Défi:

Dans le langage de programmation de votre choix, acceptez un entier comme entrée dans la base 10 et sortez-le dans la notation négadécimale , également connue sous le nom de base -10

Exemple d'algorithme:

Il s'agit d'un algorithme tiré de Wikipedia pour convertir la base 10 en n'importe quelle base négative dans VB.NET :

Function toNegativeBase(Number As Integer , base As Integer) As System.Collections.Generic.List(Of Integer)

    Dim digits As New System.Collections.Generic.List(Of Integer)
    while Number <> 0
        Dim remainder As Integer= Number Mod base
        Number = CInt(Number / base)

        if remainder < 0 then
            remainder += system.math.abs(base)
            Number+=1
        end if

        digits.Insert(0, remainder)
    end while

    return digits
end function

De toute évidence, vous pouvez utiliser n'importe quel algorithme, tant qu'il répond au défi

Exemples d'entrées / sorties:

Contribution:

12

Production:

192

Un autre exemple:

Contribution:

2048

Production:

18168

Règle:

Vous ne devez pas utiliser de méthodes intégrées pour résoudre ce problème qui existent dans votre langage de programmation

C'est un code-golf , donc le code le plus court gagne!

JavaScript (ES6), 51 45 37 octets

f=n=>n&&n%10+((k=n<0)+f(k-n/10|0))*10

Cas de test

f=n=>n&&n%10+((k=n<0)+f(k-n/10|0))*10

console.log("12 -> " + f(12))
console.log("2048 -> " + f(2048))

Japt , 11 octets

_ì ìAn)¥U}a

Testez-le en ligne!

Explication

_ì ìAn)¥U}a  // Implicit: U = input integer, A = 10
_        }a  // Return the smallest non-negative integer Z that returns a truthy value
             // when run through this function:
 ì           //   Convert Z to a list of its base 10 digits.
   ìAn)      //   Interpret this as a list of base -10 digits and convert to a base 10 integer.
       ¥U    //   Return (the result == U).
             // Implicit: output result of last expression

Lot, 82 octets

@set/a"d=%1%%10,n=%1/-10-(a=d>>4),d-=a*10
@if %n% neq 0 %0 %n% %d%%2
@echo %d%%2

La division de Batch est tronquée à zéro, donc si le reste est négatif, je dois ajouter 1 (et également ajouter 10 au reste) pour compenser. Les chiffres sont ensuite accumulés %2jusqu'à ce que le résultat devienne nul.

Gelée , 9 octets

Dḅ-10=ð1#

Il s'agit d'un inverse de force brute de la conversion de nombres négatifs en nombres entiers.

Essayez-le en ligne!

Comment ça fonctionne

Dḅ-10=ð1#  Main link. Argument: n

      ð    Combine the links to the left into a chain and start a new, dyadic
           chain with left and right argument n.
       1#  Repeatedly execute the chain with left argument k = n, n + 1, ... and
           right argument n until the first match is found.
D          Convert k to decimal.
 ḅ-10      Convert the result from base -10 to integer.
     =     Compare the result with n.

Pyth - 9 octets

Lel, il y a des emoji qui pleurent.

fqQijT;_;

Suite de tests .

Python 3, 35 octets

