Hintergrund :

Sie haben den Auftrag erhalten, Basis-10-Zahlen in Basis-2 zu konvertieren, ohne vorgefertigte Basis-Konvertierungsfunktionen zu verwenden. Sie können auch keine importierten Bibliotheken verwenden.

Problem :

Konvertiert eine Eingabezeichenfolge von Basis 10 (dezimal) in Basis 2 (binär). Sie dürfen keinen vorgefertigten Code / Funktionen / Methoden für die Basiskonvertierung oder importierte Bibliotheken verwenden. Da es sich um Code-Golf , wird die kürzeste Antwort in Bytes gewinnen.

Die Eingabe erfolgt in einem Bereich von -32768 bis 32767 (einschließlich der Behandlung von Vorzeichenbytes in Ihrem Code).

GolfScript - 17 Bytes

~{.1&\2/}16*;]-1%

Nicht zu viel ausführlicher als der eingebaute ~2base.

JavaScript, 46

for(x=prompt(o='');x;x>>>=1)o=(x&1)+o;alert(o)

Brainf * ck, 98 77

Dies ist natürlich nicht zum Gewinnen gedacht, aber was wäre ein Wettbewerb, wenn es keine Brainfk-Lösung gäbe?

++++[>++++<-]>>,<[->>++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>[-]++++++[->++++++++<]>.[-]>[-<<<+>>>]<<<<]

Da brainfk nur mit 8-Bit-Ganzzahlen und keinen Negativen umgehen kann, halte ich mich nicht vollständig an die Regeln, aber hey, ich war nie dabei, um es zu gewinnen.

Dies funktioniert tatsächlich für 16-Bit-Eingaben, wenn Ihr Interpreter dies unterstützt

Ich habe es sogar in ASCII-Werten ausgegeben

Hier ist der kommentierte Code:

++[>++++<-]                       preload 8 onto cell 1
>>,<                                input into cell 2
[-                                  iterate over cell 1
    >>++<                               put 2 in cell 3
    [->-[>+>>]>[+[-<+>]>+>>]<<<<<]      division algorithm: converts {n d} into {0 d_minus_n%d n%d n/d}
    >[-]++++++[->++++++++<]>           clears cell 4 and puts 48(ascii of 0) into cell 5
    .[-]                                output n%2 and clear it (the bit)
    >[-<<<+>>>]                         bring n/2 into cell 2 (to be used for division in next iteration)
<<<<]                               end iterate

Kürzere Algorithmus (77):

+>,>-<[>>[->]++[-<+]-<-]++++++++[->++++++<]>+[->+>+>+>+>+>+>+>+<<<<<<<<]>[.>]

Dieser kann nur 8-Bit-Ganzzahlen verarbeiten.

