Contando de 1 a um número inteiro… em binário

13

Introdução:

Lembro que quando eu era criança, pegava uma calculadora e continuava pressionando o +botão, e via o quanto eu podia contar. Agora, gosto de programar e estou desenvolvendo para iOS.

Contar é uma habilidade fundamental para humanos e computadores. Sem ele, o resto da matemática não pode ser feito. Isso é feito simplesmente iniciando 1e adicionando repetidamente 1a ele.

O desafio:

Este é apenas um desafio simples. O que eu gostaria que o seu programa fizesse é imprimir do 1que for Integernecessário. No entanto, vou dar uma guinada nele, já que a contagem decimal é meio chata:

A contagem não pode estar na base 10, deve mostrar-se contando em binário.

Portanto, para contar até 5, usando números inteiros de 32 bits, ficaria assim:

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

É um computador. Eles sabem melhor o binário. Sua entrada pode ser um número inteiro de 32 ou 64 bits. É realmente com você. No entanto, se você usar números inteiros de 32 bits, sua saída deverá ser um número inteiro de 32 bits em binário e se você usar números inteiros de 64 bits, sua saída deverá ser números inteiros de 64 bits em binário .

Entrada de amostra:

um inteiro de 32 bits, 5

Saída de amostra:

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

Pontuação:

Sua pontuação é igual a quantos bytes seu código tiver. Como este é o Code Golf, a pontuação mais baixa vence.

Pontos bônus:

Se você mostrar, na saída, o número que está no número 10 base (por exemplo, 0000 0000 0000 0000 0000 0000 0000 0001em binário é igual à base 10 1), multiplique sua pontuação por 0.8.

Se você agrupar 4 dígitos da saída, como eu fiz, multiplique sua pontuação por 0.8(novamente). Isso não é necessário.

Não arredondar para cima nem para baixo. Sua pontuação é um número de ponto flutuante.

Boa sorte!

code-golf 
— DDPWNAGE
fonte
Você precisa colocar os dígitos em pedaços de quatro separados por espaços?
— Xnor
@ xnor Não. Fiz a legibilidade, mas também incluirei uma oportunidade de bônus.
— DDPWNAGE 17/07/2015
E se eu usar um tipo de dados de tamanho ilimitado (Python 3, intpor exemplo)?
— Isaacg
@isaacg Especifique se o seu programa usa números inteiros de 32 ou 64 bits. Você não precisa acomodar os números inteiros que estão fora dos limites; você só precisa produzir o que inseriu. Em outras palavras, a escolha é sua.
— DDPWNAGE 17/07/2015
4
E se nosso idioma usa algo diferente, como números inteiros de 30 bits (Haskell) ou números inteiros de precisão arbitrários (J)?
— FUZxxl 17/07/2015

Respostas:

14

APL, 10 caracteres

Outro em APL. Supõe ⎕IO←1(o padrão). Sem pontos de bônus. Lê o número do dispositivo de entrada. Se o seu APL usar números inteiros de 64 bits em vez de números inteiros de 32 bits, substitua 64 por 32 conforme necessário.

Observe que o APL converte de forma transparente em números de ponto flutuante quando o intervalo de um número inteiro é excedido. Portanto, é difícil dizer exatamente com qual tamanho inteiro o APL trabalha.

⍉(32⍴2)⊤⍳⎕

explicação

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
Parece que eu não deveria ter tentado tão difícil de obter os 4 agrupamentos haha
— protista
@ Protist Não tente obter pontos de bônus que são muito difíceis de implementar. Quase nunca vale a pena o esforço.
— FUZxxl 17/07/2015
A pergunta solicitada especificamente para uma contagem de bytes em vez de caracteres, portanto, a pontuação deve ser de 20 bytes.
— Ankh-morpork 19/07/2015
@ dohaqatar7 Existem codificações de APL (como a página de código 907 ) que ajustam todo o conjunto de caracteres da APL em um byte. Existem algumas extensões de APL que não podem ser codificadas com as páginas de código tradicionais de APL, mas eu não as uso.
— FUZxxl 19/07/2015
7

JavaScript ( ES6 ) 56,8 (71 * 0,8)

Versão de 32 bits, pois o JavaScript não suporta precisão de 64 bits (no máximo 53 bits usando dobras de ponto flutuante)

Sem agrupamento

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

Com agrupamento - pontuação 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)}

