Die Herausforderung ist einfach; gibt die folgenden sechs 2D-Integer-Arrays aus:

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

Was sind diese 2D-Integer-Arrays? Dies sind die Zahlen, die in einem Zaubertrick mit Karten verwendet werden, die diese Zahlen enthalten:

Der Zaubertrick fordert jemanden auf, sich eine Zahl im Bereich [1, 60] auszudenken und demjenigen, der den Zaubertrick ausführt, alle Karten zu geben, die diese Zahl enthalten. Derjenige, der den Zaubertrick ausführt, kann dann die oberen linken Zahlen (alle Zweierpotenzen) der gegebenen Karten addieren, um die Zahl zu erhalten, an die die Person gedacht hat. Einige zusätzliche Erklärungen, warum dies funktioniert, finden Sie hier.

Herausforderungsregeln:

• Sie können die sechs 2D-Integer-Arrays in jedem vernünftigen Format ausgeben. Kann mit Trennzeichen gedruckt werden; kann ein 3D-Integer-Array sein, das die sechs 2D-Integer-Arrays enthält; kann eine String-Liste von Zeilen sein; etc.
• Sie dürfen die untere rechte Position der letzten vier Karten mit einem negativen Wert im Bereich [-60, -1]oder im Zeichen füllen, '*'anstatt es wegzulassen, um die rechteckigen Matrizen der 2D-Ganzzahl-Arrays zu erstellen (nein, Sie dürfen sie nicht mit 0oder ohne füllen) -integer wie null/ undefinedals Alternative, mit der Ausnahme *, dass in den eigentlichen Karten auch ein Stern verwendet wird.
• Die Reihenfolge der Zahlen in den Matrizen ist obligatorisch. Obwohl es für den physischen Zaubertrick keine Rolle spielt, sehe ich diese Herausforderung hauptsächlich als eine Matrix - eine Kolmogorov-Komplexität , daher die Einschränkung der Ordnung.
  Die Reihenfolge der Matrizen selbst in der Ausgabeliste kann beliebig sein, da aus der Karte oben links hervorgeht, welche Matrix welche ist.

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln mit Standard-E / A-Regeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp, verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu (z. B. TIO ).
• Außerdem wird dringend empfohlen, eine Erklärung für Ihre Antwort hinzuzufügen.

MATL , 12 11 Bytes

-1 Byte danke an den Master selbst :)

60:B"@fQ6eq

Erläuterung:

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

Probieren Sie es online!

Perl 6 , 63 46 Bytes

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

Probieren Sie es online!

Ausgabe als 2D-Arrays auf mehreren Zeilen, wobei das letzte Array von jedem abgeschnitten wird, falls erforderlich.

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

Probieren Sie es online!

Die Methode hier besteht darin, eine Liste aller möglichen Zahlen zu erstellen r(61)und diese dann auf die Liste der Zahlen für eine Karte zu reduzieren i&2**k.

Durch Verwenden von List Slicing wird diese 1D-Liste von Zahlen auf die richtige 6x5-Kartengröße umgeordnet [card nums][j::5]for j in r(5).

Dann wird dieser Generator nur für 6 Karten wiederholt for k in r(6).

Während ich keine Lösung mit weniger als 76 Bytes finden konnte, sind hier zwei andere, die ebenfalls 76 Bytes umfassen:

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

Probieren Sie es online!

Das nächste ist von Jonathan Allan inspiriert .

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

Probieren Sie es online!

Alle Kommentare werden sehr geschätzt.

Holzkohle , 26 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Ich habe versucht, die Einträge direkt zu berechnen, aber dies waren bereits 27 Bytes, bevor ich *das unten rechts korrigierte. Gibt jede Zeile mit Leerzeichen und einer Leerzeile zwischen den Karten aus. Erläuterung:

Ｅ⁶                          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ô®ζ

Probieren Sie es online!

Erläuterung

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ô®ζ,

Probieren Sie es online!

Erläuterung

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

Schale , 13 Bytes

ṠMöTC5Wnünḣ60

Probieren Sie es online!

Erläuterung

          ḣ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

Probieren Sie es online!

_{-4 Bytes, danke an Jonathan Allan}

Japt , 14 Bytes

6Æ60õ f&2pX)ó5

Versuch es

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

Probieren Sie es online!

Kommentiert

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

Inspiration von TFeld's und The Matt's .

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

Probieren Sie es 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;}

Probieren Sie es online!

Gibt die Matrizen als 3D-Int-Array in o zurück.

Die letzten 4 Matrizen haben -1 als letzten Wert.

2 Bytes dank Kevin Cruijssen gespeichert.

7 8 Bytes dank Arnauld gespeichert .

CJam (18 Bytes)

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

Online-Demo . Dies ist ein vollständiges Programm, das auf stdout ausgegeben wird.

Präparation

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

Jelly , 13 Bytes

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

Ein niladischer Link, der eine Liste von (6) Listen von Listen von ganzen Zahlen liefert. (Es wird die Standardoption ohne *oder mit negativem Füllzeichen ausgegeben.)

Probieren Sie es online!

Wie?

$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

Viele 15er, ohne den Trick "Minimale Länge bei Aufteilung in fünf" zu bemerken:

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

... und als ich versuchte, eine kürzere zu finden, bekam ich eine weitere 13, ohne den Trick überhaupt zu brauchen:

60B€Uz0Ts5ZƊ€

Wolfram-Sprache (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

Probieren Sie es online!

Jelly , 13 Bytes

60B€Uz0µTs5Z)

Probieren Sie es online!

Lose basierend auf der MATL-Antwort von flawr . Ein Niladic-Link, der bei Bedarf eine Liste mit Listen ausgibt.

R , 73 Bytes

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

Ich bin mir nicht ganz sicher, ob ich die Bestellanforderung erfüllt habe, da R die Matrizen standardmäßig spaltenweise ausfüllt, sodass die Reihenfolge, in der sie physisch auf den Karten angezeigt wird, mit der Reihenfolge übereinstimmt, in der die Matrizen in R zugeordnet sind.

Probieren Sie es online!

T-SQL, ( 1.168 1.139 Bytes)

Ich wollte nur wissen, dass ich es schaffen kann.

Optimierte Version

 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

Online-Demo

Probieren Sie es online!

Ausführliche Version - mit Notizen als SQL-Kommentare

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!

Anmerkung 1: Einige der Logik bezieht sich auf das Rendern von eckigen Klammern und Kommas.

Hinweis 2: Neuere Versionen von SQL Server bieten kompaktere Ansätze zum Erstellen von durch Kommas getrennten Listen. (Dies wurde auf SQL Server 2016 erstellt.)

Hinweis 3: Arrays für eine bestimmte Karte werden nicht sortiert (was gemäß der Spezifikation in Ordnung ist). Zahlen innerhalb eines Arrays sind korrekt sortiert. In diesem Fall rendert jede "Karte" der Frage ihre Arrays in einer separaten Zeile in den Ergebnissen.

Kürzere bis hartcodierte Arrays?

Ja.

Byte mich.

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

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

Probieren Sie es online!

Rot , 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]

Probieren Sie es 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

Probieren Sie es online! Mit freundlicher Genehmigung von 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))

Dies könnte kürzer als mehrere Zeilen sein, aber ich wollte es in einer Codezeile tun.

05AB1E , 14 Bytes

žOε60LDNo&ĀÏ5ι

Probieren Sie es online!