Die Geschenke wurden geöffnet. Die Hackfleischpasteten sind gegessen worden. Die Star Wars wurden gesehen. Die Weihnachtszeit neigt sich dem Ende zu. Inzwischen haben Sie vielleicht ein paar Weihnachtscracker gezogen . Wenn Sie Glück haben, haben Sie möglicherweise anstelle des üblichen nutzlosen Plastikspielzeugs einen Mystery Calculator gewonnen, mit dem Sie Ihre Freunde und Verwandten in Erstaunen versetzen können .

Dieser Trick besteht aus 6 Karten, auf denen jeweils ein 4 × 8-Raster mit Zahlen gedruckt ist. Jede Karte enthält eine andere Teilmenge der ganzen Zahlen [1,63]. Der Zauberer fordert Sie auf, eine Nummer von einer Karte auszuwählen und diese Nummer geheim zu halten. Der Zauberer fragt dann, welche Karten diese Nummer haben. Mit diesem Wissen wird der Magier auf magische Weise in der Lage sein, die erratene ursprüngliche Zahl zu bestimmen und offenzulegen.

Geben Sie den vollständigen Satz von 6 Mystery Calculator-Karten wie folgt aus:

 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

Die Ausgabe kann eine letzte nachgestellte Zeile enthalten oder nicht. Es darf kein Leerzeichen nachgestellt werden. Jede Karte ist durch 11 -Perforationen getrennt.

• md5sum mit abschließender newline: 7aa2d9339b810ec62a2b90c5e11d6f4a
• md5sum ohne letzte newline: e9abe4e32dca3e8fbfdaa4886fc5efd2

Für diejenigen unter Ihnen, die eher Windows-orientiert sind, werde ich auch CRLFZeilenenden zulassen . In diesem Fall sind die md5s:

• md5sum mit abschließender newline: e4f16ff9752eee2cedb5f97c7b5aec6d
• md5sum ohne letzte newline: 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

Wird mit einem Fehler beendet, der standardmäßig zulässig ist .

Probieren Sie es online! oder überprüfen Sie den MD5-Hash .

Wie es funktioniert

Nach der Initialisierung k als 1 geben wir eine Endlosschleife ein, die den folgenden Code ausführt.

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)Erzeugt ein Tupel aller nicht negativen ganzen Zahlen unter 64 , für die das j- ^te Bit gesetzt ist, wobei j die Iterationszahl der Schleife ist, dh 2 ^j = k .

('%2d '*7+'%2d\n')*4erstellt zuerst die Formatzeichenfolge '%2d %2d %2d %2d %2d %2d %2d \n'und wiederholt sie dann viermal. Dies ist eine Vorlage für jede Karte, die jede Ganzzahl im Tupel mit zwei Zeichen (vorstehende Leerzeichen) auffüllt und jede 8er- Gruppe voneinander trennt Ganzzahlen durch Leerzeichen und die Gruppen selbst durch Zeilenvorschübe .

Jetzt, die printAussage von Python 2 ist ein merkwürdiges Biest. Es werden mehrere durch Kommata getrennte Ausdrücke verwendet, die nacheinander gedruckt werden. Es wertet den ersten Ausdruck aus, druckt ihn aus, wertet die nächsten Ausdrücke aus, druckt ihn aus usw., bis keine Ausdrücke mehr übrig sind. Wenn dem letzten Ausdruck kein Komma folgt, wird ein Zeilenvorschub angehängt. Außerdem wird allen Ausdrücken ein Leerzeichen vorangestellt, es sei denn, sie werden am Anfang einer Zeile gedruckt.

In jeder Iteration wird zuerst das Ergebnis der Anwendung der Formatzeichenfolge auf das Tupel gedruckt. Wir stehen am Anfang einer Zeile, daher wird kein Leerzeichen vorangestellt.

