Los regalos han sido abiertos. Se han comido los pasteles picados. La Guerra de las Galaxias ha sido vista. La temporada navideña está comenzando a disminuir. Es probable que a estas alturas ya hayas sacado algunas galletas navideñas . Si tiene suerte, en lugar de los habituales juguetes de plástico inútiles, es posible que haya ganado una Calculadora de misterio con la que puede sorprender a sus amigos y familiares .

Este truco consta de 6 cartas cada una con una cuadrícula de números 4x8 impresa en ella. Cada tarjeta contiene un subconjunto diferente de los enteros [1,63]. El mago le pedirá que elija un número de una tarjeta y mantenga ese número en secreto. El mago entonces preguntará qué cartas tienen ese número. Con ese conocimiento, el mago mágicamente podrá determinar y revelar el número original adivinado.

Imprima el conjunto completo de 6 tarjetas de Mystery Calculator exactamente de la siguiente manera:

 1  3  5  7  9 11 13 15
17 19 21 23 25 27 29 31
33 35 37 39 41 43 45 47
49 51 53 55 57 59 61 63
 - - - - - - - - - - -
 2  3  6  7 10 11 14 15
18 19 22 23 26 27 30 31
34 35 38 39 42 43 46 47
50 51 54 55 58 59 62 63
 - - - - - - - - - - -
 4  5  6  7 12 13 14 15
20 21 22 23 28 29 30 31
36 37 38 39 44 45 46 47
52 53 54 55 60 61 62 63
 - - - - - - - - - - -
 8  9 10 11 12 13 14 15
24 25 26 27 28 29 30 31
40 41 42 43 44 45 46 47
56 57 58 59 60 61 62 63
 - - - - - - - - - - -
16 17 18 19 20 21 22 23
24 25 26 27 28 29 30 31
48 49 50 51 52 53 54 55
56 57 58 59 60 61 62 63
 - - - - - - - - - - -
32 33 34 35 36 37 38 39
40 41 42 43 44 45 46 47
48 49 50 51 52 53 54 55
56 57 58 59 60 61 62 63

La salida puede o no contener una nueva línea final final. No debe haber espacios en blanco al final. Cada tarjeta está separada por 11 -perforaciones.

• md5sum con nueva línea final: 7aa2d9339b810ec62a2b90c5e11d6f4a
• md5sum sin nueva línea final: e9abe4e32dca3e8fbfdaa4886fc5efd2

Para aquellos de ustedes con una orientación más de Windows, también permitiré CRLFterminaciones de línea de estilo. En ese caso, los md5 son:

• md5sum con nueva línea final: e4f16ff9752eee2cedb5f97c7b5aec6d
• md5sum sin nueva línea final: 78c560eed3b83513e3080117ab5dc5fa

Python 2 , 99 96 93 91 bytes

k=1
while 1:print('%2d '*7+'%2d\n')*4%tuple(n for n in range(64)if k&n),11/(k<32)*' -';k*=2

Sale con un error, que está permitido por defecto .

Pruébalo en línea! o verificar el hash MD5 .

Cómo funciona

Después de inicializar k como 1 , ingresamos un bucle infinito que ejecuta el siguiente código.

print('%2d '*7+'%2d\n')*4%tuple(n for n in range(64)if k&n),11/(k<32)*' -';k*=2

tuple(n for n in range(64)if k&n)crea una tupla de todos los números enteros no negativos por debajo de 64 que tienen allí j ^ésimo conjunto de bits, donde j es el número de iteración del bucle, es decir, 2 ^j = k .

('%2d '*7+'%2d\n')*4primero crea la cadena de formato '%2d %2d %2d %2d %2d %2d %2d \n', luego la repite cuatro veces. Esta es una plantilla para cada tarjeta, que agrega cada número entero en la tupla a dos caracteres (espacios anteriores), separa cada grupo de 8 números enteros por espacios, y los grupos mismos por saltos de línea.

