Le défi est simplement; produire les six tableaux entiers 2D suivants:

[[ 1, 11, 21, 31, 41, 51],
 [ 3, 13, 23, 33, 43, 53],
 [ 5, 15, 25, 35, 45, 55],
 [ 7, 17, 27, 37, 47, 57],
 [ 9, 19, 29, 39, 49, 59]]

[[ 2, 11, 22, 31, 42, 51],
 [ 3, 14, 23, 34, 43, 54],
 [ 6, 15, 26, 35, 46, 55],
 [ 7, 18, 27, 38, 47, 58],
 [10, 19, 30, 39, 50, 59]]

[[ 4, 13, 22, 31, 44, 53],
 [ 5, 14, 23, 36, 45, 54],
 [ 6, 15, 28, 37, 46, 55],
 [ 7, 20, 29, 38, 47, 60],
 [12, 21, 30, 39, 52]]

[[ 8, 13, 26, 31, 44, 57],
 [ 9, 14, 27, 40, 45, 58],
 [10, 15, 28, 41, 46, 59],
 [11, 24, 29, 42, 47, 60],
 [12, 25, 30, 43, 56]]

[[16, 21, 26, 31, 52, 57],
 [17, 22, 27, 48, 53, 58],
 [18, 23, 28, 49, 54, 59],
 [19, 24, 29, 50, 55, 60],
 [20, 25, 30, 51, 56]]

[[32, 37, 42, 47, 52, 57],
 [33, 38, 43, 48, 53, 58],
 [34, 39, 44, 49, 54, 59],
 [35, 40, 45, 50, 55, 60],
 [36, 41, 46, 51, 56]]

Quels sont ces tableaux entiers 2D? Ce sont les nombres utilisés dans un tour de magie avec des cartes contenant ces nombres:

Le tour de magie demande à quelqu'un de penser à un nombre dans la plage [1, 60] et de donner à celui qui effectue le tour de magie toutes les cartes qui contiennent ce numéro. Celui qui exécute le tour de magie peut ensuite additionner les nombres en haut à gauche (tous une puissance de 2) des cartes données pour arriver au nombre auquel la personne pensait. Vous trouverez ici quelques explications supplémentaires sur les raisons de ce fonctionnement.

Règles du défi:

• Vous pouvez sortir les six tableaux entiers 2D dans n'importe quel format raisonnable. Peut être imprimé avec des délimiteurs; peut être un tableau d'entiers 3D contenant les six tableaux d'entiers 2D; peut être une liste de chaînes de lignes; etc.
• Vous êtes autorisé à remplir la position en bas à droite des quatre dernières cartes avec une valeur négative dans la plage [-60, -1]ou le caractère '*'au lieu de le laisser pour faire des matrices rectangulaires de tableaux entiers 2D (non, vous n'êtes pas autorisé à les remplir avec 0ou un non -entier comme null/ undefinedcomme alternative, à l'exception du fait *qu'une étoile est également utilisée dans les cartes réelles).
• L'ordre des nombres dans les matrices est obligatoire. Bien que cela n'ait pas d'importance pour le tour de magie physique, je vois ce défi principalement comme une matrice - une complexité kolmogorov , d'où la restriction de la commande.
  L'ordre des matrices elles-mêmes dans la liste de sortie peut être dans n'importe quel ordre, car il est clair sur la carte en haut à gauche quelle matrice est laquelle.

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse avec des règles d'E / S par défaut , vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code (par exemple TIO ).
• De plus, l'ajout d'une explication à votre réponse est fortement recommandé.

MATL , 12 11 octets

-1 octet grâce au maître lui-même :)

60:B"@fQ6eq

Explication:

60:           % create a vector [1,2,3,...,60]
   B          % convert to binary matrix (each row corresponds to one number)
    "         % loop over the columns and execute following commands:
     @f       % "find" all the nonzero entries and list their indices
       Q      % increment everything
        6e    % reshape and pad with a zero at the end
          q   % decrement (reverts the increment and makes a -1 out of the zero
              % close loop (]) implicitly
              % display the entries implicitly

