Intro:

Ricordo che da bambino prendevo una calcolatrice e continuavo a premere il +pulsante per vedere quanto potevo contare. Ora mi piace programmare e sto sviluppando per iOS.

Il conteggio è un'abilità fondamentale sia per l'uomo che per il computer. Senza di essa, il resto della matematica non può essere fatto. È fatto semplicemente avviando 1e aggiungendo ripetutamente 1ad esso.

La sfida:

Questa è solo una semplice sfida. Quello che vorrei che il tuo programma facesse è stampare da 1qualunque cosa Integeresso accetti. Tuttavia, ci proverò, dato che il conteggio decimale è un po 'noioso:

Il conteggio non può essere nella base 10, deve mostrarsi conteggio in binario.

Quindi, per contare fino a 5, usando numeri interi a 32 bit, sarebbe simile al seguente:

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

È un computer. Conoscono meglio i binari. L'input può essere un numero intero a 32 o 64 bit. Dipende davvero da te. Tuttavia, se si utilizzano numeri interi a 32 bit, l'output deve essere numeri interi a 32 bit in formato binario e se si utilizzano numeri interi a 64 bit, l'output deve essere numeri interi a 64 bit in formato binario .

Input di esempio:

un numero intero a 32 bit, 5

Uscita campione:

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

punteggio:

Il tuo punteggio è uguale a quanti byte è il tuo codice. Dato che si tratta di Code Golf, vince il punteggio più basso.

Punti bonus:

Se mostri, nell'output, il numero è come un numero di base 10 (ad esempio, 0000 0000 0000 0000 0000 0000 0000 0001in binario è uguale alla base 10 1), moltiplica il tuo punteggio per0.8 .

Se raggruppate 4 cifre di output come ho fatto io, moltiplicate il punteggio per 0.8(di nuovo). Questo non è richiesto.

Non arrotondare e non arrotondare. Il tuo punteggio è un numero in virgola mobile.

In bocca al lupo!

code-golf

— DDPWNAGE
fonte

Devi mettere le cifre in blocchi di quattro separati da spazi?

— xnor

@xnor No. L'ho fatto per leggibilità, ma includerò anche un'opportunità bonus per quello.

— DDPWNAGE,

Cosa succede se utilizzo un tipo di dati di dimensioni illimitate ( intad esempio Python 3 )?

— Isaacg,

@isaacg Specifica se il programma utilizza numeri interi a 32 o 64 bit. Non devi accontentarti di quegli interi che sono fuori limite; devi solo produrre ciò che inserisci. In altre parole, la scelta è tua.

— DDPWNAGE,

4

E se la nostra lingua utilizzasse qualcosa di diverso, come numeri interi a 30 bit (Haskell) o numeri arbitrari di precisione (J)?

— FUZxxl,

14

APL, 10 caratteri

Un altro in APL. Presuppone ⎕IO←1(impostazione predefinita). Nessun punto bonus. Legge il numero dal dispositivo di input. Se il tuo APL utilizza numeri interi a 64 bit invece di numeri interi a 32 bit, sostituisci 64 per 32 secondo necessità.

Si noti che APL converte in modo trasparente in numeri in virgola mobile quando viene superato l'intervallo di un numero intero. È difficile quindi dire esattamente con quale APL di dimensioni intere funziona.

⍉(32⍴2)⊤⍳⎕

spiegazione

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
fonte

sembra che non avrei dovuto sforzarmi tanto per ottenere i 4 gruppi ahah

— protista il

@protista Non cercare di ottenere punti bonus che sono troppo difficili da implementare. Non vale quasi mai la pena.

— FUZxxl,

La domanda ha richiesto specificamente un conteggio dei byte anziché un carattere, quindi il punteggio dovrebbe essere di 20 byte.

— ankh-morpork,

@ dohaqatar7 Esistono codifiche di APL (come la tabella codici 907 ) che si adattano all'intero set di caratteri APL in un byte. Esistono alcune estensioni APL che non possono essere codificate con le tradizionali tabelle codici APL, ma non ne uso nessuna.

— FUZxxl,

7

JavaScript ( ES6 ) 56.8 (71 * 0.8)

Versione a 32 bit, poiché JavaScript non è in grado di gestire la precisione a 64 bit (al massimo 53 bit utilizzando i doppi in virgola mobile)

