Herausforderung:

Akzeptieren Sie in der Programmiersprache Ihrer Wahl eine Ganzzahl als Eingabe in Basis 10 und geben Sie sie in negadezimaler Notation aus , die auch als Basis -10 bezeichnet wird

Beispielalgorithmus:

Dies ist ein aus Wikipedia entnommener Algorithmus, um die Basis 10 in eine beliebige negative Basis in VB.NET umzuwandeln :

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

Natürlich können Sie jeden Algorithmus verwenden, solange er die Herausforderung erfüllt

Beispiel Ein- / Ausgänge:

Eingang:

12

Ausgabe:

192

Ein anderes Beispiel:

Eingang:

2048

Ausgabe:

18168

Regel:

Sie dürfen keine in Ihre Programmiersprache integrierten Methoden verwenden, die dieses Problem lösen

Dies ist ein Code-Golf , also gewinnt der kürzeste Code!

JavaScript (ES6), 51 45 37 Bytes

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

Testfälle

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 Bytes

_ì ìAn)¥U}a

Online testen!

Erläuterung

_ì ì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

Batch, 82 Bytes

@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

Die Teilung des Stapels wird auf Null gekürzt. Wenn der Rest negativ ist, muss ich zum Ausgleich 1 addieren (und auch 10 zum Rest addieren). Die Ziffern werden dann akkumuliert, %2bis das Ergebnis Null wird.

Gelee , 9 Bytes

Dḅ-10=ð1#

Dies ist eine Brute-Force-Umkehrung der Negadezimal-Ganzzahl-Umwandlung.

Probieren Sie es online!

Wie es funktioniert

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 Bytes

Lel es hat das Weinen Emoji drin.

fqQijT;_;

Test Suite .

Python 3, 35 Bytes

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

Python-Port von Arnauld's Algorithmus.

Alternativ für 102 Bytes eine generische Funktion unter Verwendung des Algorithmus des ursprünglichen Posts:

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 ""

Gelee , 10 Bytes

:⁵NµÐĿ%⁵ṚḌ

Probieren Sie es online!

Hintergrund

Das Konvertieren einer Liste nicht negativer Werte von der Basis b in eine Ganzzahl kann durch Linksfaltung mit der Funktion x, y ↦ bx + y erfolgen . Um eine Ganzzahl in die Basis b umzuwandeln , müssen wir diese Funktion einfach umkehren, dh einen Ausdruck für bx + y ↦ x, y finden .

In Python (und damit Jelly) ist das Ergebnis des Modulo-Operators immer nicht negativ, also (bx + y)% | b | = y .

Außerdem wird die Ganzzahldivision immer abgerundet, um sicherzustellen, dass bei q = n / d und r = n% d die Gleichheit n = qd + r gilt. Wenn s das Vorzeichen von b ist , dann (sx) | b | + y = bx + y , also sx = (bx + y) / | b | und deshalb ist s ((bx + y) / | b |) = x.

Wie es funktioniert

:⁵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 Byte

Dies ist eine Vorlagensprache, an der ich gearbeitet habe.
Es ist keineswegs zum Golfen gedacht.
Es fehlt sogar die komplette Grundrechenart, aber es erlaubt winzige PHP-Ausschnitte direkt zu schreiben.
Dies funktioniert um dieses Problem herum.

{@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}

Dies wirft eine Reihe von Warnungen.
Der Code wird in PHP "kompiliert".

Ungolfed, mit Trash Whitespace:

{@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}

Bei Bedarf kann eine schrittweise Erklärung hinzugefügt werden, aber ich glaube, dass dies ziemlich einfach ist.

Haftungsausschluss :

Das letzte Commit war zum Zeitpunkt des Schreibens dieser Antwort am 2017-01-07 20:36 UTC + 00: 00.
Dies funktioniert bei Commit 140e56ff38f45fa4fd40fd3ec382094e707b1bad vom 2017-01-06 23:27 UTC + 00: 00.
Dies ist die Version, die zum Ausführen dieser Antwort verwendet wird.

Der PHP-Code ist unter https://raw.githubusercontent.com/ismael-miguel/SimpleTemplate/140e56ff38f45fa4fd40fd3ec382094e707b1bad/SimpleTemplate.php verfügbar

Ich empfehle dies mit der letzten Version auszuführen, aber diese funktioniert gut für diese Frage.

Wie läuft man?

Erstellen Sie eine Datei mit dem Code und führen Sie sie folgendermaßen aus:

<?php

    include 'path/to/SimpleTemplate.php';

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

    $template->render(<number>);

Der Wert wird dann auf dem Bildschirm angezeigt.

PHP, 71 67 Bytes

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

oder 62 Bytes für einen Port von Arnauld's Antwort :

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

Mathematica, 49 Bytes

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

Definiert eine Funktion, ddie ein ganzzahliges Argument verwendet und eine Zeichenfolge zurückgibt. Ein rekursiver Algorithmus - sieht aus wie der gleiche Algorithmus in Arnauld's Antwort . Es funktioniert auch mit negativen Zahlen. (Es gibt die leere Zeichenfolge intsead von "0" zurück, wenn die Eingabe 0 ist.) Hinweis für Mathematica-Golfer: Die Verwendung ±erfordert einen zusätzlichen Satz von Klammern und scheint daher nicht kürzer zu sein.

C 68 Bytes

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

Anstatt die resultierende Zahl zu drucken, gibt das Programm sie einfach zurück. Offensichtlich ist dies die Antwort von Arnauld. Der einzige Unterschied besteht darin, dass C keine interpretierte Sprache ist. Ich hatte das Gefühl, dass ich es zu einem vollständigen Programm machen sollte, anstatt nur zu einer Funktion.

Rust, 88 Bytes

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}}

Dies ist nur eine rekursive Version des in der Frage angegebenen Algorithmus.