O desafio é simplesmente; produz as seis seguintes matrizes inteiras 2D:

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

O que são essas matrizes inteiras 2D? Estes são os números usados ​​em um truque de mágica com cartões contendo estes números:

O truque de mágica pede que alguém pense em um número no intervalo [1, 60] e dê a quem executa o truque de mágica todas as cartas que contêm esse número. O jogador que executa o truque de mágica pode somar os números do canto superior esquerdo (com potência de 2) das cartas dadas para chegar ao número em que a pessoa estava pensando. Algumas explicações adicionais sobre por que isso funciona podem ser encontradas aqui.

Regras do desafio:

• Você pode gerar as seis matrizes inteiras 2D em qualquer formato razoável. Pode ser impresso com delimitadores; pode ser uma matriz inteira 3D contendo as seis matrizes inteiras 2D; pode ser uma lista de linhas de linhas; etc.
• Você pode preencher a posição inferior direita dos últimos quatro cartões com um valor negativo no intervalo [-60, -1]ou no caractere, em '*'vez de deixá-lo de fora para criar matrizes retangulares de matrizes inteiras 2D (não, não é permitido preenchê-las com 0ou sem -integer como null/ undefinedcomo alternativa, com a exceção de *que uma estrela também é usada nas cartas reais).
• A ordem dos números nas matrizes é obrigatória. Embora não importe para o truque de mágica física, vejo esse desafio principalmente como uma matriz - complexidade de kolmogorov , daí a restrição de ordem.
  A ordem das matrizes na lista de saída pode estar em qualquer ordem, pois fica claro no cartão superior esquerdo qual matriz é qual.

Regras gerais:

• Isso é código-golfe , então a resposta mais curta em bytes vence.
  Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
• As regras padrão se aplicam à sua resposta com as regras de E / S padrão , para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
• As brechas padrão são proibidas.
• Se possível, adicione um link com um teste para o seu código (ou seja, TIO ).
• Além disso, é altamente recomendável adicionar uma explicação para sua resposta.

MATL , 12 11 bytes

-1 byte graças ao próprio mestre :)

60:B"@fQ6eq

Explicação:

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

Experimente online!

Perl 6 , 63 46 bytes

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

Experimente online!

Produz como matrizes 2D em várias linhas, com a última matriz de cada uma cortada, se necessário.

Python 2 , 76 bytes

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

Experimente online!

O método aqui é criar uma lista de todos os números possíveis r(61)e depois reduzi-los à lista de números de um cartão i&2**k.

Em seguida, usando o fatiamento de lista, a lista de números 1D é reorganizada no tamanho de cartão 6x5 correto [card nums][j::5]for j in r(5).

Então, este gerador é repetido apenas para 6 cartões for k in r(6).

Embora eu não tenha encontrado soluções com menos de 76 bytes, aqui estão outras duas que também têm 76 bytes:

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

Experimente online!

Este próximo é inspirado em 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

Experimente online!

Quaisquer comentários são muito apreciados.

Carvão , 26 bytes

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

Experimente online! Link é a versão detalhada do código. Tentei calcular as entradas diretamente, mas isso já tinha 27 bytes antes de ajustar para o *no canto inferior direito. Produz cada linha unida com espaços e uma linha em branco entre os cartões. Explicação:

Ｅ⁶                          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 bytes

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

Experimente online!

Explicação

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 bytes

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

Experimente online!

Explicação

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

Casca , 13 bytes

ṠMöTC5Wnünḣ60

Experimente online!

Explicação

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

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

Experimente online!

_{-4 bytes, graças a Jonathan Allan}

Japonês , 14 bytes

6Æ60õ f&2pX)ó5

Tente

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 bytes

_=>[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=[]))

Experimente online!

Comentado

_ =>                        // 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 bytes

Inspiração tirada do TFeld e do Matt .

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

Experimente online!

C (gcc) , 95 bytes

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

Experimente online!

Retorna as matrizes como uma matriz int 3D em o.

As últimas 4 matrizes têm -1 como seu último valor.

Economizou 2 bytes graças a Kevin Cruijssen.

Economizou 7 8 bytes graças a Arnauld.

CJam (18 bytes)

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

Demonstração online . Este é um programa completo com saída para stdout.

Dissecação

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

Gelatina , 13 bytes

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

Um link niládico que gera uma lista de (6) listas de listas de números inteiros. (Ele gera a opção padrão de não ter *ou nenhum preenchimento negativo.)

Experimente online!

Quão?

$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

Muitos 15s sem perceber o truque "mínimo de comprimento quando dividido em cinco":

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

... e, enquanto tentava achar menor, consegui outros 13 sem precisar do truque:

60B€Uz0Ts5ZƊ€

Wolfram Language (Mathematica) , 88 bytes

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

Wolfram Language (Mathematica) , 99 bytes

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

Experimente online!

Gelatina , 13 bytes

60B€Uz0µTs5Z)

Experimente online!

Basicamente baseado na resposta MATL da flawr . Um link niládico que gera uma lista de listas conforme necessário.

R , 73 bytes

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

Não tenho certeza absoluta de que atendi ao requisito de ordem, já que R, por padrão, preenche matrizes por coluna. Portanto, a ordem em que aparece fisicamente nos cartões é a mesma que a maneira como as matrizes são alocadas em R.

Experimente online!

T-SQL, ( 1.168 1.139 bytes)

Eu só queria saber que eu poderia fazer isso.

Versão otimizada

 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

Demonstração online

Experimente online!

Versão detalhada - com notas como comentários 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!

Nota 1: Parte da lógica se refere à renderização de colchetes e vírgulas.

Nota 2: As versões mais recentes do SQLServer têm abordagens mais compactas para criar listas delimitadas por vírgulas. (Isso foi criado no SQL Server 2016.)

Nota 3: As matrizes para um determinado cartão não são classificadas (o que é aceitável de acordo com as especificações). Os números em uma matriz são classificados corretamente. Nesse caso, cada "cartão" da pergunta renderiza suas matrizes em uma linha separada nos resultados.

Matrizes mais curtas para codificar?

Sim.

Byte me.

C # (compilador interativo do Visual C #) , 112 bytes

_=>" ".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))

Experimente online!

Vermelho , 108 107 bytes

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]

Experimente online!

APL + WIN, 65 62 bytes

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

Experimente online! Cortesia de Dyalog Classic

MATLAB, 155 bytes

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

Isso poderia ser mais curto como várias linhas, mas eu queria fazê-lo em uma linha de código.

05AB1E , 14 bytes

žOε60LDNo&ĀÏ5ι

Experimente online!