Senza raggruppamento

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

Con raggruppamento: punteggio 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 qualsiasi 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>

Espandi frammento

— edc65
fonte

6

Pyth, 18 * 0,8 * 0,8 = 11,52 byte

VSQjd+c.[64.BN\04N

Esempio di output:

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
fonte

2

@DDPWNAGE Concedi alle altre persone un po 'di tempo per competere prima di accettare una risposta :)

— orlp

Bene, stavo pensando di accettarlo temporaneamente, quindi le persone sanno cosa battere.

— DDPWNAGE,

2

@DDPWNAGE Ricorda che non puoi facilmente accettare una risposta dopo aver accettato una risposta e atteso qualche ora.

— FUZxxl,

4

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

VSQjd+cjk.[032.BN4N

Esempio di output per l'ingresso 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

Dimostrazione.

— isaacg
fonte

4

Python 2, 48 * 0.8 = 38.4

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

Converte un numero in binario, utilizza la formattazione di stringa per convertirlo in binario con 32 cifre, quindi stampa anche il numero decimale per il bonus. Utilizza un execloop per incrementare dal 1valore di input.

— XNOR
fonte

Bella soluzione! Non credo che è stato specificato, ma questo mancherò sui grandi numeri nella gamma a 32 bit: OverflowError: repeated string is too long. Non sono sicuro se questo sia un limite solo per la mia macchina.

— Kade,

4

CJam, 13.44 (21 × 0.64)

ri{)_2b64Ue[4/S*S@N}/

Provalo online.

— Dennis
fonte

4

APL, 23.68 (37 × .8 × .8)

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

— protista
fonte

3

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

Mi sento un po 'triste con la mia presentazione :( Dovrebbe esserci un modo migliore per farlo!

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

Spiegazione

                                         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

Test

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
fonte

2

bene puoi cadere in K;)k){-1{" "/:,/'$:(0N 4#0b\:x),x}@'1+!x}

— protista il

3

Lisp comune, 96.0

Punto: (* 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)))))

Esempio

Chiamare la funzione con 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

Spiegazione

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

"000000000000000000000000000101010101010 2730"

La stringa intermedia (un array) viene modificata per inserire un carattere spazio nei seguenti indici a base zero: 4 9 14 19 24 29 34. Quindi viene stampato.

