Zählen von 1 bis zu einer Ganzzahl… in Binär

13

Intro:

Ich erinnere mich, als ich ein Kind war, bekam ich einen Taschenrechner und drückte weiter auf den +Knopf, um zu sehen, wie hoch ich zählen konnte. Jetzt programmiere ich gerne und entwickle für iOS.

Zählen ist sowohl für Menschen als auch für Computer eine grundlegende Fähigkeit. Ohne sie kann der Rest der Mathematik nicht durchgeführt werden. Es wird einfach getan, indem man bei beginnt 1und es wiederholt hinzufügt 1.

Die Herausforderung:

Dies ist nur eine einfache Herausforderung. Ich möchte, dass Ihr Programm von dem druckt 1, was Integeres benötigt. Ich werde jedoch eine Wendung hineinwerfen, da das Zählen von Dezimalstellen ein bisschen langweilig ist:

Die Zählung kann nicht zur Basis 10 gehören, sondern muss sich als binär erweisen.

Wenn Sie also mit 32-Bit-Ganzzahlen bis 5 zählen, sieht das folgendermaßen aus:

0000 0000 0000 0000 0000 0000 0000 0001 ..... 1
0000 0000 0000 0000 0000 0000 0000 0010 ..... 2
0000 0000 0000 0000 0000 0000 0000 0011 ..... 3
0000 0000 0000 0000 0000 0000 0000 0100 ..... 4
0000 0000 0000 0000 0000 0000 0000 0101 ..... 5

Es ist ein Computer. Sie wissen am besten, was binär ist. Ihre Eingabe kann entweder eine 32-Bit- oder eine 64-Bit-Ganzzahl sein. Es liegt wirklich an Ihnen. Wenn Sie jedoch 32-Bit-Ganzzahlen verwenden, muss Ihre Ausgabe aus 32-Bit-Ganzzahlen in Binärform bestehen . Wenn Sie 64-Bit-Ganzzahlen verwenden, muss Ihre Ausgabe aus 64-Bit-Ganzzahlen in Binärform bestehen .

Beispieleingabe:

eine 32-Bit-Ganzzahl, 5

Beispielausgabe:

0000 0000 0000 0000 0000 0000 0000 0001
0000 0000 0000 0000 0000 0000 0000 0010
0000 0000 0000 0000 0000 0000 0000 0011
0000 0000 0000 0000 0000 0000 0000 0100
0000 0000 0000 0000 0000 0000 0000 0101

Wertung:

Ihre Punktzahl entspricht der Anzahl der Bytes, die Ihr Code enthält. Da dies Code Golf ist, gewinnt die niedrigste Punktzahl.

Bonuspunkte:

Wenn Sie in der Ausgabe anzeigen, dass es sich bei der Zahl um eine Zahl zur Basis 10 handelt (z. B. ist die Zahl 0000 0000 0000 0000 0000 0000 0000 0001in Binärzahl gleich der Zahl zur Basis 10 1), multiplizieren Sie Ihre Punktzahl mit 0.8.

Wenn Sie 4 Stellen der Ausgabe wie ich gruppieren, multiplizieren Sie Ihre Punktzahl mit 0.8(erneut). Dies ist nicht erforderlich.

Nicht aufrunden und nicht abrunden. Ihre Punktzahl ist eine Gleitkommazahl.

Viel Glück!

code-golf DDPWNAGE
quelle
Müssen Sie die Ziffern in durch Leerzeichen getrennten Viererblöcken eingeben?
xnor
@xnor Nein. Ich habe es aus Gründen der Lesbarkeit getan, aber ich werde auch eine Bonusmöglichkeit dafür einschließen.
DDPWNAGE
Was ist, wenn ich einen Datentyp mit unbegrenzter Größe verwende ( intz. B. Python 3 )?
isaacg
@isaacg Geben Sie an, ob Ihr Programm 32- oder 64-Bit-Ganzzahlen verwendet. Sie müssen keine Ganzzahlen berücksichtigen, die außerhalb der Grenzen liegen. Sie müssen nur das ausgeben, was Sie eingegeben haben. Mit anderen Worten, die Wahl liegt bei Ihnen.
DDPWNAGE
4
Was ist, wenn unsere Sprache etwas anderes verwendet, wie 30-Bit-Ganzzahlen (Haskell) oder Ganzzahlen mit willkürlicher Genauigkeit (J)?
FUZxxl