Teste em qualquer navegador (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>
Expandir snippet

— edc65
fonte
6

Pitão, 18 * 0,8 * 0,8 = 11,52 bytes

VSQjd+c.[64.BN\04N

Exemplo de saída:

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 Dê a outras pessoas algum tempo para competir antes de aceitar uma resposta :)
— orlp
Tudo bem, eu estava pensando em aceitá-lo temporariamente, para que as pessoas saibam o que vencer.
— DDPWNAGE 17/07/2015
2
@DDPWNAGE Lembre-se de que você não pode aceitar uma resposta facilmente depois de aceitar uma resposta e esperar algumas horas.
— FUZxxl 17/07/2015
4

Pitão, 19 * 0,8 * 0,8 = 12,16 bytes

VSQjd+cjk.[032.BN4N

Exemplo de saída para a entrada 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

Demonstração.

— isaacg
fonte
4

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

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

Converte um número em binário, usa formatação de string para convertê-lo em binário com 32 dígitos e também imprime o número decimal do bônus. Usa um execloop para incrementar do 1valor de entrada.

— xnor
fonte
Ótima solução! Eu não acredito que tenha sido especificado, mas isso vai falhar em grande número na faixa de 32 bits: OverflowError: repeated string is too long. Não tenho certeza se isso é apenas um limite para minha máquina.
— Kade
4

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

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

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

Sinto-me um pouco triste com a minha submissão :( Deve haver uma maneira melhor de fazer isso!

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

Explicação

                                         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

Teste

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
bem, você pode cair em K;)k){-1{" "/:,/'$:(0N 4#0b\:x),x}@'1+!x}
— protist
3

Lisp comum, 96,0

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

Exemplo

Chamando a função com 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

Explicação

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

"000000000000000000000000000101010101010 2730"

A cadeia intermediária (uma matriz) é modificada para colocar um caractere de espaço nos seguintes índices baseados em zero: 4 9 14 19 24 29 34. Em seguida, é impressa.

Observe que o (format t"~39,'0,' ,4:b ~:*~d" #b101010101010)formato aparentemente simples não faz o que queremos. Imprime:

00000000000000000000000001010 1010 1010 2730

(o preenchimento não é agrupado por 4)

— coredump
fonte
3

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

Exemplo de saída para a entrada "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

Eu poderia adicionar mais um caractere de espaço em branco para separar os números decimais dos números binários, mas tecnicamente o problema não exige isso, eu acho? EDIT: Obrigado, CL!

— Lynn
fonte
1
Aliás, você pode substituir x%-4-1por x%-4-2para adicionar o espaço entre o binário e o decimal sem custo adicional de bytes. (Isso também eliminaria o espaço extra no início de cada linha.)
— CL- 18-15
2

Oitava, 23 caracteres

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

Exemplo de saída para a entrada 5:

ans =
00000000000000000000000000000001
00000000000000000000000000000010
00000000000000000000000000000011
00000000000000000000000000000100
00000000000000000000000000000101
— user0815
fonte
2

MatLab, 19 bytes

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

Não muito para este, o MatLab possui um conversor decimal para binário e imprime automaticamente o resultado.

— Robby
fonte
1
Isso não imprime números inteiros de 32 bits / 64 bits.
— user0815
Desculpe, obrigado pelo aviso. Eu mudei o código de acordo.
— Robby
Essa resposta é quase inteiramente idêntica à resposta da oitava .
— Alex A.
2

Julia, 42 bytes

Isso é um pouco mais curto sem os bônus.

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

Isso cria uma função sem nome que pega um número inteiro e imprime a representação binária de cada número de 1 a n , cada esquerda preenchida com zeros a 64 caracteres.

Com bônus, 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

Isso cria uma função sem nome que pega um número inteiro e imprime a representação binária como antes, desta vez dividida em grupos de 4 com o número na base 10 no final.

— Alex A.
fonte
2

Lisp comum, pontuação: 64.0

100 bytes * 0,8 * 0,8

Estou muito feliz com minha pontuação, mas ainda sinto que deve haver uma possibilidade de simplificar um pouco meu código.

Resultado

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

Código

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

Explicação

Conforme descrito na resposta de coredump , a string de formato

"~32,'0B"

gera números base2, mas parece não haver possibilidade de obter o agrupamento correto também. Portanto, eu coagir a string em uma lista e iterar sobre ela escolhendo grupos de 4 com esta string de formato:

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

Depois de cada grupo de 4, há um espaço em branco e, após o último grupo, o número da base10 é impresso.

Sem agrupamento (60x0.8 => 48.0)

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

Isso usa ~: * para processar o argumento de formato (único) novamente.

— Florian Patzl
fonte
1

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

Versão de 32 bits, como o PHP é limitado a apenas 32 bits no Windows, independentemente de o sistema operacional ser de 64 bits.

Leva um argumento de linha de 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 × 0,8)

Versão de 32 bits pelos motivos mencionados acima , conforme o CoffeeScript é compilado em JavaScript.

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

Com o agrupamento, ele se torna um pouco mais longo: 64,64 (101 × 0,8 × 0,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 bytes

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

Uso:

*Main> f 5 
00000000000000000000000000000001
00000000000000000000000000000010
00000000000000000000000000000011
00000000000000000000000000000100
00000000000000000000000000000101

Para 64 bits, substitua 32por 64. Todos os outros números também funcionam.

— nimi
fonte
1

J, 20 bytes

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

Entrada e saída de amostra:

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

Ruby, 64 bits

70 * 0,8 * 0,8 = 44,8 bytes (dividido, decimal)

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

51 * 0,8 = 40,8 bytes (decimal)

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

67 * 0,8 = 53,6 bytes (dividido)

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

44 bytes (sem bônus)

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

05AB1E , 13 11 bytes

Lb32jsäð0:»

-2 bytes graças a @ Mr.Xcoder .

Saídas sem delimitador de espaço nem número de sequência.

Experimente online.

Explicação:

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:»trabalha para 11 bytes
— Sr. Xcoder
@ Mr.Xcoder Obrigado, esqueci completamente de usar o jprefix para que ele se torne o comprimento correto.
— Kevin Cruijssen
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.