Ahora, la printdeclaración de Python 2 es una bestia curiosa. Toma varias expresiones, separadas por comas, y las imprime una por una. Evalúa la primera expresión, la imprime, evalúa las siguientes expresiones, la imprime, etc. hasta que no quedan más expresiones. A menos que la última expresión sea seguida por una coma, le agrega un salto de línea. Además, antepone un espacio a todas las expresiones, a menos que se impriman al comienzo de una línea.

En cada iteración, primero imprimimos el resultado de aplicar la cadena de formato a la tupla. Estamos al comienzo de una línea, por lo que no se antepone espacio.

Luego, (intentamos) imprimir el resultado de 11/(k<32)*' -'. Si k <32 , esta expresión se evalúa como ' - - - - - - - - - - -'. Nuevamente, estamos al comienzo de una línea, por lo que no se antepone espacio. No hay coma después de esta expresión, por lo que printagrega un salto de línea. Sin embargo, en la sexta iteración, k = 2 ⁵ = 32 , por lo que intentar evaluar 11/(k<32)*' -'genera un ZeroDivisionError no capturado . Esto se escapa del ciclo y finaliza el programa inmediatamente.

C (gcc), 105 bytes

o;main(i){for(;i<384;i++%64||puts(" - - - - - - - - - - -"))i&1<<i/64&&printf("%2d%c",i%64,++o%8?32:10);}

Python 2, 132 bytes

for c in range(6):s=" ".join("%2d"%n for n in range(64)if n&1<<c);print"\n".join([s[24*i:24*i+23]for i in range(4)]+[" -"*11]*(c<5))

Dividir secuencias es molesto en Python.

Pruébalo en línea .

Jalea , 27 26 bytes

Ts8GW
⁾ -ẋ11W
63RBUz0Ñ€j¢Y

Pruébalo en línea! o verificar el hash MD5 .

Cómo funciona

63RBUz0Ñ€j¢Y  Main link. No arguments.

63R           Range 63; yield [1, ..., 63].
   B          Binary; convert each integer to base 2.
    U         Upend; reverse the binary representations.
     z0       Zip with filler 0; transpose rows and columns, filling gaps in
              the (non-rectangular) matrix with zeroes.
       р     Map the first helper link over the new rows.
          ¢   Yield the return value of the second helper link.
         j    Join the left result, separating by the right result.
           Y  Join the results, separating by line feeds.

Ts8G          First helper link. Argument: A (array of 1's and 0's)
T             Truth; get all indices of 1's.
 s8           Split the indices into chunks of length 8.
   G          Grid; convert the 2D array into a string, separating row items
              by spaces, rows by linefeeds, and left-padding each integer
              with spaces to equal lengths.
    W         Wrap the generated string in an array.


⁾ -ẋ11W       Second helper link. No arguments.

⁾ -           Yield " -".
   ẋ11        Repeat the string 11 times.
      W       Wrap the generated string in an array.

Pip , 49 48 44 bytes

43 bytes de código, +1 para -Sbandera.