Si noti che il (format t"~39,'0,' ,4:b ~:*~d" #b101010101010)formato apparentemente semplice non fa ciò che vogliamo. Stampa:

00000000000000000000000001010 1010 1010 2730

(l'imbottitura non è raggruppata per 4)

— coredump
fonte

3

Rubino, 28 (35 * 0,8)

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

— Addison
fonte

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

Esempio di output per l'ingresso "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

~~Potrei aggiungere un altro carattere di spazio per separare i numeri decimali dai numeri binari, ma tecnicamente il problema non lo richiede, penso?~~ EDIT: Grazie, CL!

— Lynn
fonte

1

Per inciso è possibile sostituire x%-4-1con x%-4-2per aggiungere lo spazio tra binario e decimale senza costi di byte aggiuntivi. (Ciò eliminerebbe anche lo spazio extra all'inizio di ogni riga.)

— CL-

2

Ottava, 23 caratteri

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

Esempio di output per l'ingresso 5:

ans =
00000000000000000000000000000001
00000000000000000000000000000010
00000000000000000000000000000011
00000000000000000000000000000100
00000000000000000000000000000101

— user0815
fonte

2

MatLab, 19 byte

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

Non troppo per questo, MatLab ha un convertitore da decimale a binario incorporato e stampa automaticamente il risultato.

— Robby
fonte

1

Questo non stampa numeri interi a 32-bit / 64-bit.

— user0815,

Scusa, grazie per l'heads up. Ho modificato il codice di conseguenza.

— Robby,

Questa risposta è quasi del tutto identica alla risposta di Ottava .

— Alex A.

2

Julia, 42 byte

Questo è un po 'più breve senza i bonus.

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

Questo crea una funzione senza nome che accetta un numero intero e stampa la rappresentazione binaria di ogni numero da 1 a n , ciascuno a sinistra imbottito con zeri a 64 caratteri.

Con bonus, 78 byte * 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

Questo crea una funzione senza nome che accetta un numero intero e stampa la rappresentazione binaria come prima, questa volta divisa in gruppi di 4 con il numero in base 10 alla fine.

— Alex A.
fonte

2

Lisp comune, punteggio: 64,0

100 byte * 0,8 * 0,8

Sono abbastanza contento del mio punteggio, ma sento ancora che dovrebbe esserci la possibilità di semplificare un po 'il mio codice.

Produzione

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

Codice

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

Spiegazione

Come descritto nella risposta di coredump , la stringa di formato

"~32,'0B"

genera numeri di base2 ma non sembra esserci alcuna possibilità di ottenere correttamente il raggruppamento. Quindi costringo la stringa in un elenco e riporto su di essa selezionando gruppi di 4 con questa stringa di formato:

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

Dopo ogni gruppo di 4 c'è uno spazio vuoto e dopo l'ultimo gruppo, viene stampato il numero base10.

Senza raggruppamento (60x0,8 => 48,0)

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

Questo usa ~: * per elaborare nuovamente l'argomento formato (singolo).

— Florian Patzl
fonte

1

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

Versione a 32 bit, poiché PHP è limitato a soli 32 bit su Windows, indipendentemente dal fatto che il sistema operativo sia a 64 bit.

Accetta un argomento della riga di comando.

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

— rink.attendant.6
fonte

1

CoffeeScript, 60,8 (76 × .8)

Versione a 32 bit per i motivi sopra menzionati , poiché CoffeeScript viene compilato in JavaScript.

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

Con il raggruppamento diventa leggermente più lungo: 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
fonte

1

Haskell, 56 byte

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

Uso:

*Main> f 5 
00000000000000000000000000000001
00000000000000000000000000000010
00000000000000000000000000000011
00000000000000000000000000000100
00000000000000000000000000000101

Per 64 bit, sostituire il 32con 64. Anche ogni altro numero funziona.

— Nome del modello
fonte

1

J, 20 byte

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

Input e output di esempio:

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
fonte

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
fonte

1

Rubino, 64 bit

70 * 0,8 * 0,8 = 44,8 byte (diviso, decimale)

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

51 * 0,8 = 40,8 byte (decimale)

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

67 * 0.8 = 53.6 byte (diviso)

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

44 byte (nessun bonus)

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

— applaudire
fonte

1

05AB1E , 13 11 byte

Lb32jsäð0:»

-2 byte grazie a @ Mr.Xcoder .

Uscite senza delimitatore di spazio né numero di sequenza.

Provalo online.

Spiegazione:

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
fonte

1

Lb32jsäð0:»funziona per 11 byte

— Mr. Xcoder

@ Mr.Xcoder Grazie, completamente dimenticato di utilizzare jper anteporre in modo che diventi la lunghezza corretta.

— Kevin Cruijssen,

Conteggio da 1 a un intero ... in binario

Intro:

La sfida:

Input di esempio:

Uscita campione:

punteggio:

Punti bonus:

In bocca al lupo!

APL, 10 caratteri

spiegazione

JavaScript ( ES6 ) 56.8 (71 * 0.8)

Pyth, 18 * 0,8 * 0,8 = 11,52 byte

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

Python 2, 48 * 0.8 = 38.4

CJam, 13.44 (21 × 0.64)

APL, 23.68 (37 × .8 × .8)

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

Spiegazione

Test

Lisp comune, 96.0

Esempio

Spiegazione

Rubino, 28 (35 * 0,8)

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

Ottava, 23 caratteri

MatLab, 19 byte

Julia, 42 byte

Con bonus, 78 byte * 0,8 * 0,8 = 49,92

Lisp comune, punteggio: 64,0

Produzione

Codice

Spiegazione

Senza raggruppamento (60x0,8 => 48,0)

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

CoffeeScript, 60,8 (76 × .8)

Haskell, 56 byte

J, 20 byte

Swift: 98.56 (154 * 0.8 * 0.8)

Rubino, 64 bit

70 * 0,8 * 0,8 = 44,8 byte (diviso, decimale)

51 * 0,8 = 40,8 byte (decimale)

67 * 0.8 = 53.6 byte (diviso)

44 byte (nessun bonus)

05AB1E , 13 11 byte