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!

code-golf DDPWNAGE
fuente

¿Tienes que poner los dígitos en trozos de cuatro separados por espacios?

xnor

@xnor No. Lo hice para facilitar la lectura, pero también incluiré una oportunidad de bonificación por eso.

DDPWNAGE

¿Qué sucede si uso un tipo de datos de tamaño ilimitado (Python 3, intpor ejemplo)?

isaacg

@isaacg Especifique si su programa usa enteros de 32 o 64 bits. No tiene que acomodar esos enteros que están fuera de los límites; solo tiene que generar lo que ingresó. En otras palabras, la elección es tuya.

DDPWNAGE

44

¿Qué sucede si nuestro idioma usa algo diferente, como enteros de 30 bits (Haskell) o enteros de precisión arbitraria (J)?

FUZxxl

14

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)

FUZxxl
fuente

Parece que no debería haber intentado tanto para obtener las 4 agrupaciones jaja

protista

@protist No intente obtener puntos de bonificación que son demasiado difíciles de implementar. Casi nunca vale la pena el esfuerzo.

FUZxxl

La pregunta pedía específicamente un recuento de bytes en lugar de caracteres, por lo que la puntuación debería ser de 20 bytes.

ankh-morpork

@ dohaqatar7 Hay codificaciones de APL (como la página de códigos 907 ) que se ajustan a todo el conjunto de caracteres APL en un byte. Hay algunas extensiones APL que no se pueden codificar con las páginas de códigos APL tradicionales, pero no uso ninguna de ellas.

FUZxxl

7

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>

Expandir fragmento

edc65
fuente

6

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

orlp
fuente

2

@DDPWNAGE Dele a otras personas algo de tiempo para competir antes de aceptar una respuesta :)

orlp

Muy bien, estaba pensando en aceptarlo temporalmente, para que la gente sepa qué ganar.

DDPWNAGE

2

@DDPWNAGE Recuerde que no puede aceptar fácilmente una respuesta después de aceptarla y esperar unas horas.

FUZxxl

4

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.

isaacg
fuente

4

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.

xnor
fuente

Buena solución! No creo que se ha especificado, pero esto va a fallar en gran número en el rango de 32 bits: OverflowError: repeated string is too long. Sin embargo, no estoy seguro de si eso es un límite en mi máquina.

Kade

4

CJam, 13.44 (21 × 0.64)

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

Pruébalo en línea.

Dennis
fuente

4

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

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

protista
fuente

3

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

WooiKent Lee
fuente

2

bueno, puedes caer en K;)k){-1{" "/:,/'$:(0N 4#0b\:x),x}@'1+!x}

protista

3

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)

volcado de memoria
fuente

3

Rubí, 28 (35 * 0.8)

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

Addison
fuente

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

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!

Lynn
fuente

1

Por cierto, puede reemplazar x%-4-1con x%-4-2para agregar el espacio entre el binario y el decimal sin costo adicional de byte. (Esto también eliminaría el espacio extra al comienzo de cada línea).

CL-

2

Octava, 23 caracteres

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

Ejemplo de salida para la entrada 5:

ans =
00000000000000000000000000000001
00000000000000000000000000000010
00000000000000000000000000000011
00000000000000000000000000000100
00000000000000000000000000000101

usuario0815
fuente

2

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.

Robby
fuente

1

Esto no imprime enteros de 32 bits / 64 bits.

user0815

Lo siento, gracias por el aviso. He cambiado el código en consecuencia.

Robby

Esta respuesta es casi completamente idéntica a la respuesta de Octave .

Alex A.

2

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.

Alex A.
fuente

2

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.

Florian Patzl
fuente

1

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

rink.attendant.6
fuente

1

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]

rink.attendant.6
fuente

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

nimi
fuente

1

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

gar
fuente

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
fuente

1

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

aplaudir
fuente

1

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)

Kevin Cruijssen
fuente

1

Lb32jsäð0:»funciona para 11 bytes

Sr. Xcoder

@ Mr.Xcoder Gracias, olvidé por completo el uso jde anteponer para que se convierta en la longitud correcta.

Kevin Cruijssen

Contando de 1 a un entero ... en binario

Introducción:

El reto:

Entrada de muestra:

Salida de muestra:

Puntuación:

Puntos extra:

¡Buena suerte!

Respuestas:

APL, 10 caracteres

explicación

JavaScript ( ES6 ) 56.8 (71 * 0.8)

Pyth, 18 * 0.8 * 0.8 = 11.52 bytes

Pyth, 19 * 0.8 * 0.8 = 12.16 bytes

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

Explicación

Prueba

Lisp común, 96.0

Ejemplo

Explicación

Rubí, 28 (35 * 0.8)

C, 97 * 0.8 * 0.8 = 62.08

Octava, 23 caracteres

MatLab, 19 bytes

Julia, 42 bytes

Con bonos, 78 bytes * 0.8 * 0.8 = 49.92

Common Lisp, puntuación: 64.0

Salida

Código

Explicación

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

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

CoffeeScript, 60.8 (76 × .8)

Haskell, 56 bytes

J, 20 bytes

Swift: 98.56 (154 * 0.8 * 0.8)

Ruby, 64 bit

70 * 0.8 * 0.8 = 44.8 bytes (dividido, decimal)

51 * 0.8 = 40.8 bytes (decimal)

67 * 0.8 = 53.6 bytes (dividido)

44 bytes (sin bonificaciones)

05AB1E , 13 11 bytes