Essayez-le en ligne!

Perl 6 , 63 46 octets

say grep(*+&2**$_,^61)[$_,*+5...*for ^5]for ^6

Essayez-le en ligne!

Sorties sous forme de tableaux 2D sur plusieurs lignes, avec le dernier tableau de chacun coupé si nécessaire.

Python 2 , 76 octets

r=range;print[[[i for i in r(61)if i&2**k][j::5]for j in r(5)]for k in r(6)]

Essayez-le en ligne!

La méthode ici consiste à créer une liste de tous les numéros possibles r(61), puis à la réduire à la liste des numéros d'une carte i&2**k.

Ensuite, en utilisant le découpage de liste, cette liste 1D de nombres est réorganisée à la taille de carte 6x5 correcte [card nums][j::5]for j in r(5).

Ensuite, ce générateur est simplement répété pour 6 cartes for k in r(6).

Bien que je n'aie pas trouvé de solutions de moins de 76 octets, voici deux autres qui font également 76 octets:

r=range;print[[[i for i in r(61)if i&1<<k][j::5]for j in r(5)]for k in r(6)]

Essayez-le en ligne!

Ce prochain est inspiré par Jonathan Allan .

k=32
while k:print[[i for i in range(61)if i&k][j::5]for j in range(5)];k/=2

Essayez-le en ligne!

Tous les commentaires sont grandement appréciés.

Fusain , 26 octets

Ｅ⁶Ｅ⁵⪫Ｅ⁶§⁺§⪪Φ⁶¹＆πＸ²ι⁵ν⟦*⟧λ 

Essayez-le en ligne! Le lien est vers la version détaillée du code. J'ai essayé de calculer les entrées directement, mais c'était déjà 27 octets avant d'ajuster le *en bas à droite. Sort chaque ligne jointe avec des espaces et une ligne vierge entre les cartes. Explication:

Ｅ⁶                          Loop over 6 cards
  Ｅ⁵                        Loop over 5 rows
     Ｅ⁶                     Loop over 6 columns
           Φ⁶¹              Filter over 0..60 where
               π            Current value
              ＆             Bitwise And
                 ²          Literal 2
                Ｘ           Raised to power
                  ι         Card index
          ⪪        ⁵        Split into groups of 5
         §          ν       Indexed by column
        ⁺                   Concatenated with
                      *     Literal string `*`
                     ⟦ ⟧    Wrapped in an array
       §                λ   Indexed by row
    ⪫                       Joined with spaces
                            Implicitly print

05AB1E , 16 octets

60L2вíƶ0ζε0K5ô®ζ

Essayez-le en ligne!

Explication

60L                 # push [1 ... 60]
   2в               # convert each to a list of binary digits
     í              # reverse each
      ƶ             # multiply each by its 1-based index
       0ζ           # transpose with 0 as filler
         ε          # apply to each list
          0K        # remove zeroes
            5ô      # split into groups of 5
              ®ζ    # zip using -1 as filler

05AB1E , 17 octets

6F60ÝNoôāÈϘ5ô®ζ,

Essayez-le en ligne!

Explication

6F                  # for N in [0 ... 5] do
  60Ý               # push [0 ... 60]
     Noô            # split into groups of 2^N numbers
        āÈÏ         # keep every other group
           ˜        # flatten
            5ô      # split into groups of 5
              ®ζ    # transpose with -1 as filler
                ,   # print

Husk , 13 octets

ṠMöTC5Wnünḣ60

Essayez-le en ligne!

Explication

          ḣ60  Range [1..60]
        ü      Uniquify using equality predicate
         n     bitwise AND: [1,2,4,8,16,32]
 M             For each number x in this list,
Ṡ     W        take the indices of elements of [1..60]
       n       that have nonzero bitwise AND with x,
    C5         cut that list into chunks of length 5
  öT           and transpose it.

Python 2 , 82 80 78 74 octets

i=1 
exec"print zip(*zip(*[(n for n in range(61)+[-1]if n&i)]*5));i*=2;"*6

Essayez-le en ligne!