f=lambda n:n and n%10+f(0-n//10)*10

Port Python de l' algorithme d' Arnauld .

Alternativement, pour 102 octets une fonction générique utilisant l'algorithme du poste d'origine:

def f(n,b,r=0):
 if n:
  r,n=n%b,n//b
  if r<0:r+=abs(b);n+=1
  return f(n,b,r)+str(r)
 else:return ""

Gelée , 10 octets

:⁵NµÐĿ%⁵ṚḌ

Essayez-le en ligne!

Contexte

La conversion d'une liste de valeurs non négatives de la base b en nombre entier peut être obtenue en repliant vers la gauche par la fonction x, y ↦ bx + y . Pour convertir un entier en base b , nous devons simplement inverser cette fonction, c'est-à-dire trouver une expression pour bx + y ↦ x, y .

En Python (et, par extension, Jelly), le résultat de l'opérateur modulo est toujours non négatif, donc (bx + y)% | b | = y .

De plus, la division entière arrondit toujours vers le bas, en s'assurant que si q = n / d et r = n% d , l'égalité n = qd + r est vérifiée . Si s est le signe de b , alors (sx) | b | + y = bx + y , donc sx = (bx + y) / | b | et, par conséquent, s ((bx + y) / | b |) = x.

Comment ça fonctionne

:⁵NµÐĿ%⁵ṚḌ  Main link. Argument: n

   µ        Combine the links to the left into a monadic chain.
    ÐĿ      Iteratively apply the chain until the results are no longer unique.
            Collect all unique results in an array.
:⁵            Divide the previous return value (initially n) by 10.
  N           Negate; multiply the result by -1.
      %⁵    Take all results modulo 10.
        Ṛ   Reverse the results.
         Ḍ  Convert from base 10 to integer.

SimpleTemplate , 147 octets

Il s'agit d'un langage de modèle sur lequel je travaille.
En aucun cas, il est destiné au golf.
Il manque même des mathématiques de base complètes, mais il permet d'écrire directement de minuscules extraits de PHP.
Cela fonctionne autour de ce problème.

{@setN argv.0}{@whileN}{@setM N}{@php$DATA[N]=($DATA[M]/-10)|0;$DATA[R]=$DATA[M]%-10}{@ifR is lower0}{@incby10 R}{@incN}{@/}{@setD R,D}{@/}{@echoD}

Cela lance un tas d'avertissements.
Le code est "compilé" en PHP.

Non golfé, avec un espace pour les déchets:

{@set no argv.0}
{@while no}
    {@set temp_no no}
    {@php $DATA["no"] = ($DATA["temp_no"] / -10) | 0}
    {@php $DATA["remainder"] = $DATA["temp_no"] % 10}

    {@if remainder is lower than 0}
        {@inc by 10 remainder}
        {@inc no}
    {@/}
    {@set digits remainder, digits}
{@/}
{@echo digits}

Si nécessaire, une explication par étape peut être ajoutée, mais je pense que c'est assez simple.

Clause de non - responsabilité :

Le dernier commit, au moment de la rédaction de cette réponse, était le 2017-01-07 20:36 UTC + 00: 00.
Cela fonctionne sur commit 140e56ff38f45fa4fd40fd3ec382094e707b1bad du 2017-01-06 23:27 UTC + 00: 00.
C'est la version utilisée pour exécuter cette réponse.

Le code PHP est disponible sur https://raw.githubusercontent.com/ismael-miguel/SimpleTemplate/140e56ff38f45fa4fd40fd3ec382094e707b1bad/SimpleTemplate.php

Je recommande de l'exécuter avec la dernière version, mais celle-ci fonctionne bien pour cette question.

Comment courir?

Créez un fichier avec le code et exécutez-le comme ceci:

<?php

    include 'path/to/SimpleTemplate.php';

    $template = new SimpleTemplate('<code>');

    $template->render(<number>);

La valeur sera alors affichée à l'écran.

PHP, 71 67 octets

for(;$n=&$argn;$n=$g-$n/10|0)$d=($r=$n%10)+10*($g=$r<0).$d;echo+$d;

ou 62 octets pour un port de la réponse d'Arnauld :

function n($n){return$n?$n%10+(($k=$n<0)+f($k-$n/10|0))*10:0;}

Mathematica, 49 octets

d@0="";d@n_:=d[-Floor[n/10]]<>ToString[n~Mod~10];

Définit une fonction dprenant un argument entier et retournant une chaîne. Un algorithme récursif - ressemble au même algorithme dans la réponse d'Arnauld . Cela fonctionne également sur les nombres négatifs. (Il retourne la chaîne vide au lieu de "0" si l'entrée est 0.) Remarque pour les golfeurs Mathematica: l'utilisation ±requiert un jeu de parenthèses supplémentaire et ne semble donc pas être plus courte.

C, 68 octets

main(f,a){f&&scanf("%d",&a);f=a?a%10+((f=a<0)+main(0,f-a/10))*10:0;}

Au lieu d'imprimer le numéro résultant, le programme le renvoie simplement. Évidemment, c'est la réponse d'Arnauld , la seule différence est que, puisque C n'est pas un langage interprété, je pensais que je devrais en faire un programme complet plutôt qu'une simple fonction.

Rouille, 88 octets

fn g(mut n:i32)->i32{let mut r=n%10;n/=-10;if r<0{r+=10;n+=1;}if n==0{r}else{r+g(n)*10}}

Ceci est juste une version récursive de l'algorithme fourni dans la question.