Fi,6{IiP" -"X11P(sX2-#_._M2**iBA_FI,64)<>8}

Pruébalo en línea!

Explicación

                                             s is space (preinitialized)
Fi,6{                                     }  For i in range(6):
     Ii                                      If i is nonzero (i.e. all except 1st loop):
       P" -"X11                              Print hyphens
                                 FI,64       Range(64), filtered on this function:
                          2**iBA_              2**i bitwise AND with argument (is nonzero)
                         M                   To each remaining number, map this function:
                   2-#_                        2-len(argument)
                 sX                            ^ that many spaces
                       ._                      prepended to argument
                (                     )<>8   Group list into length-8 sublists
               P                             Print (-S flag joins on space then newline)

Rubí, 90 bytes.

1.upto(383){|i|print (j=i%64)<1?' -'*11+$/:"%2d%s"%[j,j+1&15>>i/256>0?' ':$/]*(j>>i/64&1)}

Sin golf

Bastante sencillo. Lo único que puede requerir una explicación adicional es cuándo seguir un número con una nueva línea en lugar de un espacio. Esto sucede cuando j+1%16==0en las primeras cuatro cartas y j+1%8== 0 en las últimas dos. Por lo tanto, la expresión 15>>i/64/4o equivalente 15>>i/256es AND con jpara determinar si se requiere espacio o nueva línea.

1.upto(383){|i|                              #Count starting at 1 instead of 0 to supress - -  before 1st card
  print (j=i%64)<1?                          #j=number to consider for card. If 0,
    ' -'*11+$/:                              #print - - -... else print
     "%2d%s"%[j,j+1&15>>i/256>0?' ':$/]*     #j formatted to 2 spaces followed by a space (or if j+1 divisible by 16 or 8 depending on card, a newline.) 
     (j>>i/64&1)                             #only print appropriate numbers for this card, i.e. when this expression evaluates to 1
}

JavaScript (ES6), 150 bytes

f=
_=>[1,2,4,8,16,32].map(m=>[...Array(64)].map((_,i)=>` ${i}`.slice(-2)).filter(i=>i&m).join` `.replace(/(.{23}) /g,`$1
`)).join(`
${` -`.repeat(11)}
`)
;document.write(`<pre>`+f())

Perl 6 ,  194116  86 bytes

put join "\n{' -'x 11}\n",map {join "\n",.[^32].rotor(8)».fmt('%2s')},(1,3...63),(2,{|($_ X+1,4)}...*),(4,{|($_ X+1,2,3,8)}...*),(8,{|((1...7,16)X+$_)}...*),(16,{|((1...15,32)X+$_)}...*),32..63

Intentalo

for 1..383 {print !($/=$_%64)??"{' -'x 11}\n"!!$/+>($_/64)%2??$/.fmt('%2d')~(($/+1)+&(15+>($_/256))??' '!!"\n")!!''}

Intentalo

for 1..383 {$_%64||put ' -'x 11;$_+&(1+<($_/64))&&printf "%2d%c",$_%64,++$/%8??32!!10}

Intentalo

(revise las secciones de Depuración para los resultados de MD5)
Los dos últimos fueron inspirados / transcritos de las implementaciones de Ruby y C

05AB1E , 71 bytes

63L©DÉÏ®À2ô®ÉÏ®ÀÀÀ4ô®ÉÏ®Á8ô®ÈÏ63®Á16ô®ÈÏ63D32sŸ)˜32ôvy8ôvy.B}„ -11×})¨»

Pruébalo en línea!

Este enfoque, no lo intentes. Probablemente eliminará esto por vergüenza para ser honesto. La manipulación de matrices no es mi fuerte, así que intenté generar fuerza bruta para generar las 6 secuencias y luego bombearlas juntas descuidadamente.

Lote, 249 bytes

@echo off
set s=
for %%i in (1 2 4 8 16 32)do for /l %%j in (0,1,63)do call:c %%i %%j
exit/b
:c
if %2==0 if %1 gtr 1 echo  - - - - - - - - - - -
set/an=%1^&%2
if %n%==0 exit/b
set n=  %2
set s=%s%%n:~-3%
if not "%s:~23%"=="" echo%s%&set s=

Emite un CRLF final.

JavaScript (ES6), 103 102 bytes

f=(k=1,n=z=0)=>n>>6?k>>5?'':' -'.repeat(11)+`
`+f(k*2):(n&k?(n>9?'':' ')+n+`
 `[++z&7&&1]:'')+f(k,++n)

_{MD5: 7AA2D9339B810EC62A2B90C5E11D6F4A}

Prueba

f=(k=1,n=z=0)=>n>>6?k>>5?'':' -'.repeat(11)+`
`+f(k*2):(n&k?(n>9?'':' ')+n+`
 `[++z&7&&1]:'')+f(k,++n)

console.log(f())

bash / utilidades de Unix, 125 124 bytes

b='- - - - ';for ((x=1;x<33;x*=2));{ for n in {0..63};{ ((x&n))&&printf \ %2d $n;};echo $b$b$b;}|fold -w24|sed -e\$d -es/.//

Editar: se eliminó un ^ innecesario de la expresión regular al final; la expresión regular siempre coincidirá al comienzo de la línea de todos modos.

PHP, 102 bytes

