Arkaplan :

Herhangi bir önceden hazırlanmış temel dönüştürme işlevi kullanmadan temel 10 sayılarını temel 2'ye dönüştürmek için bir görev aldınız. İçe aktarılan kitaplıkları da kullanamazsınız.

Sorun :

Bir giriş dizesini taban 10'dan (ondalık) taban 2'ye (ikili) dönüştürün. Önceden hazırlanmış temel dönüşüm kodunu / işlevlerini / yöntemlerini veya içe aktarılan kitaplıkları kullanamazsınız. Bu kod golf olduğundan , bayt cinsinden en kısa cevap kazanacaktır.

Giriş, -32768 ile 32767 arasında herhangi bir şey olacaktır (kodunuza işaret bayt işlemeyi dahil edin)

GolfScript - 17 bayt

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

Yerleşik olandan çok daha ayrıntılı değil ~2base.

JavaScript, 46

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

Brainf * ck, 98 77

Açıkçası bu kazanma amacıyla değil, eğer bir brainfk çözümü olmasaydı bir rekabet ne olurdu?

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

Brainfk sadece 8 bit tamsayıları işleyebildiğinden ve negatif olmadığından, kurallara tam olarak uymadığını, ancak bunu kazanmak için asla orada değildim.

Tercümanınız destekliyorsa bu aslında 16 bit giriş için işe yarar

ASCII değerlerinde çıktı bile aldım

Açıklamalı kod şöyledir:

++[>++++<-]                       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

Daha kısa algoritma (77):

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

Bu sadece 8 bit tamsayıları işleyebilir.

Algoritma, aslında çok kısa olan bir ikili sayaç kullanarak çalışır (bir artış daha >[->]++[-<+]-<-sonra bitleri ortaya koyar. Sorun tüm bitleri yazdırmanın zor olmasıdır

Bu son algoritma, bayt pahasına herhangi bir sayıda bite uyacak şekilde uyarlanabilir. N bit tamsayıları ile başa çıkabilmek için 53 + 3 * N bayt kodlaması gerekir.

örnekler:

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

Zorunlu APL yanıtı - 21 22

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

Örnekler:

      "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 Makine Kodu, 272 bayt

Her zamanki gibi, burada tanımlanan kural tablosu sözdizimini kullanıyorum .Bu sitede veya alternatif olarak bu java uygulamasını kullanarak test edebilirsiniz .

Kodun birçoğu ondalık-onaltılı dönüştürücümden buraya kopyalandı .

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

Taban 2'de 0'dan sayım yaparken taban 10'daki girişten geri sayar. Sıfırın azaltılmasıyla giriş bloğunu siler ve sonlanır.

Javascript 59

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

Perl, 44

Bu benim ilk Perl programım, bu yüzden bu kolayca golf daha aşağı olabilir eğer beni affet. Düzenleme: Cevabımdan 7 karakter aldığınız için @primo'ya teşekkür ederim.

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

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

Mantık aslında önceki C çözümümle aynı.

Ayrıca, 64 bit kullanır.

Javascript - 56 48 ve 36 28 karakter

• Negatif sayılarla çalışmaz.

8 karakter tıraş ettiği için @Blender'a teşekkürler.

Bu form girdi alır ve çıktıyı gösterir, 48 karakter:

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

Bir değişkeni aikili değişkene sokan bir talimat xgerekiyorsa (ve xdeğeri bir yan etki olarak yok etmekle uğraşmazsanız ), burada 28 karakter vardır:

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

Python - 61 60 karakter

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

C, 55 karakter

Fazladan bir sıfır basar (2 bayt uğruna).
İçinde özyinelemeprintf yazdırma sırasını tersine çevirir, böylece algoritma bitleri sağdan sola çıkarır, ancak soldan sağa yazdırır.

EDIT : putcharyerine bir karakter kaydetti printf.

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

Dyalog APL , 11 bayt

2|⌊⎕÷2*⌽⍳16

2|Ve yarıya bölünmesi kalan
⌊yuvarlak aşağı değer
⎕girişi
÷, her bölünen
2*her gücüne iki
⍳16 {0, 1, 2, ..., 15}

gerektirir ⎕IO←0Birçok sistemde varsayılan olanı .

TryAPL çevrimiçi!

C, 81

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

Çıktıda 16 bit vardır (dolgu sıfırları dahil)

Apps Komut + Google E, 147 144 121 bayt

Senaryo

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

yaprak

=j(b1)

Bu komut dosyasının ZygD tarafından değiştirilmiş versiyonu .

Haskell, 66 bayt

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

İle arayın b "-1023", main=interact btam bir program ekleyin veya Ideon'da deneyin.

cpozitif tamsayılar için dönüşüm gerçekleştirir.
b r=show.c.read$rbir dizeyi sayıya cdönüştürür , uygular ve dizeye geri dönüştürür.
b('-':r)='-':b rolası bir -satır aralığı çıkarır ve sonuca yeniden ekler.

PowerShell, 59 87 82 70 bayt

Negatif sayıları desteklemek için +28 bayt.
Yalnızca @ ASCII sayesinde -12 bayt

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

Çevrimiçi deneyin!

Bu koddan uyarlanmıştır . Komut satırı parametresi ile girdi alır -d.

APL (NARS), 17 karakter, 34 bayt

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

Bu, Adam'ın /codegolf//a/90107 kodunun bir bit biti için parametre ekleyebilmesi ve bu işlev için ⎕IO (burada ⎕IO = 1) önemi yok ...

  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 

Kolayca bit sayısını bu şekilde işlemek (son sonucun doğru olması gerektiğini kontrol ettim)

Smalltalk (Smalltalk / X), 63/78

ilk sürüm bir ara dize (78) oluşturur:

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

aslında, dizeyi oluşturmaya gerek yoktur; sadece karakterleri çıktı (63):

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

mhmh - bir numarayı okumanın daha kısa bir yolu var mı?

Python 3.x: 65 karakter

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]

