Les cadeaux ont été ouverts. Les hachis ont été mangés. La guerre des étoiles a été regardée. La saison de Noël commence à se terminer. Vous avez peut-être déjà tiré quelques crackers de Noël . Si vous êtes chanceux, au lieu des jouets en plastique inutiles habituels, vous avez peut-être gagné une calculatrice mystère avec laquelle vous pouvez étonner vos amis et vos proches .

Cette astuce consiste en 6 cartes chacune avec une grille 4x8 de chiffres imprimés dessus. Chaque carte contient un sous-ensemble différent des entiers [1,63]. Le magicien vous demandera de choisir un numéro sur une carte et de garder ce numéro secret. Le magicien demandera alors quelles cartes ont ce numéro. Avec cette connaissance, le magicien sera magiquement en mesure de déterminer et de divulguer le nombre d'origine deviné.

Sortez le jeu complet de 6 cartes Mystery Calculator exactement comme suit:

 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 sortie peut ou non contenir un retour à la ligne final final. Il ne doit y avoir aucun espace de fin. Chaque carte est séparée par 11 -perforations.

• md5sum avec la nouvelle ligne finale: 7aa2d9339b810ec62a2b90c5e11d6f4a
• md5sum sans nouvelle ligne finale: e9abe4e32dca3e8fbfdaa4886fc5efd2

Pour ceux d'entre vous qui ont une orientation plus Windows, j'autoriserai également les CRLFfins de ligne de style. Dans ce cas, les md5 sont:

• md5sum avec la nouvelle ligne finale: e4f16ff9752eee2cedb5f97c7b5aec6d
• md5sum sans nouvelle ligne finale: 78c560eed3b83513e3080117ab5dc5fa

Python 2 , 99 96 93 91 octets

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

Quitte avec une erreur, ce qui est autorisé par défaut .

Essayez-le en ligne! ou vérifiez le hachage MD5 .

Comment ça marche

Après avoir initialisé k à 1 , nous entrons dans une boucle infinie qui exécute le code suivant.

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)crée un tuple de tous les entiers non négatifs inférieurs à 64 qui ont leur j ^ème bit défini, où j est le nombre d'itérations de la boucle, c'est-à-dire 2 ^j = k .

('%2d '*7+'%2d\n')*4crée d'abord la chaîne de formatage '%2d %2d %2d %2d %2d %2d %2d \n', puis la répète quatre fois. Il s'agit d'un modèle pour chaque carte, qui remplit chaque entier du tuple à deux caractères (espaces en préfixe), sépare chaque groupe de 8 entiers par des espaces et les groupes eux-mêmes par des sauts de ligne.

Maintenant, la printdéclaration de Python 2 est une bête curieuse. Il prend plusieurs expressions, séparées par des virgules, et les imprime une par une. Il évalue la première expression, l'imprime, évalue les expressions suivantes, l'imprime, etc. jusqu'à ce qu'il ne reste plus d'expressions. À moins que la dernière expression ne soit suivie d'une virgule, elle y ajoute un saut de ligne. En outre, il ajoute un espace à toutes les expressions, sauf si elles sont imprimées au début d'une ligne.

Dans chaque itération, nous imprimons d'abord le résultat de l'application de la chaîne de formatage au tuple. Nous sommes au début d'une ligne, donc aucun espace n'est ajouté.

Ensuite, nous (essayons) d'imprimer le résultat de 11/(k<32)*' -'. Si k <32 , cette expression est évaluée à ' - - - - - - - - - - -'. Encore une fois, nous sommes au début d'une ligne, donc aucun espace n'est ajouté. Il n'y a pas de virgule après cette expression, donc printajoute un saut de ligne. Cependant, dans la sixième itération, k = 2 ⁵ = 32 , donc essayer d'évaluer 11/(k<32)*' -'déclenche une ZeroDivisionError non capturée . Cela sort de la boucle et termine immédiatement le programme.

C (gcc), 105 octets

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 octets

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

Le fractionnement de séquences est ennuyeux en Python.

Essayez-le en ligne .

Gelée , 27 26 octets

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

Essayez-le en ligne! ou vérifiez le hachage MD5 .

Comment ça marche

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 octets

43 octets de code, +1 pour l' -Sindicateur.

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

Essayez-le en ligne!

Explication

                                             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)

Rubis, 90 octets

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

Non golfé

Assez simple. La seule chose qui peut nécessiter des explications supplémentaires est de savoir quand suivre un nombre avec une nouvelle ligne plutôt qu'un espace. Cela se produit lorsque j+1%16==0dans les quatre premières cartes et j+1%8== 0 dans les deux dernières. Par conséquent, l'expression 15>>i/64/4ou de manière équivalente 15>>i/256est ET jpour déterminer si un espace ou une nouvelle ligne est requis.

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 octets

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 116  86 octets

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

Essayez-le

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

Essayez-le

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

Essayez-le

(consultez les sections Débogage pour les résultats MD5)
Les deux dernières ont été inspirées / transcrites à partir des implémentations Ruby et C

05AB1E , 71 octets

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

Essayez-le en ligne!

Cette approche, ne l'essayez pas. Supprimera probablement cela par honte pour être honnête. La manipulation de la matrice n'est pas mon point fort, j'ai donc essayé de générer par force la force des 6 séquences, puis de les pomper ensemble.

Lot, 249 octets

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

Génère un CRLF de fin.

JavaScript (ES6), 103 102 octets

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}

Tester

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

Edit: Suppression d'un ^ inutile de l'expression régulière à la fin; l'expression régulière correspondra toujours au début de la ligne de toute façon.

PHP, 102 octets

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

imprime une nouvelle ligne de début mais pas de fin, et un espace de début dans chaque ligne. Courez avec -nrou essayez-le en ligne .

Pour PHP <5.6, remplacez 2**$cpar (1<<$c). PHP 5.5 pourrait utiliser à la &~1<<$c?:place de %2**$c||.
Pour PHP <5.5, remplacez "\n"[$n++%8]par ($n++%8?"":"\n").

Les tirets sont désactivés d'un caractère en raison de l'espace de tête; ajouter un espace au premierstr_pad paramètre (insérez un espace avant la deuxième ligne de code) pour corriger.

La suppression de l'espace de tête nécessite à la place quelques manipulations et trois octets supplémentaires: printf("%c%2d",$n++%8?32:10,++$b%64);et 23au lieu de 25.

Transformer la nouvelle ligne de tête en ligne de fin coûterait encore trois octets:

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 octets

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

correspond à toutes les spécifications et fonctionne avec toutes les versions de PHP.

Python 2 , 89 octets

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

Essayez-le en ligne!

Explication:

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

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

Port de @Emigna réponse 05AB1E s » ici , après quoi j'ajouté du code pour l' imprimer selon les exigences de ce défi.

Essayez-le en ligne ou vérifiez md5sum .

Explication:

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

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)

J'écrirai une explication plus tard.

Si console.lognécessaire, le nombre d'octets serait de 247 octets.