Dann versuchen wir, das Ergebnis von auszudrucken 11/(k<32)*' -'. Wenn k <32 , wird dieser Ausdruck zu ausgewertet ' - - - - - - - - - - -'. Auch hier stehen wir am Anfang einer Zeile, daher wird kein Leerzeichen vorangestellt. Nach diesem Ausdruck steht kein Komma. printFügen Sie daher einen Zeilenvorschub hinzu. In der sechsten Iteration ist jedoch k = 2 ⁵ = 32 , sodass der Versuch, auszuwerten, 11/(k<32)*' -'einen nicht erfassten ZeroDivisionError auslöst . Dies bricht die Schleife ab und beendet das Programm sofort.

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

Das Aufteilen von Sequenzen ist in Python ärgerlich.

Probieren Sie es online aus .

Jelly , 27 26 Bytes

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

Probieren Sie es online! oder überprüfen Sie den MD5-Hash .

Wie es funktioniert

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 Byte Code, +1 für -SFlag.

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

Probieren Sie es online!

Erläuterung

                                             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)

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

Ungolfed

Ziemliech direkt. Die einzige Sache, die zusätzliche Erklärung erfordert, ist, wann eine Zahl mit einer neuen Zeile anstatt einer Leerstelle zu folgen ist. Dies passiert, wenn j+1%16==0in den ersten vier Karten j+1%8== 0 und in den letzten beiden. Daher wird der Ausdruck 15>>i/64/4oder die Entsprechung 15>>i/256mit UND verknüpft, um jzu bestimmen, ob Leerzeichen oder Zeilenumbrüche erforderlich sind.

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

Versuch es

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

Versuch es

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

Versuch es

(überprüfen Sie die Debug - Abschnitte für die MD5 - Ergebnisse)
Die letzten beiden wurden inspiriert / transkribiert von den Ruby und C - Implementierungen

05AB1E , 71 Bytes

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

Probieren Sie es online!

Probieren Sie diesen Ansatz nicht aus. Wird wahrscheinlich aus Schande löschen, um ehrlich zu sein. Die Matrix-Manipulation ist nicht meine Stärke, deshalb habe ich versucht, alle 6 Sequenzen mit brachialer Kraft zu erzeugen und sie dann schlampig zusammenzupumpen.

Batch, 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=

Gibt eine nachfolgende CRLF aus.

JavaScript (ES6), 103 bis 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}

Prüfung

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 / Unix-Dienstprogramme, 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/.//

Bearbeiten: Ein unnötiges ^ wurde am Ende aus dem regulären Ausdruck entfernt. Der reguläre Ausdruck wird ohnehin immer am Anfang der Zeile angezeigt.

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

druckt eine führende, aber keine nachfolgende neue Zeile und ein führendes Leerzeichen in jeder Zeile. Laufen Sie mit -nroder versuchen Sie es online .

Für PHP <5.6, ersetzen 2**$cmit (1<<$c). PHP 5.5 könnte &~1<<$c?:anstelle von verwenden %2**$c||.
Für PHP <5.5, ersetzen "\n"[$n++%8]mit($n++%8?"":"\n") .

Bindestriche sind aufgrund des führenden Leerzeichens ein Zeichen weniger. füge ein Leerzeichen an das erste anstr_pad Parameter ein Leerzeichen hinzu (fügen Sie ein Leerzeichen vor der zweiten Codezeile ein), um dies zu beheben.

Das Entfernen des führenden Leerzeichens erfordert stattdessen etwas Fummeln und drei zusätzliche Bytes: printf("%c%2d",$n++%8?32:10,++$b%64);und23 statt25 .

Die führende Zeile in eine nachfolgende zu verwandeln, würde weitere drei Bytes kosten:

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

Entspricht allen Spezifikationen und funktioniert mit allen PHP-Versionen.

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

Probieren Sie es online!

Erläuterung:

# 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׶.øý

Port aus @Emignas 05AB1E-Antwort hier. Danach habe ich zusätzlichen Code hinzugefügt, um ihn gemäß den Anforderungen in dieser Herausforderung zu drucken.

Probieren Sie es online oder überprüfen Sie md5sum .

Erläuterung:

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)

Ich werde später eine Erklärung schreiben.

Falls console.logerforderlich, würde die Byteanzahl 247 Bytes betragen.