Der Algorithmus arbeitet mit einem Binärzähler, der eigentlich sehr kurz ist (ein Inkrement >[->]++[-<+]-<-legt dann die Bits fest. Das Problem ist, dass es schwierig ist, alle Bits auszudrucken

Dieser letzte Algorithmus kann auf Kosten von Bytes an eine beliebige Anzahl von Bits angepasst werden. Um mit N Bit-Ganzzahlen umgehen zu können, sind zum Codieren 53 + 3 * N Bytes erforderlich.

Beispiele:

(1 bit) +>,>-<[>>[->]++[-<+]-<-]++++++++[->++++++<]>+[->+<]>[.>]
(2 bit) +>,>-<[>>[->]++[-<+]-<-]++++++++[->++++++<]>+[->+>+<<]>[.>]
(3 bit) +>,>-<[>>[->]++[-<+]-<-]++++++++[->++++++<]>+[->+>+>+<<<]>[.>]
etc

Obligatorische APL-Antwort - 21 22

"01"[1+2|⌊⎕÷2⋆⊖0,⍳15]

Beispiele:

      "01"[1+2|⌊⎕÷2⋆⊖0,⍳15]
⎕: 0
0000000000000000
      "01"[1+2|⌊⎕÷2⋆⊖0,⍳15]
⎕: 13
0000000000001101
      "01"[1+2|⌊⎕÷2⋆⊖0,⍳15]
⎕: 9999
0010011100001111
      "01"[1+2|⌊⎕÷2⋆⊖0,⍳15]
⎕: -3
1111111111111101
      "01"[1+2|⌊⎕÷2⋆⊖0,⍳15]
⎕: 32767
0111111111111111

Turing Machine Code, 272 Byte

Wie üblich verwende ich die hier definierte Regeltabellensyntax. Sie können es auf dieser Site oder alternativ mit dieser Java-Implementierung testen .

Ein Großteil des Codes wurde von meinem Dezimal-Hex-Konverter hier kopiert .

0 * * l B
B * * l C
C * 0 r D
D * * r E
E * * r A
A _ * l 1
A * * r *
1 0 9 l 1
1 1 0 l 2
1 2 1 l 2
1 3 2 l 2
1 4 3 l 2
1 5 4 l 2
1 6 5 l 2
1 7 6 l 2
1 8 7 l 2
1 9 8 l 2
1 _ * r Y
Y * * * X
X * _ r X
X _ _ * halt
2 * * l 2
2 _ _ l 3
3 * 1 r 4
3 1 0 l 3
4 * * r 4
4 _ _ r A

Zählt von der Eingabe in Basis 10 abwärts, während von 0 in Basis 2 aufwärts gezählt wird. Wenn die Null verringert wird, wird der Eingabeblock gelöscht und beendet.

Javascript 59

o='';i=parseInt(prompt());do{o=(i&1)+o}while(i>>=1)alert(o)

Perl, 44

Dies ist mein erstes Perl-Programm überhaupt. Bitte verzeihen Sie mir, wenn dies weiter verbessert werden kann. Edit: Danke @primo, dass du 7 Zeichen von meiner Antwort entfernt hast.

$x=<>;do{@s=($x&1,@s)}while($x>>=1);print@s

$x=<>;do{push@s,$x&1}while($x>>=1);print reverse@s

Die Logik ist im Wesentlichen dieselbe wie bei meiner vorherigen C-Lösung.

Verwendet auch 64 Bit.

Javascript - 56 48 und 36 28 Zeichen

• Funktioniert nicht mit negativen Zahlen.

Vielen Dank an @Blender für das Rasieren von 8 Zeichen.

Dieses Formular akzeptiert Eingaben und zeigt Ausgaben mit 48 Zeichen:

x=prompt();for(a="";x;x=~~(x/2))a=x%2+a;alert(a)

Wenn nur eine Anweisung benötigt wird, die eine Variable in ader binären Form einer Variablen xeinfügt (und Sie sich nicht darum kümmern, den xWert als Nebeneffekt zu zerstören ), ist dies hier eine Anweisung mit 28 Zeichen:

for(a="";x;x=~~(x/2))a=x%2+a

Python - 61 60 Zeichen

x=input();print"".join("01"[x>>i&1]for i in range(15,-1,-1))

C 55 Zeichen

Gibt eine zusätzliche führende Null aus (um 2 Byte zu sparen).
Die Rekursion innerhalb printfkehrt die Druckreihenfolge um, sodass der Algorithmus die Bits von rechts nach links extrahiert, aber von links nach rechts druckt.

BEARBEITEN : Speichern eines Zeichens mit putcharanstelle vonprintf .

f(x){(x*=x<0?-printf("-"):1)&&f(x/2);putchar(48+x%2);}

Dyalog APL , 11 Bytes

2|⌊⎕÷2*⌽⍳16

2|Der verbleibende Teilungsbetrag, wenn er halbiert ist vom
⌊abgerundeten Wert
⎕der Eingabe
÷geteilt durch
2* zwei zur Potenz von
⍳16{0, 1, 2, ..., 15}

Benötigt, ⎕IO←0was auf vielen Systemen Standard ist.

TryAPL online!

C 81

char b[17];i=15;main(x){scanf("%d",&x);while(i+1)b[i--]=(x&1)+48,x>>=1;puts(b);}

Die Ausgabe hat ausschließlich 16 Bits (einschließlich Auffüllen von Nullen)

Apps Script + Google Sheets, 147 144 121 Byte

Skript

function j(decNumb){var str='';do{str=String(decNumb%2)+str;decNumb=decNumb/2|0;}while(decNumb>=1);return parseInt(str);}

Blatt

=j(b1)

Geänderte Version dieses Skripts von ZygD.

Haskell, 66 Bytes

c 0=0
c n=c(div n 2)*10+mod n 2
b('-':r)='-':b r
b r=show.c.read$r

Rufen Sie mit auf b "-1023", fügen Sie main=interact bein komplettes Programm hinzu oder probieren Sie es auf Ideon aus.

cFührt die Konvertierung für positive ganze Zahlen durch.
b r=show.c.read$rwandelt einen String in eine Zahl um, wendet ihn an cund wandelt ihn zurück in einen String. Entfernt
b('-':r)='-':b reine mögliche Führung -und hängt sie erneut an das Ergebnis an.

PowerShell, 59 87 82 70 Byte

+28 Bytes zur Unterstützung negativer Zahlen.
-12 Bytes dank nur @ ASCII

param($d)$m=$d-lt0;while($d){$n="01"[$d%2]+$n;$d=($d-$d%2)/2}'-'*$m+$n

Probieren Sie es online!

Angepasst von diesem Code . Übernimmt die Eingabe über einen Befehlszeilenparameter -d.

APL (NARS), 17 Zeichen, 34 Byte

{2∣⌊⍵÷2*(⍺-1)..0}

Es ist eine Kopie und Modifikation der Antwort von Adam /codegolf//a/90107 in der Weise, wie man den Parameter für die Bitlänge hinzufügen kann und ⎕IO für diese Funktion (hier ist hereIO = 1) sollte habe keine Bedeutung ...

  f←{2∣⌊⍵÷2*(⍺-1)..0}
  16 f 2
0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 
  32 f 2
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 
  32 f ¯1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 
  16 f ¯1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 
  64 f ¯12345678
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 0 0 1 1 1 0 0 1 1 1 1 0 1 0 1 1 0 0 1 0 

es scheint einfach zu sein, die Anzahl der Bits auf diese Weise zu handhaben (ich habe geprüft, dass das letzte Ergebnis richtig sein sollte)

Smalltalk (Smalltalk / X), 63/78

Die erste Version erzeugt eine Zwischenzeichenfolge (78):

t:=Number readFrom:Stdin.
((15to:1by:-1)collect:[:i|$0+(t>>i&1)]as:String)print

Tatsächlich ist es nicht erforderlich, die Zeichenfolge zu erstellen. Gib einfach die Zeichen aus (63):

t:=Number readFrom:Stdin.
15to:1by:-1 do:[:i|($0+(t>>i&1))print]

mhmh - gibt es eine kürzere möglichkeit, eine nummer zu lesen?

Python 3.x: 65 Zeichen

b=lambda n:n<2 and'01'[n]or b(n//2)+b(n%2);print(b(int(input())))

Bash, 44

f=b+=n/2**e%2*10**e,2**e++/n?f=b:f;echo $[f]

Übergeben Sie einen Eingabewert über die Umgebungsvariable an das Skript n. Die Dezimaldarstellung des binären Ergebnisses darf nicht überschreiten LONG_MAX.

Dies sollte auch kompatibel mit ksh93und sein, zshwenn bund einitialisiert werden 0und eine ordnungsgemäße arithmetische Erweiterung verwendet wird.

C # - 104

string p(int d){var r="";long i=1;while(r.Length<=64){var g=d&i;r=(g!=0)? "1"+r:"0"+r;i=i<<1;}return r;}

Diese Methode konvertiert dezimal in binär bis zu 64 Bits .

Bei Ausführung der obigen Methode in Linqpad - rr = p (-32768); rr.Dump ();

Ausgabe: 01111111111111111111111111111111111111111111111111000000000000000

Java 8, 80 71 Bytes

n->{String r="";for(int i=n<0?-n:n;i>0;i/=2)r=i%2+r;return n==0?"0":r;}

-9 Bytes aufgrund einer Regel in den Kommentaren. Negative Base-10-Eingänge können anscheinend den positiven / absoluten Base-2-Wert als Ausgabe zurückgeben.

Erläuterung:

Probieren Sie es online aus.

n->{                   // Method with integer parameter and String return-type
  String r="";         //  Result-String, starting empty
  for(int i=n<0?-n:n;  //  Start `i` at the absolute (non-negative) value of the input
      i>0;             //  Loop as long as `i` is not 0
      i/=2)            //    After every iteration: integer-divide `i` by 2
    r=i%2+r;           //   Prepend the result with `i` modulo-2
  return n==0?         //  If the input is 0:
          "0"          //   Return literal "0"
         :             //  Else:
          r;           //   Return the result-String

Kotlin , 82 Bytes

{s:String->{var i=s.toInt()
var r=""
(0..15).map{r="${i and 1}$r"
i=i shr 1}
r}()}

Probieren Sie es online!

Kleines Basic , 133 Bytes

Ein Skript, das Eingaben von und Ausgaben an die TextWindowKonsole ausführt.

n=TextWindow.Read()
While n>0
c=c+1
x[c]=Math.Remainder(n,2)
n=Math.Floor(n/2)
EndWhile
For i=0To c-1
TextWindow.Write(x[c-i])
EndFor

Probieren Sie es bei SmallBasic.com Benötigt Silverlight und muss daher im IE ausgeführt werden.

I / O wird von der schwarzen Konsole genommen / gegeben.

-22 Bytes dank @Neil

MATL , 15 - 17 Bytes

t0<?16Ww+]`2&\t]x

Probieren Sie es auf MATL Online aus

TIO

(+2 Bytes, wobei führende 0 für negative Zahlen entfernt wird. Das Vorzeichenbit sollte das erste Bit sein.)

Die Ausgabe in MATL Online sollte von unten nach oben gelesen werden (MSB befindet sich unten).

Der Hauptteil ist ziemlich einfach: `2&\t = Wenn der Wert größer als 0 ist, dividiere durch 2 und akkumuliere die Reste.

Der Umgang mit negativen Zahlen und die Darstellung der 2er-Komplemente war der schwierige Teil. Am Ende ging ich mit dem " subtrahieren aus$2^N$"Methode zum Ermitteln des Zweierkomplements einer Zahl. Da wir nur Werte bis -32768 verarbeiten müssen, erstellt der Code für negative Zahlen $2^{16} = 65536$with 16W, fügt den Eingang zu dem hinzu (zB 65536 + (-42)), was etwas ergibt, das MATLAB als positive Zahl ansieht, aber die vorzeichenbehaftete Binärdarstellung des Eingangs in 16-Bit-Form darstellt.

C (gcc) , 50 43 Bytes

-7 bytes dank ceilingcat .

f(n){printf("-%d"+(~n?n&&f(n/2),1:0),n&1);}

Probieren Sie es online!

PowerShell , 43 Byte

param($n)15..0|%{$r+='01'[($n-shr$_)%2]}
$r

Probieren Sie es online!

> <> ,  34  33 Bytes

|!/?=0:,2-}:%2:+***"  @"(0:
n{\~{

Probieren Sie es online!