Thách thức chỉ đơn giản là; xuất sáu mảng số nguyên 2D sau:

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

Những mảng số nguyên 2D này là gì? Đây là những con số được sử dụng trong trò ảo thuật với những lá bài chứa những con số này:

Trò ảo thuật yêu cầu ai đó nghĩ về một số trong phạm vi [1, 60] và đưa cho người thực hiện trò ảo thuật đó tất cả các thẻ có chứa số này. Người thực hiện trò ảo thuật sau đó có thể tính tổng các số trên cùng bên trái (tất cả sức mạnh bằng 2) của các thẻ đã cho để lấy số mà người đó đang nghĩ đến. Một số giải thích thêm về lý do tại sao công trình này có thể được tìm thấy ở đây.

Quy tắc thử thách:

• Bạn có thể xuất sáu mảng số nguyên 2D ở bất kỳ định dạng hợp lý nào. Có thể được in với dấu phân cách; có thể là mảng số nguyên 3D chứa sáu mảng số nguyên 2D; có thể là một danh sách chuỗi các dòng; v.v.
• Bạn được phép điền vào vị trí dưới cùng bên phải của bốn thẻ cuối cùng với giá trị âm trong phạm vi [-60, -1]hoặc ký tự '*'thay vì bỏ nó để tạo các ma trận mảng số nguyên 2D (không, bạn không được phép điền vào chúng 0hoặc không -integer thích null/ undefinedthay thế, ngoại trừ *vì một ngôi sao cũng được sử dụng trong các thẻ thực tế).
• Thứ tự của các số trong ma trận là bắt buộc. Mặc dù nó không quan trọng đối với trò ảo thuật vật lý, tôi thấy thử thách này chủ yếu dưới dạng ma trận - độ phức tạp kolmogorov , do đó hạn chế về trật tự.
  Thứ tự của các ma trận trong danh sách đầu ra có thể theo bất kỳ thứ tự nào, vì nó rõ ràng từ thẻ trên cùng bên trái là ma trận nào.

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Quy tắc chuẩn áp dụng cho câu trả lời của bạn với quy tắc I / O mặc định , vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn (tức là TIO ).
• Ngoài ra, thêm một lời giải thích cho câu trả lời của bạn rất được khuyến khích.

MATL , 12 11 byte

-1 byte nhờ chính chủ :)

60:B"@fQ6eq

Giải trình:

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

Hãy thử trực tuyến!

Perl 6 , 63 46 byte

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

Hãy thử trực tuyến!

Đầu ra dưới dạng mảng 2D trên nhiều dòng, với mảng cuối cùng của mỗi dòng bị cắt nếu cần thiết.

Python 2 , 76 byte

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

Hãy thử trực tuyến!

Phương pháp ở đây là tạo một danh sách tất cả các số có thể r(61) và sau đó chia nhỏ nó xuống danh sách các số cho một thẻi&2**k .

Sau đó, bằng cách sử dụng cắt danh sách, danh sách các số 1D đó được sắp xếp lại theo kích thước thẻ 6x5 chính xác [card nums][j::5]for j in r(5) .

Sau đó, trình tạo này chỉ được lặp lại cho 6 thẻ for k in r(6) .

Mặc dù tôi không thể tìm thấy bất kỳ giải pháp nào dưới 76 byte, nhưng đây là hai giải pháp khác cũng là 76 byte:

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

Hãy thử trực tuyến!

Điều tiếp theo này được lấy cảm hứng từ 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

Hãy thử trực tuyến!

Bất kỳ ý kiến ​​được đánh giá rất cao.

Than , 26 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Tôi đã thử tính toán các mục trực tiếp nhưng đây đã là 27 byte trước khi điều chỉnh *ở phía dưới bên phải. Đầu ra mỗi hàng được nối với khoảng trắng và một dòng trống giữa các thẻ. Giải trình:

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

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

Hãy thử trực tuyến!

Giải trình

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 byte

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

Hãy thử trực tuyến!

Giải trình

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 byte

ṠMöTC5Wnünḣ60

Hãy thử trực tuyến!

Giải trình

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

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

Hãy thử trực tuyến!

_{-4 byte, nhờ Jonathan Allan}

Japt , 14 byte

6Æ60õ f&2pX)ó5

Thử nó

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 byte

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

Hãy thử trực tuyến!

Đã bình luận

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