for(;$c<6;$n%32||$c+=print str_pad("
",25," -"),$n%2**$c||$b+=1<<$c)printf("
"[$n++%8]."%3d",++$b%64);

imprime una nueva línea inicial pero no posterior, y un espacio inicial en cada línea. Ejecutar -nro probarlo en línea .

Para PHP <5.6, reemplace 2**$ccon (1<<$c). PHP 5.5 podría usar en &~1<<$c?:lugar de %2**$c||.
Para PHP <5.5, reemplace "\n"[$n++%8]con ($n++%8?"":"\n").

Los guiones son un carácter apagado debido al espacio inicial; agregue un espacio al primer str_padparámetro (inserte un espacio antes de la segunda línea de código) para corregirlo.

En cambio, eliminar el espacio inicial requiere un poco de violín y tres bytes adicionales: printf("%c%2d",$n++%8?32:10,++$b%64);y en 23lugar de 25.

Convertir la nueva línea principal en una final le costaría otros tres bytes:

for(;$c<6;$n%32||$c+=print str_pad("",22," -")."
",$n%2**$c||$b+=1<<$c)printf("%2d%c",++$b%64,++$n%8?32:10);

PHP, 109 bytes

for($c=1;~$c&64;$n%32||$c<<=print str_pad("",22," -")."
",$n%$c||$b+=$c)printf("%2d%c",++$b%64,++$n%8?32:10);

coincide con todas las especificaciones y funciona con todas las versiones de PHP.

Python 2 , 89 bytes

i=0;exec"print('%2d '*7+'%2d\\n')*4%tuple(j for j in range(64)if j&2**i)+' -'*11;i+=1;"*6

Pruébalo en línea!

Explicación:

# initialize outer counter variable
i=0
           # generate a formatting string for a single row of numbers
           # %2d will left pad an integer with spaces, up to string length 2
           # the \\n is so that exec will interpret it as a character rather than a literal line break
           '%2d '*7+'%2d\\n'
          # create a formatting string of 4 lines of 8 numbers
          (.................)*4
                               # format the string with a generated tuple of numbers that have a 1 in the current bit slot
                               # (or more literally, bitwise j AND 2^i is not zero)
                               %tuple(j for j in range(64)if j&2**i)
                                                                    # add the perforation break
                                                                    +' -'*11
     # print the generated string, then increment the counter
     print..................................................................;i+=1
# execute the following statements 6 times
exec"............................................................................."*6

05AB1E , 29 bytes

63L2вíƶ0ζε0K8ô§2j»}„ -11׶.øý

Puerto de @Emigna respuesta 05AB1E 's aquí , después de lo cual añade código adicional para imprimir de acuerdo con los requisitos de este desafío.

Pruébelo en línea o verifique md5sum .

Explicación:

63L          # Create a list in the range [1,63]
   2в        # Convert each number to binary as lists of 0s and 1s
     í       # Reverse each binary list
      ƶ      # Multiply each binary digit by its 1-based index [1,length] (so [1,63])
       0ζ    # Zip/transpose; swapping rows/columns, with "0" as filler
ε            # Map each inner list to:
 0K          #  Remove all 0s
   8ô        #  Split it into (four) lists of size 8
     §       #  Cast each integer to string (bug, shouldn't be necessary..)
      2j     #  And pad leading spaces to make each string size 2
        »    #  Join the inner lists by spaces, and then all strings by newlines
}„ -         # After the map: push string " -"
    11×      # Repeated 11 times to " - - - - - - - - - - -"
       ¶.ø   # Surround it with newlines: "\n - - - - - - - - - - -\n"
          ý  # And join the mapped strings with this delimiter-string
             # (after which the result is output implicitly)

JavaScript, 234 bytes.

for(a=[[],[],[],[],[],[]],i=1;i<64;i++)for(j=0;j<6;j++)i&2**j?a[j].push(i<10?" "+i:i):0;for(j=0;j<6;j++){for(s=[],i=0;i<4;)s.push(a[j].slice(i*8,++i*8).join(" "));b=s.join(n="\n");a[j]=b.substr(0,b.length)};a.join(n+" -".repeat(11)+n)

Escribiré una explicación más tarde.

Si console.loges necesario, el recuento de bytes sería de 247 bytes.