Antworten:

14

APL, 10 Zeichen

Ein weiterer in APL. Angenommen ⎕IO←1(Standardeinstellung). Keine Bonuspunkte. Liest die Nummer vom Eingabegerät. Wenn Ihre APL 64-Bit-Ganzzahlen anstelle von 32-Bit-Ganzzahlen verwendet, ersetzen Sie 32 nach Bedarf durch 64.

Beachten Sie, dass APL transparent in Gleitkommazahlen konvertiert, wenn der Bereich einer Ganzzahl überschritten wird. Es ist schwierig, genau zu sagen, mit welcher Ganzzahlgröße APL arbeitet.

⍉(32⍴2)⊤⍳⎕

Erläuterung

2          ⍝ the number 2
32⍴2       ⍝ a vector of 32 twos.
(32⍴2)⊤X   ⍝ X represented as base 2 to 32 digits precision
⍳X         ⍝ a vector of the integers from 1 to X
⎕          ⍝ a number queried from the terminal
(32⍴2)⊤⍳⎕  ⍝ the output we want, flipped by 90°
⍉(32⍴2)⊤⍳⎕ ⍝ the output we want in correct orientation (⍉ is transpose)
FUZxxl
quelle
sieht so aus, als hätte ich mich nicht so sehr anstrengen sollen, um die 4 Gruppierungen zu bekommen haha
Protist
@protist Versuche nicht, Bonuspunkte zu bekommen, die zu schwer umzusetzen sind. Die Mühe lohnt sich fast nie.
FUZxxl
Bei der Frage, die speziell für die Anzahl der Bytes und nicht für die Anzahl der Zeichen gestellt wurde, sollte die Bewertung 20 Bytes betragen.
Ankh-Morpork
@ dohaqatar7 Es gibt Codierungen von APL (wie Codepage 907 ), die den gesamten APL-Zeichensatz in ein Byte einpassen . Es gibt einige APL-Erweiterungen, die mit den herkömmlichen APL-Codepages nicht codiert werden können, aber ich verwende keine davon.
FUZxxl
7

JavaScript ( ES6 ) 56.8 (71 * 0.8)

32-Bit-Version, da JavaScript keine 64-Bit-Genauigkeit unterstützt (höchstens 53 Bit bei Verwendung von Gleitkommadoppelwerten)

Ohne Gruppierung

f=n=>{for(i=0;i++<n;)console.log((8*(8<<26)+i).toString(2).slice(1),i)}

Mit Gruppierung - Punktzahl 60.16 (94 * .64)

f=n=>{for(i=0;i++<n;)console.log((8*(8<<26)+i).toString(2).slice(1).match(/..../g).join` `,i)}

Test in jedem Browser (ES5)

function f(n)
{
  for(i=0;i++<n;)console.log((8*(8<<26)+i).toString(2).substr(1).match(/..../g).join(' '),i)
}

// Test
console.log = function(x,y) { O.innerHTML += x+' '+y+'\n' }
Count to: <input id=I><button onclick="O.innerHTML='';f(+I.value)">-></button>
<pre id=O></pre>
Erweitern Sie das Snippet

edc65
quelle
6

Pyth, 18 × 0,8 × 0,8 = 11,52 Bytes

VSQjd+c.[64.BN\04N

Beispielausgabe:

0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0001 1
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0010 2
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0011 3
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0100 4
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0101 5
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0110 6
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0111 7
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 1000 8
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 1001 9
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 1010 10
orlp
quelle
2
@ DPWNAGE Geben Sie anderen Leuten etwas Zeit, um sich zu messen, bevor Sie eine Antwort annehmen :)
orlp
Okay, ich habe darüber nachgedacht, es vorübergehend zu akzeptieren, damit die Leute wissen, was sie schlagen sollen.
DDPWNAGE
2
@DDPWNAGE Denken Sie daran, dass Sie eine Antwort nicht so einfach ablehnen können, nachdem Sie sie akzeptiert und einige Stunden gewartet haben.
FUZxxl
4

Pyth, 19 * 0,8 * 0,8 = 12,16 Bytes

