Viết chương trình hoặc hàm, cho một số nguyên n, xây dựng một mảng có nkích thước chiều ndài, trong đó mỗi phần tử là một định danh cho tọa độ của chính nó. Đó là, bắt đầu với một mảng, điền vào đó ncác mảng, trong đó mỗi nmảng chứa nhiều mảng hơn, cho đến độ sâu n-1. Các phần tử của mảng sâu nhất là tọa độ mô tả vị trí của chúng trong mảng đầy đủ.

Một số ví dụ trong trường hợp giải thích của tôi là khó hiểu.

n = 1

["1"]

n = 2

[
 ["11", "12"],
 ["21", "22"]
]

n = 3

[
  [
    ["111","112","113"],
    ["121","122","123"],
    ["131","132","133"]
  ],
  [
    ["211","212","213"],
    ["221","222","223"],
    ["231","232","233"]
  ],
  [
    ["311","312","313"],
    ["321","322","323"],
    ["331","332","333"]
  ]
]

Ở đây, "321" có nghĩa là nó là phần tử thứ 1 của phần tử thứ 2 của mảng thứ 3.

Quy tắc:

• Tọa độ và thứ nguyên ( n) có thể là 0 hoặc 1 được lập chỉ mục
• Bạn có thể giả sử nlà một chữ số, dưới 10 cho cả hai tùy chọn lập chỉ mục để ngăn chặn đầu ra mơ hồ
• IO rất linh hoạt.
  • Cụ thể, tọa độ có thể là mảng, chuỗi, vv miễn là chúng rõ ràng. "321" => [3,2,1]
  • Đầu ra có thể là số nguyên trong cơ sở 10 có hoặc không có các số 0 đứng đầu.
  • Các tọa độ có thể theo thứ tự ngược lại nếu bạn muốn, miễn là nó phù hợp. "321" => "123"
  • Đầu ra không nhất thiết phải là một cấu trúc mảng trong ngôn ngữ của bạn. Miễn là có các dấu hiệu riêng biệt rõ ràng để bắt đầu một mảng, kết thúc một mảng và để tách các phần tử.
  • Đầu ra cho n=1chỉ có thể là 1
  • Nếu đầu ra của bạn không điển hình, hãy đảm bảo giải thích định dạng.
• Đây là môn đánh gôn, vì vậy giải pháp ngắn nhất trong mỗi ngôn ngữ sẽ thắng!

APL Dyalog , 5 3 byte

⍳⍴⍨

-2 byte nhờ FrownyFrog

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

⍳đưa ra tất cả các chỉ số cho hình dạng của một mảng. ví dụ 2 3 .
⍴định hình lại arg bên phải là kích thước của arg bên trái. ⍨làm cho cả hai là đúng arg.

Python 3 , 56 byte

f=lambda n,*l:len(l)//n*l or[f(n,*l,k)for k in range(n)]

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

Ông Xcoder đã lưu 2 byte chuyển sang Python 3 để giải nén sao.

Ngôn ngữ Wolfram (Mathicala) , 32 22 byte

^{-10 byte nhờ @alephalpha}

