Introducción:

Recuerdo que cuando era niño, obtenía una calculadora y seguía presionando el +botón, y veía hasta qué punto podía contar. Ahora, me gusta programar, y estoy desarrollando para iOS.

Contar es una habilidad fundamental tanto para humanos como para computadoras. Sin ella, el resto de las matemáticas no se pueden hacer. Se hace simplemente comenzando en 1y añadiéndole repetitivamente 1.

El reto:

Esto no es más que un simple desafío. Lo que me gustaría que hiciera su programa es imprimir desde 1lo Integerque sea necesario. Sin embargo, le daré un giro, ya que el conteo decimal es un poco aburrido:

El recuento no puede estar en la base 10, tiene que mostrarse contando en binario.

Entonces, para contar hasta 5, usando enteros de 32 bits, se vería así:

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 una computadora. Ellos saben binario mejor. Su entrada puede ser un entero de 32 bits o de 64 bits. Realmente depende de usted. Sin embargo, si usa números enteros de 32 bits, su salida debe ser números enteros de 32 bits en binario , y si usa números enteros de 64 bits, su salida debe ser números enteros de 64 bits en binario .

Entrada de muestra:

un entero de 32 bits, 5

Salida de muestra:

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

Puntuación:

Su puntaje es igual a la cantidad de bytes que tenga su código. Como se trata de Code Golf, gana la puntuación más baja.

Puntos extra:

Si muestra, en la salida, el número en el que se encuentra como número base 10 (por ejemplo, 0000 0000 0000 0000 0000 0000 0000 0001en binario es igual a la base 10 1), multiplique su puntaje por 0.8.

Si agrupa 4 dígitos de salida como lo hice yo, multiplique su puntaje por 0.8(nuevamente). Esto no es obligatorio.

No redondee ni redondee hacia abajo. Tu puntaje es un número de coma flotante.

¡Buena suerte!

APL, 10 caracteres

Otro en APL. Asume ⎕IO←1(el valor predeterminado). No hay puntos de bonificación. Lee el número del dispositivo de entrada. Si su APL usa enteros de 64 bits en lugar de enteros de 32 bits, sustituya 64 por 32 según sea necesario.

Observe que APL se convierte transparentemente en números de punto flotante cuando se excede el rango de un entero. Por lo tanto, es difícil decir exactamente con qué tamaño entero funciona APL.

⍉(32⍴2)⊤⍳⎕

explicación

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)

JavaScript ( ES6 ) 56.8 (71 * 0.8)

Versión de 32 bits, ya que JavaScript no puede manejar la precisión de 64 bits (a lo más 53 bits utilizando dobles puntos de coma flotante)

Sin agrupar

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

Con agrupación - puntaje 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)}

Prueba en cualquier 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>

Pyth, 18 * 0.8 * 0.8 = 11.52 bytes

VSQjd+c.[64.BN\04N

Salida de ejemplo:

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

Pyth, 19 * 0.8 * 0.8 = 12.16 bytes

VSQjd+cjk.[032.BN4N

Ejemplo de salida para la 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

Demostración.

Python 2, 48 * 0.8 = 38.4

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

Convierte un número en binario, utiliza el formato de cadena para convertirlo en binario con 32 dígitos, y luego también imprime el número decimal para la bonificación. Utiliza un execbucle para incrementar desde 1el valor de entrada.

CJam, 13.44 (21 × 0.64)

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

Pruébalo en línea.

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

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

KDB (Q), 50 * 0.8 * 0.8 = 32

Me siento un poco triste con mi presentación :( ¡Debería haber una mejor manera de hacer esto!

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

Explicación

                                         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

Prueba

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

Lisp común, 96.0

Puntuación: (* 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)))))

Ejemplo

Llamando a la función 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

Explicación

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

"000000000000000000000000000101010101010 2730"

La cadena intermedia (una matriz) se modifica para poner un carácter de espacio en los siguientes índices basados ​​en cero: 4 9 14 19 24 29 34. Luego se imprime.

Tenga en cuenta que el (format t"~39,'0,' ,4:b ~:*~d" #b101010101010)formato aparentemente sencillo no hace lo que queremos. Imprime:

00000000000000000000000001010 1010 1010 2730

(el relleno no está agrupado por 4)

Rubí, 28 (35 * 0.8)

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

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

Ejemplo de salida para la 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

Podría agregar un carácter de espacio en blanco más para separar los números decimales de los números binarios, pero técnicamente el problema no lo requiere, creo. EDITAR: Gracias, CL!

Octava, 23 caracteres

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

Ejemplo de salida para la entrada 5:

ans =
00000000000000000000000000000001
00000000000000000000000000000010
00000000000000000000000000000011
00000000000000000000000000000100
00000000000000000000000000000101

MatLab, 19 bytes

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

No demasiado para este, MatLab tiene un convertidor decimal a binario incorporado e imprime automáticamente el resultado.

Julia, 42 bytes

Esto es un poco más corto sin las bonificaciones.

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

Esto crea una función sin nombre que toma un número entero e imprime la representación binaria de cada número del 1 al n , cada uno rellenado con ceros a 64 caracteres.

Con bonos, 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

Esto crea una función sin nombre que toma un número entero e imprime la representación binaria como antes, esta vez dividida en grupos de 4 con el número en la base 10 al final.

Common Lisp, puntuación: 64.0

100 bytes * 0.8 * 0.8

Estoy bastante contento con mi puntaje, pero aún siento que debería existir la posibilidad de simplificar un poco mi código.

Salida

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

Explicación

Como se describe en la respuesta de coredump , la cadena de formato

"~32,'0B"

genera números de base2 pero parece que tampoco existe la posibilidad de agrupar correctamente. Por lo tanto coacciono la cadena en una lista e itero sobre ella seleccionando grupos de 4 con esta cadena de formato:

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

Después de cada grupo de 4 hay un espacio en blanco, y después del último grupo, se imprime el número base10.

Sin agrupación (60x0.8 => 48.0)

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

Esto usa ~: * para procesar el argumento de formato (único) nuevamente.

PHP, 51.84 (81 × .8 × .8)

Versión de 32 bits, ya que PHP está limitado a solo 32 bits en Windows, independientemente de si el sistema operativo es de 64 bits.

Toma un argumento de línea de comando.

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

CoffeeScript, 60.8 (76 × .8)

Versión de 32 bits por las razones mencionadas anteriormente , ya que CoffeeScript se compila en JavaScript.

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

Con la agrupación se vuelve un poco más larga: 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]

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, reemplace el 32con 64. Todos los demás números también funcionan.

J, 20 bytes

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

Muestra de entrada y salida:

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

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

Ruby, 64 bit

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 (sin bonificaciones)

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

05AB1E , 13 11 bytes

Lb32jsäð0:»

-2 bytes gracias a @ Mr.Xcoder .

Salidas sin delimitador de espacio ni número de secuencia.

Pruébalo en línea.

Explicación:

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)