Cảm hứng lấy từ cả TFeld và The Matt's .

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

Hãy thử trực tuyến!

C (gcc) , 95 byte

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

Hãy thử trực tuyến!

Trả về ma trận dưới dạng mảng int 3D trong o.

4 ma trận cuối cùng có -1 là giá trị cuối cùng của chúng.

Đã lưu 2 byte nhờ Kevin Cruijssen.

Đã lưu 7 8 byte nhờ Arnauld.

CJam (18 byte)

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

Bản demo trực tuyến . Đây là một chương trình đầy đủ mà đầu ra cho thiết bị xuất chuẩn.

Mổ xẻ

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

Thạch , 13 byte

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

Một liên kết niladic mang lại một danh sách (6) danh sách các số nguyên. (Nó xuất ra tùy chọn mặc định không có *hoặc không có phụ.)

Hãy thử trực tuyến!

Làm sao?

Mỗi ma trận chứa, theo thứ tự chính cột, các số lên đến $60$ chia sẻ bit set đơn với số trên cùng bên trái (tối thiểu).

Chương trình này đầu tiên làm cho tất cả $60$ danh sách các số có thể có trong $[1,60]$chia sẻ bất kỳ bit-set nào với số chỉ mục của chúng. Sau đó nó tách từng phần thành từng phần của$5$và chỉ giữ lại những cái có độ dài tối thiểu - sẽ là những cái mà chỉ mục chỉ có một tập bit duy nhất (và do đó cũng là giá trị tối thiểu của nó). Cuối cùng, nó chuyển đổi từng thứ để đưa chúng vào thứ tự chính cột.

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

Rất nhiều số 15 mà không nhận ra thủ thuật "tối thiểu theo chiều dài khi chia thành fives":

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

... Và, trong khi cố gắng tìm kiếm ngắn hơn, tôi đã nhận được 13 cái khác mà không cần mánh khóe nào cả:

60B€Uz0Ts5ZƊ€

Ngôn ngữ Wolfram (Mathicala) , 88 byte

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

Ngôn ngữ Wolfram (Mathicala) , 99 byte

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

Hãy thử trực tuyến!

Thạch , 13 byte

60B€Uz0µTs5Z)

Hãy thử trực tuyến!

Dựa vào câu trả lời MATL của flawr . Một liên kết niladic mà đưa ra một danh sách các danh sách theo yêu cầu.

R , 73 byte

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

Tôi không hoàn toàn chắc chắn liệu tôi có đáp ứng yêu cầu về thứ tự hay không, vì R mặc định điền vào ma trận theo cột, vì vậy thứ tự xuất hiện trên thẻ giống như cách phân bổ ma trận trong R.

Hãy thử trực tuyến!

T-SQL, ( 1.168 1.139 byte)

Tôi chỉ muốn biết tôi có thể làm điều đó.

Phiên bản tối ưu hóa

 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

Bản demo trực tuyến

Hãy thử trực tuyến!

Phiên bản dài dòng - với ghi chú là nhận xét 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!

Lưu ý 1: Một số logic liên quan đến kết xuất dấu ngoặc vuông và dấu phẩy.

Lưu ý 2: Các phiên bản SQLServer mới hơn có các cách tiếp cận nhỏ gọn hơn để tạo danh sách được phân tách bằng dấu phẩy. (Điều này đã được tạo trên SQL Server 2016.)

Lưu ý 3: Mảng cho một thẻ nhất định không được sắp xếp (không phù hợp với thông số kỹ thuật). Các số trong một mảng được sắp xếp chính xác. Trong trường hợp này, mỗi "thẻ" của câu hỏi, kết xuất các mảng của nó trên một hàng riêng biệt trong kết quả.

Ngắn hơn để mảng mã cứng?

Vâng.

Tạm biệt tôi

C # (Trình biên dịch tương tác Visual C #) , 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))

Hãy thử trực tuyến!

Màu đỏ , 108 107 byte

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]

Hãy thử trực tuyến!

APL + THẮNG, 65 62 byte

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

Hãy thử trực tuyến! Lịch sự của Dyalog Classic

MATLAB, 155 byte

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

Điều này có thể ngắn hơn nhiều dòng nhưng tôi muốn làm điều đó trong một dòng mã.

05AB1E , 14 byte

žOε60LDNo&ĀÏ5ι

Hãy thử trực tuyến!