Ortam değişkeninden komut dosyasına bir giriş değeri iletin n. İkili sonucun ondalık gösterimi aşılamaz LONG_MAX.

Bu aynı zamanda ksh93ve zsheğer bve ebunlar ile başlatılırsa uyumlu olmalı 0ve uygun aritmetik genişleme kullanılmalıdır.

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

Bu yöntem ondalığı ikiliye dönüştürür 64 bitlere .

Linqpad'de yukarıdaki yöntem yürütüldüğünde - rr = p (-32768); rr.Dump ();

Çıktı: 01111111111111111111111111111111111111111111111111000000000000000

Java 8, 80 71 bayt

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

Yorumlarda bir kural nedeniyle -9 bayt. Negatif baz-10 girişleri, pozitif / mutlak baz-2 değerini görünüşte çıktı olarak döndürebilir.

Açıklama:

Çevrimiçi deneyin.

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 bayt

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

Çevrimiçi deneyin!

Küçük Temel , 133 bayt

TextWindowKonsola giriş ve çıkış yapan bir komut dosyası .

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

SmallBasic.com adresinde deneyin Silverlight gerektirir ve bu nedenle IE'de çalıştırılmalıdır.

G / Ç siyah konsoldan alınır / verilir.

@Neil sayesinde -22 bayt

MATL , 15 17 bayt

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

MATL Online'da deneyin

TIO

(Negatif sayılar için önde gelen 0'ı kaldıran +2 bayt, işaret biti ilk bit olmalıdır.)

MATL Online'da çıktı aşağıdan yukarıya okunmalıdır (MSB altta).

Ana kısım oldukça basittir: `2&\t= değer 0'dan büyükken, 2'ye bölün ve kalanları biriktirin.

Negatif sayıları ele almak ve onlara 2'nin tamamlayıcı temsilini vermek zor kısımdı. Sonunda ben "ile çıkarma ile gitti$2^N$"Bir sayının ikisinin tamamlayıcısını alma yöntemi. Yalnızca -32768'e kadar değerleri işlememiz gerektiğinden, negatif sayılar için kod oluşturur $2^{16} = 65536$ile 16Wgirişi ekler (örn. 65536 + (-42)); bu, MATLAB'ın pozitif bir sayı olarak gördüğü, ancak girişin imzalı ikili gösterimini 16 bit biçiminde temsil ettiği anlamına gelir.

C (gcc) , 50 43 bayt

Tavan kedisi sayesinde -7 bayt .

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

Çevrimiçi deneyin!

PowerShell , 43 bayt

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

Çevrimiçi deneyin!

> <> ,  34  33 bayt

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

Çevrimiçi deneyin!