_{-4 octets, merci à Jonathan Allan}

Japt , 14 octets

6Æ60õ f&2pX)ó5

Essayez-le

6Æ              Create a range from 0 to 5 (inclusive) and map each X into
  60õ             Elements in the range [1..60]
      f             Where
       &2pX)          The number bitwise AND with X is not 0
  ó5              Split into 5 arrays, where each array contains every 5th element

-Q flag is just for formatting purposes

JavaScript (ES6),  90  88 octets

_=>[1,2,4,8,16,32].map(n=>(g=i=>i<60?g(++i,i&n?m[y%5]=[...m[y++%5]||[],i]:0):m)(y=m=[]))

Essayez-le en ligne!

Commenté

_ =>                        // anonymous function taking no argument
  [1, 2, 4, 8, 16, 32]      // list of powers of 2, from 2**0 to 2**5
  .map(n =>                 // for each entry n in this list:
    ( g = i =>              //   g = recursive function taking a counter i
      i < 60 ?              //     if i is less than 60:
        g(                  //       recursive call:
          ++i,              //         increment i
          i & n ?           //         if a bitwise AND between i and n is non-zero:
            m[y % 5] =      //           update m[y % 5]:
            [ ...m[y++ % 5] //             prepend all previous values; increment y
              || [],        //             or prepend nothing if it was undefined so far
              i             //             append i
            ]               //           end of update
          :                 //         else:
            0               //           do nothing
        )                   //       end of recursive call
      :                     //     else:
        m                   //       return m[]
    )(y = m = [])           //   initial call to g with i = y = m = []
                            //   (i and y being coerced to 0)
  )                         // end of map()

Python 2 , 73 octets

Inspiration tirée à la fois de TFeld et de Matt .

k=32
while k:print zip(*zip(*[(i for i in range(61)+[-1]if i&k)]*5));k/=2

Essayez-le en ligne!

C (gcc) , 95 octets

i,j,k;f(int o[][5][6]){for(i=6;i;)for(o[--i][4][5]=j=k=-1;j<60;)++j&1<<i?o[i][++k%5][k/5]=j:0;}

Essayez-le en ligne!

Renvoie les matrices sous forme de tableau int 3D dans o.

Les 4 dernières matrices ont -1 comme dernière valeur.

Enregistré 2 octets grâce à Kevin Cruijssen.

Enregistré 7 8 octets grâce à Arnauld.

CJam (18 octets)

