Виклик просто; вивести наступні шість 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]]

Які ці 2D цілі масиви? Це цифри, які використовуються у чарівному трюку з картками, що містять ці числа:

Чарівний трюк просить когось придумати число в діапазоні [1, 60] і дати тому, хто виконує магічний трюк, всі карти, які містять це число. Той, хто виконує магічний трюк, може підсумовувати ліві верхні ліви (потужність 2) даних карт, щоб дістатись до числа, про яке думала людина. Деякі додаткові пояснення, чому це працює, можна знайти тут.

Правила виклику:

• Ви можете вивести шість 2D цілих масивів у будь-якому розумному форматі. Можна друкувати роздільниками; може бути тривимірним масивом 3D, що містить шість 2D цілих масивів; може бути рядком-рядком рядків; тощо.
• Ви можете заповнити нижню праву позицію останніх чотирьох карт негативним значенням у діапазоні [-60, -1]чи символі, '*'замість того, щоб випускати її, щоб зробити 2D цілі масиви прямокутними матрицями (ні, вам заборонено заповнювати їх 0чи не -цілість як null/ undefinedяк альтернатива, за винятком того, *що зірка також використовується у фактичних картах).
• Порядок чисел у матрицях є обов’язковим. Хоча це не має значення для фізичного магічного трюку, я бачу цей виклик головним чином як матрицю - колгорогоров-складність , отже, обмеження на порядок.
  Порядок самих матриць у списку вихідних даних може бути в будь-якому порядку, оскільки з лівої верхньої карти зрозуміло, яка саме матриця.

Загальні правила:

• Це код-гольф , тому найкоротша відповідь у байтах виграє.
  Не дозволяйте мовам коду-гольфу відштовхувати вас від публікації відповідей з не кодовими гольф-мовами. Спробуйте придумати якомога коротшу відповідь на "будь-яку" мову програмування.
• Для вашої відповіді застосовуються стандартні правила з правилами вводу / виводу за замовчуванням , тому вам дозволяється використовувати STDIN / STDOUT, функції / метод із відповідними параметрами та повним програмами типу повернення. Твій дзвінок.
• Лазівки за замовчуванням заборонені.
• Якщо можливо, додайте посилання з тестом для вашого коду (тобто TIO ).
• Також настійно рекомендується додавати пояснення до своєї відповіді.

MATL , 12 11 байт

-1 байт завдяки самому майстру :)

60:B"@fQ6eq

Пояснення:

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

Спробуйте в Інтернеті!

Perl 6 , 63 46 байт

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

Спробуйте в Інтернеті!

Виводиться у вигляді двовимірних масивів у кількох рядках, при цьому останній масив кожного з них обрізається, якщо це необхідно.

Python 2 , 76 байт

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

Спробуйте в Інтернеті!

Метод тут полягає у створенні списку всіх можливих чисел, r(61)а потім відбиванні до списку чисел для картки i&2**k.

Потім, використовуючи нарізки списку, 1D список номерів переставляють на правильний розмір картки 6x5 [card nums][j::5]for j in r(5).

Потім цей генератор просто повторюється протягом 6 карт for k in r(6).

Хоча я не міг знайти жодного рішення менше 76 байт, ось два інших, які також є 76 байтами:

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

Спробуйте в Інтернеті!

Цей наступний натхненний Джонатаном Алланом .

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

Спробуйте в Інтернеті!

Будь-які коментарі дуже вдячні.

Вугілля деревне , 26 байт

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

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Я спробував обчислити записи безпосередньо, але це вже було 27 байт, перш ніж налаштувати значення *в нижньому правому куті. Виводить кожен рядок, з'єднаний з пробілами та порожнім рядком між картками. Пояснення:

Ｅ⁶                          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 байт

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

Спробуйте в Інтернеті!

Пояснення

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 байт

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

Спробуйте в Інтернеті!

Пояснення

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

Лушпиння , 13 байт

ṠMöTC5Wnünḣ60

Спробуйте в Інтернеті!

Пояснення

          ḣ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 байт

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

Спробуйте в Інтернеті!

_{-4 байти, завдяки Джонатану Аллану}

Japt , 14 байт

6Æ60õ f&2pX)ó5

Спробуй це

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 байт

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

Спробуйте в Інтернеті!

Прокоментував

_ =>                        // 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 байти

Натхнення, взяте як від TFeld, так і від The Matt's .

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

Спробуйте в Інтернеті!

C (gcc) , 95 байт

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

Спробуйте в Інтернеті!

Повертає матриці у вигляді масиву 3D int у o.

Останні 4 матриці мають -1 як останнє значення.

Збережено 2 байти завдяки Kevin Cruijssen.

Збережено 7 8 байт завдяки Арнольду.

CJam (18 байт)

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

Інтернет демо . Це повна програма, яка виводить на stdout.

Розсічення

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

Желе , 13 байт

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

Ніладичне посилання, яке дає список (6) списків списків цілих чисел. (Він виводить за допомогою типового параметра відсутність *або негативний заповнювач.)

Спробуйте в Інтернеті!

Як?

$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

Багато 15-ти років, не усвідомлюючи трюку "мінімальний за довжиною, коли розділено на п'ять":

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

... і, намагаючись знайти коротший, я отримав ще 13, не потребуючи фокусу:

60B€Uz0Ts5ZƊ€

Мова Вольфрама (Mathematica) , 88 байт

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

Мова Вольфрама (Mathematica) , 99 байт

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

Спробуйте в Інтернеті!

Желе , 13 байт

60B€Uz0µTs5Z)

Спробуйте в Інтернеті!

Вільно ґрунтується на відповіді MATL недоліка . Ніладичне посилання, яке видає список списків у міру необхідності.

R , 73 байти

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

Я не зовсім впевнений, чи задовольнив я вимогу замовлення, оскільки R за замовчуванням заповнює матриці за стовпцями, тому порядок такий, що фізично відображається на картках, такий самий, як матриці розподіляються в Р.

Спробуйте в Інтернеті!

T-SQL, ( 1168 1,139 байт)

Я просто хотів знати, що можу це зробити.

Оптимізована версія

 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

Демонстрація в Інтернеті

Спробуйте в Інтернеті!

Докладна версія - з примітками як коментарі 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

Вуаля!

Примітка 1: Деяка логіка стосується візуалізації квадратних дужок та коми.

Примітка 2. Новіші версії SQLServer мають більш компактні підходи до створення списків, обмежених комами. (Це було створено на SQL Server 2016.)

Примітка 3: Масиви для даної картки не сортуються (що нормально за специфікацією). Числа в масиві правильно відсортовані. У цьому випадку кожна «картка» запитання виводить свої масиви в окремий рядок у результатах.

Короткі масиви з жорстким кодом?

Так.

Байте мене.

C # (Visual C # Interactive Compiler) , 112 байт

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

Спробуйте в Інтернеті!

Червоний , 108 107 байт

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]

Спробуйте в Інтернеті!

APL + WIN, 65 62 байти

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

Спробуйте в Інтернеті! Надано Dyalog Classic

MATLAB, 155 байт

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

Це може бути коротше декількох рядків, але я хотів це зробити в одному рядку коду.

05AB1E , 14 байт

žOε60LDNo&ĀÏ5ι

Спробуйте в Інтернеті!