I regali sono stati aperti. Le trito-torte sono state mangiate. Star Wars è stato visto. Il periodo natalizio sta iniziando a concludersi. Ormai potresti aver tirato alcuni cracker natalizi . Se sei fortunato, invece dei soliti inutili giocattoli di plastica, potresti aver vinto un Mystery Calculator con cui puoi stupire i tuoi amici e parenti .

Questo trucco consiste in 6 carte ognuna con una griglia 4x8 di numeri stampati su di essa. Ogni carta contiene un sottoinsieme diverso degli interi [1,63]. Il mago ti chiederà di scegliere un numero da una carta e mantenere quel numero segreto. Il mago chiederà quindi quali carte hanno quel numero. Con questa conoscenza, il mago sarà magicamente in grado di determinare e rivelare il numero originale indovinato.

Stampa il set completo di 6 carte Mystery Calculator esattamente come segue:

 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

L'output può contenere o meno un'ultima riga finale finale. Non devono esserci spazi vuoti finali. Ogni carta è separata da 11 -perforazioni.

• md5sum con la nuova riga finale: 7aa2d9339b810ec62a2b90c5e11d6f4a
• md5sum senza newline finale: e9abe4e32dca3e8fbfdaa4886fc5efd2

Per quelli di voi che hanno più di un orientamento di Windows, consentirò anche le CRLFterminazioni di linea di stile. In tal caso, gli md5 sono:

• md5sum con la nuova riga finale: e4f16ff9752eee2cedb5f97c7b5aec6d
• md5sum senza newline finale: 78c560eed3b83513e3080117ab5dc5fa

Python 2 , 99 96 93 91 byte

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

Esce con un errore, che è consentito per impostazione predefinita .

Provalo online! oppure verifica l'hash MD5 .

Come funziona

Dopo aver inizializzato k come 1 , entriamo in un ciclo infinito che esegue il codice seguente.

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 di tutti i numeri interi non negativi inferiori 64 che ha ci j ^esimo bit impostato, dove j è il conteggio iterazione del ciclo, cioè, 2 ^j = k .

('%2d '*7+'%2d\n')*4crea prima la stringa di formato '%2d %2d %2d %2d %2d %2d %2d \n', quindi la ripete quattro volte. Questo è un modello per ogni carta, che porta ogni numero intero nella tupla a due caratteri (anteponendo spazi), separa ogni gruppo di 8 numeri interi per spazi e i gruppi stessi per avanzamenti di riga.

Ora, l' printaffermazione di Python 2 è una bestia curiosa. Prende diverse espressioni, separate da virgole, e le stampa una per una. Valuta la prima espressione, la stampa, valuta le espressioni successive, la stampa, ecc. Fino a quando non rimangono più espressioni. A meno che l'ultima espressione non sia seguita da una virgola, aggiunge un avanzamento di riga. Inoltre, antepone uno spazio a tutte le espressioni, a meno che non vengano stampate all'inizio di una riga.

In ogni iterazione, stampiamo prima il risultato dell'applicazione della stringa di formato alla tupla. Siamo all'inizio di una riga, quindi nessuno spazio è anteposto.

Quindi, (tentiamo di) stampare il risultato di 11/(k<32)*' -'. Se k <32 , questa espressione valuta ' - - - - - - - - - - -'. Ancora una volta, siamo all'inizio di una riga, quindi nessuno spazio è anteposto. Non c'è virgola dopo questa espressione, quindi printaccoda un avanzamento riga. Tuttavia, nella sesta iterazione, k = 2 ⁵ = 32 , quindi il tentativo di valutare 11/(k<32)*' -'genera un ZeroDivisionError non rilevato . Questo si interrompe e termina immediatamente il programma.

C (gcc), 105 byte

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 byte

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

Suddividere le sequenze è fastidioso in Python.

Provalo online .

Gelatina , 27 26 byte

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

Provalo online! oppure verifica l'hash MD5 .

Come funziona

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 byte

43 byte di codice, +1 per la -Sbandiera.

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

Provalo online!

Spiegazione

                                             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)

Rubino, 90 byte

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

Ungolfed

Abbastanza semplice. L'unica cosa che potrebbe richiedere ulteriori spiegazioni è quando seguire un numero con una nuova riga anziché uno spazio. Questo succede quando j+1%16==0nelle prime quattro carte e j+1%8== 0 nelle ultime due. Quindi l'espressione 15>>i/64/4o equivalente 15>>i/256è ANDed con jper determinare se è necessario spazio o newline.

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 byte

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 ,  194 116  86 byte

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

Provalo

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

Provalo

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

Provalo

(controlla le sezioni Debug per i risultati MD5)
Gli ultimi due sono stati ispirati / trascritti dalle implementazioni di Ruby e C.

05AB1E , 71 byte

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

Provalo online!

Questo approccio, non provarlo. Probabilmente lo eliminerò per vergogna per essere onesti. La manipolazione della matrice non è il mio punto di forza, quindi ho provato a forzare la forza per generare tutte e 6 le sequenze e poi pomparle insieme in modo sciatto.

Lotto, 249 byte

@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=

Emette un CRLF finale.

JavaScript (ES6), 103 102 byte

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}

Test

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

utility bash / Unix, 125 124 byte

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/.//

Modifica: rimosso un ^ non necessario dal regex alla fine; la regex corrisponderà comunque sempre all'inizio della riga.

PHP, 102 byte

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

stampa una riga iniziale ma non trascinata e uno spazio iniziale in ogni riga. Corri con -nro provalo online .

Per PHP <5.6, sostituire 2**$ccon (1<<$c). PHP 5.5 potrebbe usare al &~1<<$c?:posto di %2**$c||.
Per PHP <5.5, sostituire "\n"[$n++%8]con ($n++%8?"":"\n").

I trattini sono uno dei personaggi a causa dello spazio iniziale; aggiungere uno spazio al primo str_padparametro (inserire uno spazio prima della seconda riga di codice) da correggere.

La rimozione dello spazio iniziale richiede invece un po 'di manipolazione e tre byte aggiuntivi: printf("%c%2d",$n++%8?32:10,++$b%64);e 23invece di 25.

Trasformare la nuova riga iniziale in una riga finale costerebbe altri tre byte:

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 byte

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

corrisponde a tutte le specifiche e funziona con tutte le versioni di PHP.

Python 2 , 89 byte

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

Provalo online!

Spiegazione:

# 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 byte

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

Port da @Emigna risposta 05AB1E s' qui , dopo di che ho aggiunto codice aggiuntivo per stamparlo in base ai requisiti di questa sfida.

Provalo online o verifica md5sum .

Spiegazione:

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 byte.

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)

Scriverò una spiegazione più tardi.

Se console.lognecessario, il conteggio dei byte sarebbe 247 byte.