6{61{2A#&},5/zp}fA

Démo en ligne . Il s'agit d'un programme complet qui sort sur stdout.

Dissection

6{             }fA    # for A = 0 to 5
  61{2A#&},           #   filter [0,61) by whether bit 2^A is set
           5/z        #   break into chunks of 5 and transpose to get 5 lists
              p       #   print

Gelée , 13 octets

60&ƇⱮs€5LÐṂZ€

Un lien niladique qui produit une liste de (6) listes de listes d'entiers. (Il génère l'utilisation de l'option par défaut de *remplissage nul ou négatif.)

Essayez-le en ligne!

Comment?

$60$

$60$$[1,60]$$5$

60&ƇⱮs€5LÐṂZ€ - Link: no arguments
60            - set the left argument to 60
    Ɱ         - map across ([1..60]) with:  (i.e. [f(60,x) for x in [1..60]])
   Ƈ          -   filter keep if:  (N.B. 0 is falsey, while non-zeros are truthy)
  &           -     bitwise AND
      €       - for each:
     s 5      -   split into chunks of five
         ÐṂ   - keep those with minimal:
        L     -   length
           Z€ - transpose each

Beaucoup de 15 sans réaliser l'astuce "minimal par la longueur lorsqu'il est divisé en cinq":

5Ż2*Ɱ60&ƇⱮs€5Z€
6µ’2*60&Ƈ)s€5Z€
60&ƇⱮ`LÞḣ6s€5Z€

... et, tout en essayant de trouver plus court, j'ai obtenu un autre 13 sans avoir du tout besoin de l'astuce:

60B€Uz0Ts5ZƊ€

Wolfram Language (Mathematica) , 88 octets

Transpose@Partition[#~Append~-1,5]&/@Last@Reap[Sow[,NumberExpand[,2]]~Do~{,60},Except@0]

Wolfram Language (Mathematica) , 99 octets

Transpose@Partition[#~FromDigits~2&/@Last@GatherBy[{0,1}~Tuples~6,#[[-k]]&],5]~Table~{k,6}/. 61->-1

Essayez-le en ligne!

Gelée , 13 octets

60B€Uz0µTs5Z)

Essayez-le en ligne!

Librement basé sur la réponse MATL de flawr . Un lien niladique qui génère une liste de listes selon les besoins.

R , 73 octets

`!`=as.raw;lapply(0:5,function(i)matrix(c((a=1:60)[(!a&!2^i)>0],-1),5,6))

Je ne suis pas entièrement sûr d'avoir satisfait à l'exigence de commande, car R par défaut remplit les matrices par colonne, donc l'ordre tel qu'il apparaît physiquement sur les cartes est le même que la façon dont les matrices sont allouées dans R.

Essayez-le en ligne!

T-SQL, ( 1 168 1 139 octets)

Je voulais juste savoir que je pouvais le faire.

Version optimisée

 WITH g AS(SELECT 1 AS n UNION ALL SELECT n+1 FROM g WHERE n+1<61),B as(SELECT cast(cast(n&32 as bit)as CHAR(1))+cast(cast(n&16 as bit)as CHAR(1))+cast(cast(n&8 as bit)as CHAR(1))+cast(cast(n&4 as bit)as CHAR(1))+cast(cast(n&2 as bit)as CHAR(1))+cast(cast(n&1 as bit)as CHAR(1))as b FROM g),P as(SELECT * from (values(1), (2), (4), (8), (16), (32)) as Q(p)),S as(select distinct p,p+(substring(b,6,1)*1)*(case when p=1 then 0 else 1 end)+(substring(b,5,1)*2)*(case when p=2 then 0 else 1 end)+(substring(b,4,1)*4)*(case when p=4 then 0 else 1 end)+(substring(b,3,1)*8)*(case when p=8 then 0 else 1 end)+(substring(b,2,1)*16)*(case when p=16 then 0 else 1 end)+(substring(b,1,1)*32)*(case when p=32 then 0 else 1 end)as e from P cross apply B),D as(select * from S where e>=p and e<61),R as(select p,(row_number()over(partition by p order by cast(e as int)))%5 as r,e from D),H as(select k.p,'['+stuff((select','+cast(l.e as varchar)from R l where l.p=k.p and l.r=k.r for xml path('')),1,1,'')+']'as s from R k group by k.p,k.r)select stuff((select','+cast(x.s as varchar)from H x where x.p=z.p for xml path('')),1,1,'')from H z group by z.p

Démo en ligne

Essayez-le en ligne!

Version détaillée - avec des notes comme commentaires SQL

WITH gen -- numbers 1 to 60
AS (
    SELECT 1 AS num
    UNION ALL
    SELECT num+1 FROM gen WHERE num+1<=60
),
BINARIES -- string representations of binaries 000001 through 111111
as (
SELECT 
    +cast( cast(num & 32 as bit) as CHAR(1))
    +cast( cast(num & 16 as bit)  as CHAR(1))
    +cast( cast(num & 8 as bit)  as CHAR(1))
    +cast( cast(num & 4 as bit)  as CHAR(1))
    +cast( cast(num & 2 as bit)   as CHAR(1))
    +cast(cast(num & 1 as bit)  as CHAR(1)) as binry FROM gen
),
POWERS -- first 6 powers of 2
as (
SELECT * from (values(1), (2), (4), (8), (16), (32)) as Q(powr)
),
SETELEMENTS -- cross apply the six powers of 2 against the binaries
-- returns 2 cols. col 1 = the power of 2 in question.
-- col 2 is calculated as that power of 2 plus the sum of each power of 2 other than the current row's power value, 
-- but only where a given power of 2 is switched "on" in the binary string, 
-- ie. where the first digit in the string represents 32, the second represents 16 and so on. 
-- That is, if the binary is 100100 then the number will be 
-- the sum of (32 x 1) + (16 x 0) + (8 x 0) + (4 x 1) + (2 x 0) + (1 x 0) 
-- but if the current row's power is 32 or 4, then just that number (32 or 4) is excluded from the sum.
-- rows are distinct.
as (
select distinct powr,
powr+
 (substring(binry,6,1) * 1) * (case when powr = 1 then 0 else 1 end)
 +(substring(binry,5,1) * 2) * (case when powr = 2 then 0 else 1 end)
 +(substring(binry,4,1) * 4) * (case when powr = 4 then 0 else 1 end)
 +(substring(binry,3,1) * 8) * (case when powr = 8 then 0 else 1 end)
 +(substring(binry,2,1) * 16) * (case when powr = 16 then 0 else 1 end)
 +(substring(binry,1,1) * 32) * (case when powr = 32 then 0 else 1 end) as elt
from POWERS cross apply BINARIES
),
DISTINCTELEMENTS -- purge calculated numbers smaller than the power of 2 or greater than 60
as (
select * from SETELEMENTS where elt >= powr and elt < 61
)--,
,
ROWNUMBERED -- for each power, number the rows repeatedly from 0 through 5, then back to 0 through 5 again, etc
as (
select powr, (row_number() over (partition by powr order by cast(elt as int)))%5 as r, elt  from DISTINCTELEMENTS
),
GROUPEDSETS -- for each row number, within each power, aggregate the numbers as a comma-delimited list and wrap in square brackets - the inner arrays
as (
select r1.powr, '['+stuff((select ',' + cast(r2.elt as varchar) from ROWNUMBERED r2 where r2.powr = r1.powr and r2.r = r1.r for xml path('')),1,1,'')+']' as s
from ROWNUMBERED r1
group by r1.powr,r1.r
)
select -- now aggregate all the inner arrays per power
stuff((select ',' + cast(g2.s as varchar) from GROUPEDSETS g2 where g2.powr = g1.powr for xml path('')),1,1,'')
from GROUPEDSETS g1
group by g1.powr

Voila!

Remarque 1: une partie de la logique concerne le rendu des crochets et des virgules.

Remarque 2: les versions plus récentes de SQLServer ont des approches plus compactes pour créer des listes séparées par des virgules. (Cela a été créé sur SQL Server 2016.)

Remarque 3: Les tableaux pour une carte donnée ne sont pas triés (ce qui est correct selon les spécifications). Les nombres dans un tableau sont correctement triés. Dans ce cas, chaque "carte" de la question, rend ses tableaux sur une ligne distincte dans les résultats.

Tableaux plus courts à code dur?

Oui.

Byte moi.

C # (Visual C # Interactive Compiler) , 112 octets

_=>" ".Select(x=>Enumerable.Range(1,60).Where(l=>(l&x)>0).Select((a,b)=>new{a,b}).GroupBy(i=>i.b%5,i=>i.a))

Essayez-le en ligne!

Rouge , 108 107 octets

n: 32 until[b: collect[repeat k 60[if n and k = n[keep k]]]loop 5[print
extract b 5 b: next b]1 > n: n / 2]

Essayez-le en ligne!

APL + WIN, 65 62 octets

v←∊+\¨n,¨29⍴¨1↓¨(n⍴¨1),¨1+n←2*0,⍳5⋄((v=61)/v)←¯1⋄1 3 2⍉6 6 5⍴v

Essayez-le en ligne! Gracieuseté de Dyalog Classic

MATLAB, 155 octets

cellfun(@disp,cellfun(@(x)x-repmat(62,5,6).*(x>60),cellfun(@(x)reshape(find(x,30),[5 6]),mat2cell(dec2bin(1:62)-48,62,ones(1,6)),'Uniform',0),'Uniform',0))

Cela pourrait être plus court que plusieurs lignes, mais je voulais le faire en une seule ligne de code.

05AB1E , 14 octets

žOε60LDNo&ĀÏ5ι

Essayez-le en ligne!