VSQjd+cjk.[032.BN4N

Beispielausgabe für Eingabe 5:

0000 0000 0000 0000 0000 0000 0000 0001 1
0000 0000 0000 0000 0000 0000 0000 0010 2
0000 0000 0000 0000 0000 0000 0000 0011 3
0000 0000 0000 0000 0000 0000 0000 0100 4
0000 0000 0000 0000 0000 0000 0000 0101 5

Demonstration.

isaacg
quelle
4

Python 2, 48 * 0,8 = 38,4

i=0;exec"i+=1;print format(i,'032b'),i;"*input()

Konvertiert eine Zahl in eine Binärzahl, konvertiert sie mithilfe der Zeichenfolgenformatierung in eine Binärzahl mit 32 Stellen und gibt dann auch die Dezimalzahl für den Bonus aus. Verwendet eine execSchleife zum Inkrementieren von 1zum Eingabewert.

xnor
quelle
Schöne lösung! Ich glaube nicht , es wurde angegeben, aber dies wird in der 32-Bit - Bereich auf eine große Anzahl fehlschlagen: OverflowError: repeated string is too long. Ich bin mir nicht sicher, ob das eine Beschränkung nur für meine Maschine ist.
Kade,
4

APL, 23,68 (37 × .8 × .8)

{⎕←(⍕⍵),⍨⊃,/,/' ',⍨⍕¨8 4⍴(32⍴2)⊤⍵}¨⍳⎕
Protist
quelle
3

KDB (Q), 50 × 0,8 × 0,8 = 32

Ich bin ein bisschen traurig über meine Einsendung :( Es sollte einen besseren Weg geben, dies zu tun!

{-1{" "sv raze@'string(0N 4#0b vs x),x}@'1+til x;}

Erläuterung

                                         1+til x     / counting
   {                                  }@'            / lambda each
                      (0N 4#0b vs x),x               / convert to binary and join with input
    " "sv raze@'string                               / convert to string, concatenate each string and join with space
{-1                                             ;}   / print and surpress output in lambda

Prüfung

q){-1{" "sv raze@'string(0N 4#0b vs x),x}@'1+til x;}5
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0001 1
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0010 2
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0011 3
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0100 4
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0101 5
WooiKent Lee
quelle
2
Nun, Sie können in K fallen;)k){-1{" "/:,/'$:(0N 4#0b\:x),x}@'1+!x}
Protist
3

Common Lisp, 96.0

Ergebnis: (* 150 .8 .8)

(lambda(y)(flet((p(n &aux(x(format()"~39,'0b ~:*~d"n)))(dolist(p'(4 9 14 19 24 29 34))(setf(aref x p)#\ ))(princ x)(terpri)))(dotimes(i y)(p(1+ i)))))

Beispiel

Aufruf der Funktion mit 10:

0000 0000 0000 0000 0000 0000 0000 0001 1
0000 0000 0000 0000 0000 0000 0000 0010 2
0000 0000 0000 0000 0000 0000 0000 0011 3
0000 0000 0000 0000 0000 0000 0000 0100 4
0000 0000 0000 0000 0000 0000 0000 0101 5
0000 0000 0000 0000 0000 0000 0000 0110 6
0000 0000 0000 0000 0000 0000 0000 0111 7
0000 0000 0000 0000 0000 0000 0000 1000 8
0000 0000 0000 0000 0000 0000 0000 1001 9
0000 0000 0000 0000 0000 0000 0000 1010 10

Erläuterung

(format()"~39,'0b ~:*~d" #b101010101010) gibt:

"000000000000000000000000000101010101010 2730"

Die Zwischenzeichenfolge (ein Array) wird geändert, um ein Leerzeichen an die folgenden auf Null basierenden Indizes zu setzen: 4 9 14 19 24 29 34. Anschließend wird sie gedruckt.

Beachten Sie, dass das anscheinend unkomplizierte (format t"~39,'0,' ,4:b ~:*~d" #b101010101010)Format nicht das tut, was wir wollen. Es druckt:

00000000000000000000000001010 1010 1010 2730

(die Polsterung ist nicht nach 4 gruppiert)

Core-Dump
quelle
3

Rubin, 28 (35 * 0,8)

?1.upto(*$*){|x|puts"%.32b #{x}"%x}
addison
quelle
3

C 97 × 0,8 × 0,8 = 62,08

a,x;main(b){for(scanf("%u",&b);a++<b;printf("%d\n",a))for(x=32;x--;)printf("%*d",x%-4-2,a>>x&1);}

Beispielausgabe für Eingabe "5":

0000 0000 0000 0000 0000 0000 0000 0001 1
0000 0000 0000 0000 0000 0000 0000 0010 2
0000 0000 0000 0000 0000 0000 0000 0011 3
0000 0000 0000 0000 0000 0000 0000 0100 4
0000 0000 0000 0000 0000 0000 0000 0101 5
0000 0000 0000 0000 0000 0000 0000 0110 6
0000 0000 0000 0000 0000 0000 0000 0111 7
0000 0000 0000 0000 0000 0000 0000 1000 8
0000 0000 0000 0000 0000 0000 0000 1001 9

Ich könnte ein weiteres Leerzeichen hinzufügen, um die Dezimalzahlen von den Binärzahlen zu trennen, aber technisch erfordert das Problem es nicht, denke ich? EDIT: Danke, CL!

Lynn
quelle
1
Im Übrigen können Sie ersetzen x%-4-1mit x%-4-2dem Raum zwischen den binären und dezimal ohne zusätzliche Byte Kosten hinzuzufügen. (Dies würde auch das zusätzliche Leerzeichen am Anfang jeder Zeile
beseitigen
2

Oktave, 23 Zeichen

dec2bin(1:input(""),32)

Beispielausgabe für Eingabe 5:

ans =
00000000000000000000000000000001
00000000000000000000000000000010
00000000000000000000000000000011
00000000000000000000000000000100
00000000000000000000000000000101
user0815
quelle
2

MatLab, 19 Bytes

@(x)dec2bin(1:x,32)

MatLab hat einen eingebauten Dezimal-Binär-Konverter und druckt das Ergebnis automatisch aus.

Robby
quelle
1
Hiermit werden keine 32-Bit / 64-Bit-Ganzzahlen gedruckt.
user0815
Entschuldigung, danke für die Hinweise. Ich habe den Code entsprechend geändert.
Robby
Diese Antwort ist nahezu identisch mit der Oktavantwort .
Alex A.
2

Julia, 42 Bytes

Dies ist etwas kürzer ohne die Boni.

n->for i=1:n println(lpad(bin(i),64,0))end

Dadurch wird eine unbenannte Funktion erstellt, die eine Ganzzahl annimmt und die Binärdarstellung jeder Zahl von 1 bis n ausgibt , wobei jede mit Nullen bis 64 Zeichen aufgefüllt bleibt.

Mit Boni sind 78 Bytes * 0,8 * 0,8 = 49,92

n->for i=1:n for j=1:4:64 print(lpad(bin(i),64,0)[j:j+3]*" ")end;println(i)end

Dadurch wird eine unbenannte Funktion erstellt, die eine Ganzzahl annimmt und die Binärdarstellung wie zuvor ausgibt. Diesmal wird sie in 4er-Gruppen aufgeteilt, wobei die Zahl zur Basis 10 am Ende gehört.

Alex A.
quelle
2

Common Lisp, Punktzahl: 64.0

100 Bytes * 0,8 * 0,8

Ich bin ziemlich zufrieden mit meiner Punktzahl, aber ich bin trotzdem der Meinung, dass es eine Möglichkeit geben sollte, meinen Code ein wenig zu vereinfachen.

Ausgabe

0000 0000 0000 0000 0000 0000 0000 0001  1
0000 0000 0000 0000 0000 0000 0000 0010  2
0000 0000 0000 0000 0000 0000 0000 0011  3
0000 0000 0000 0000 0000 0000 0000 0100  4
0000 0000 0000 0000 0000 0000 0000 0101  5
0000 0000 0000 0000 0000 0000 0000 0110  6
0000 0000 0000 0000 0000 0000 0000 0111  7
0000 0000 0000 0000 0000 0000 0000 1000  8
0000 0000 0000 0000 0000 0000 0000 1001  9
0000 0000 0000 0000 0000 0000 0000 1010  10

Code

(defun r(n)(dotimes(i n)(format t"~{~a~a~a~a ~}~a~%"(coerce(format()"~32,'0B"(1+ i))'list)(1+ i))))

Erläuterung

Wie in der Antwort von coredump beschrieben , die Formatzeichenfolge

"~32,'0B"

gibt base2-Zahlen aus, aber es scheint keine Möglichkeit zu geben, die Gruppierung auch richtig zu machen. Daher zwinge ich den String in eine Liste und iteriere darüber, indem ich 4er-Gruppen mit diesem Format-String auswähle:

"~ {~ a ~ a ~ a ~ a ~} ~ a ~%"

Nach jeder 4er-Gruppe wird ein Leerzeichen angezeigt, und nach der letzten Gruppe wird die base10-Nummer gedruckt.

Ohne Gruppierung (60x0,8 => 48,0)

(defun r(n)(dotimes(i n)(format t"~32,'0B ~:*~a~%"(1+ i))))

Dies verwendet ~: *, um das (einzelne) Formatargument erneut zu verarbeiten.

Florian Patzl
quelle
1

PHP, 51,84 (81 × .8 × .8)

32-Bit-Version, da PHP unter Windows auf nur 32-Bit beschränkt ist, unabhängig davon, ob das Betriebssystem 64-Bit ist.

Nimmt ein Befehlszeilenargument an.

for($i=0;$i++<$argv[1];)echo chunk_split(str_pad(decbin($i),32,0,0),4," ")."$i\n";
rink.attendant.6
quelle
1

CoffeeScript, 60,8 (76 × .8)

32-Bit-Version für aus den oben genannten Gründen , da CoffeeScript bis auf JavaScript kompiliert wird.

f=(x)->console.log(("0".repeat(32)+i.toString 2).slice(-32),i)for i in[1..x]

Mit der Gruppierung wird es etwas länger: 64,64 (101 × .8 × .8)

f=(x)->console.log(("0".repeat(32)+i.toString 2).slice(-32).match(/.{4}/g).join(" "),i)for i in[1..x]
rink.attendant.6
quelle
1

Haskell, 56 Bytes

f n=putStr$unlines$take n$tail$sequence$replicate 32"01"

Verwendung:

*Main> f 5 
00000000000000000000000000000001
00000000000000000000000000000010
00000000000000000000000000000011
00000000000000000000000000000100
00000000000000000000000000000101

Ersetzen Sie für 64-Bit die 32durch 64. Jede andere Nummer funktioniert auch.

nimi
quelle
1

J, 20 Bytes

(32#2)#:>:i.".1!:1<1

Probenein- und ausgabe:

3
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 0 1
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
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 1
gar
quelle
1

Swift: 98,56 (154 * 0,8 * 0,8)

for x in 1...Int(Process.arguments[1].toInt()!){var p=String(x,radix:2)
let q=count(p)
for i in 0..<32-q{p=(((q+i)%4==0) ?"0 ":"0")+p}
println("\(p) \(x)")}
addison
quelle
1

Ruby, 64 Bit

70 * 0,8 * 0,8 = 44,8 Byte (geteilt, dezimal)

1.upto(gets.to_i){|i|puts ("%064d"%i.to_s 2).scan(/.{4}/)*?\s+" #{i}"}

51 * 0,8 = 40,8 Bytes (dezimal)

1.upto(gets.to_i){|i|puts "%064d"%i.to_s(2)+" #{i}"}

67 * 0,8 = 53,6 Byte (geteilt)

1.upto(gets.to_i){|i|puts "%064d"%i.to_s(2).scan/.{4}/}

44 Bytes (keine Boni)

1.upto(gets.to_i){|i|puts "%064d"%i.to_s(2)}
klatschen
quelle
1

05AB1E , 13 11 Bytes

Lb32jsäð0:»

-2 Bytes dank @ Mr.Xcoder .

Ausgaben ohne Leerzeichen oder laufende Nummer.

Probieren Sie es online aus.

Erläuterung:

L              # List of range [1,input]
               #  i.e. 5 → [1,2,3,4,5]
 b             # Convert each to a binary string
               #  i.e. [1,2,3,4,5] → ['1','10','11','100','101']
  32j          # Join everything together with a minimum length per item of 32,
               # which basically prepends spaces to make it length 32
               #  i.e. ['1','10','11','100','101'] → '                               1                              10                              11                             100                             101'
     sä        # Split it into the input amount of parts
               #  i.e. 5 → ['                               1','                              10','                              11','                             100','                             101']
       ð0:     # Replace every space with a 0
               #  i.e. '                             101' → '00000000000000000000000000000101'
          »    # Join everything together by newlines (and output implicitly)
Kevin Cruijssen
quelle
1
Lb32jsäð0:» arbeitet für 11 Bytes
Mr. Xcoder
@ Mr.Xcoder Danke, habe völlig vergessen, das Voranstellen zu verwenden j, damit es die richtige Länge wird.
Kevin Cruijssen