Array[List,#~Table~#]&

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

J , 18 byte

,"1/^:(]{:)~@,.@i.

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

Giải pháp lặp, không có sản phẩm cartesian tích hợp. Đây là những gì đỉnh J trông giống như.

                       input                                    2
                i.     range                                 0, 1
             ,.@       reshape each element
                       into a one-dimensional array        [0],[1]   (A)
    ^:(]{:)            (input−1) times...             (1 iteration)
,"1/       ~@             prepend the contents of each 1d array in A    |
                          to every 1d array from the previous iteration,|  
                          assembling the results for each A[n] into     |!CANTEXPLAINTHIS!
                          a larger array                                |
                                                         [ [0,0],       |
                                                           [0,1] ],     |
                                                         [ [1,0],       |
                                                           [1,1] ]      |

Thạch , 8 7 byte

ṗ³s³$³¡

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

Giải trình

Sử dụng đối số 2 làm ví dụ.

ṗ³s³$³¡   
ṗ        Cartesian power with power
 ³       2 (the argument). Autoranges the left arg.
         Yields [[1,1],[1,2],[2,1],[2,2]]
    $³¡  Do 2 times:
  s³     Split into segments of length 2. 
         This last step molds the array of indices into the proper shape.

Nếu ¡không thay đổi, đó là đối số đúng của các lần lặp cho dyads thì đây sẽ là 4 byte:ṗs³¡

J, 13 byte

[:{[;/@$,:@i.

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

Điều thú vị này dài hơn nhiều so với câu trả lời của APL (mặc dù đó có thể là khả năng của tôi để xem bản dịch tốt hơn)

giải trình

[: { [ ;/@$ ,:@i.


     [                NB. the argument
            ,:@i.     NB. range 0..arg, considered as one item: ,: is "itemize" 
          $           NB. repeat the right range the left number of times
       ;/@            NB. and then put boxes around them. so, eg, if we had
                      NB. an arg of 3, now we have the list of boxes 
                      NB. [0 1 2][0 1 2][0 1 2]
[: {                  NB. { is "Catalog", it creates the cartesian product
                      NB. in exactly the format we desire.

MATLAB, 92 89 55 byte

Tôi có một câu trả lời khác khi đọc lại các quy tắc của thử thách, nhưng tôi sẽ để lại nỗ lực trước đây vì nó khác biệt và vẫn rất vui khi xem xét.

reshape(string(dec2base(0:n^n-1,n+(n<2))),[~(1:n)+n 1])

Giải trình

                        0:n^n-1                        % [0,1,...,n^n-1]
               dec2base(       ,n+(n<2))               % Put into base n (base 2 if n=1)
        string(                         )              % Convert to strings
                                          [~(1:n)+n 1] % Dimension array [n,n,...,n] (length n)
reshape(                                 ,            )% Use dim array to reshape

Điều này tạo ra một chuỗi các chuỗi n chiều được lập chỉ mục 0.

Câu trả lời trước (89 byte)

Golf đầu tiên của tôi! Điều này có thể có thể giảm nhiều hơn nhưng tôi nghĩ tôi đã đăng những gì tôi đã có.

x=(1:n)';for d=2:n;y=((1:n)*10^(d-1));o=[];for p=1:nnz(y);o=cat(d,o,(x+y(p)));end;x=o end

Giải trình

x=(1:n)';                       % Create array x=[1,2,...n]'
for d=2:n                       % d for dimension
    y=((1:n)*10^(d-1));         % Creates an array for each d where
                                %   y=[10,20,30,...] for n=2
                                %   y=[100,200,...] for n=3 etc.
    o=[];                       % o for output
    for p=1:nnz(y)              % For each value of y
        o=cat(d,...             % Concatenate in the dth dimension:
            o,...               % - The current output
            x+y(p));            % - The sum of
                                %   - The array from the last dimension
                                %   - The current value in y (e.g. 100)
    end
    x=o                         % Send the output to x for the next loop
end

Đầu ra x ở cuối để đưa ra giải pháp

Tương tự như bài MATLAB khác, đầu ra là một mảng n chiều, ngoại trừ nó sử dụng các số để hiển thị tọa độ. Nó hoạt động với bất kỳ giá trị nào, mặc dù vì các vòng lặp rất tệ trong MATLAB, nó bắt đầu chậm lại đáng kể khoảng n = 8.

Chỉnh sửa: -2 byte nhờ Luis Mendo. Cũng loại bỏ dấu chấm phẩy cuối cùng để in đầu ra.

Rust ,201 176 167 166 154 byte

enum L{S(String),L(Vec<L>)}fn
h(n:u8,d:u8,s:&str)->L{if
d<1{L::S(s.into())}else{L::L((0..n).map(|i|h(n,d-1,&format!("{}{}",s,i))).collect())}}|n|h(n,n,"")

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

Loại đầu ra là một loại tổng với hai biến thể khi ngôn ngữ được gõ đúng. Nó có thể Llà một loại danh sách chứa loại tổng này hoặc Slà loại kết quả (một chuỗi). Kết quả có thể trông như thế này.

L::L([
 L::L([ L::S("00"), L::S("01") ]),
 L::L([ L::S("10"), L::S("11") ]),
])

Ngoài ra, định dạng lại bằng cách sử dụng rustfmt:

enum L {
    S(String),
    L(Vec<L>),
}
fn h(n: u8, d: u8, s: &str) -> L {
    if d < 1 {
        L::S(s.into())
    } else {
        L::L(
            (0..n)
                .map(|i| h(n, d - 1, &format!("{}{}", s, i)))
                .collect(),
        )
    }
}
|n| h(n, n, "")

R , 102 byte

function(n,m=array(T,rep(n,n)))`if`(n<2,'1',{m[]=apply(which(m,T)[,`[<-`(1:n,1:2,2:1)],1,toString);m})

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

• 1 chỉ mục, đảo ngược
• Thật không may, R lưu trữ ma trận theo cột, nếu không chúng ta có thể giảm xuống 73 byte
• -9 byte được lưu nhờ đề xuất @Giuseppe để sử dụng whichlập chỉ mục mảng

Java 10, 144 byte

Giải pháp là phương pháp f. Nó tạo ra một chuỗi đại diện của mảng.

String h(int n,int d,String s){if(d<1)return s;var r="[";for(int i=0;i++<n;)r+=h(n,d-1,s+i)+",";return r+"]";}String f(int n){return h(n,n,"");}

Dùng thử trực tuyến

Bị đánh cắp

String h(int n, int d, String s) {
    if (d < 1)
        return s;
    var r = "[";
    for (int i = 0; i++ < n;)
        r += h(n, d - 1, s + i) + ",";
    return r + "]";
}
String f(int n) {
    return h(n, n, "");
}

Lời cảm ơn

• tiết kiệm byte nhờ Konrad Borowski

05AB1E , 7 byte

LsãsGsô

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

Giải trình

L          # push range [1 ... input]
 sã        # input repeated cartesian products of the list
   sG      # input - 1 times do:
     sô    # split into input parts

JavaScript (Node.js) , 62 60 58 byte

f=(n,i=n,s='')=>i?[...Array(n)].map((_,j)=>f(n,i-1,s+j)):s

Hãy thử trực tuyến! Đầu ra là 0-index. Chỉnh sửa: Đã lưu 2 byte nhờ @JoKing và thêm 2 byte nhờ @Arnauld.

MATLAB, 116 108 104 byte

Tôi cảm thấy như phải có một cách ngắn hơn để làm điều này, với sự yêu thích của MATLAB đối với ma trận đa chiều ... Cảm ơn Luis vì 4 byte từ một số thao tác ngắn

a=~(1:n)+n;c=cell(1,n);[c{:}]=ind2sub(a,1:n^n);reshape(arrayfun(@(varargin)[varargin{:}],c{:},'un',0),a)

Giải trình

% For using twice, define the array of dimension sizes [n, n, .., n]
a=~(1:n)+n;
% To group variable number of outputs from ind2sub into a cell array
c=cell(1,n);   
% Convert linear indices to self-describing coordinates
[c{:}]=ind2sub(a,1:n^n);     
% reshape to make it the n-dimensional array
% arrayfun to loop over the numerous ind2sub outputs simultaneously
% varargin and {:} usage to account for various numbers of inputs
reshape(arrayfun(@(varargin)[varargin{:}],c{:},'uni',0),a)

Đầu ra là một mảng ô n chiều, trong đó mỗi phần tử là một mảng của các giá trị tọa độ. Hoạt động cho bất kỳ nkhông có sự mơ hồ vì đầu ra mảng số, miễn là một n^(n+1)mảng phần tử có thể được lưu trữ trong RAM!

Than , 26 byte

Ｎθ≔ＥＸθθ⪫⪪◧⍘ιθθ ¦0υＦθ≔⪪υθυυ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

Ｎθ

Đầu vào n.

≔ＥＸθθ⪫⪪◧⍘ιθθ ¦0υ

Tạo tất cả các nⁿ nsố-chữ số trong cơ sở n.

Ｆθ≔⪪υθυ

Chia nthời gian của chúng thành một nmảng hai chiều trong đó mỗi chiều có kích thước n.

υ

In mảng. Định dạng đầu ra mặc định là mỗi phần tử trên một dòng riêng của nó, sau đó mỗi khối ndòng được kết thúc bằng một dòng trống, sau đó mỗi khối của ncác ndòng được kết thúc bởi một dòng trống thứ hai, và cứ thế lên đến n-1các dòng trống ở cấp cao nhất .

Thạch , 7 byte

ṗṁẋ`ŒṬ$

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