เขียนโปรแกรมหรือฟังก์ชั่นที่กำหนดจำนวนเต็มnสร้างอาร์เรย์ที่มีnขนาดnความยาวโดยที่แต่ละองค์ประกอบเป็นตัวระบุพิกัดของมันเอง นั่นคือเริ่มต้นด้วยหนึ่งอาร์เรย์เติมมันมีnอาร์เรย์ที่แต่ละคนมีอาร์เรย์มากขึ้นถึงความลึกของn n-1องค์ประกอบของอาร์เรย์ที่ลึกที่สุดคือพิกัดที่อธิบายว่าพวกเขาอยู่ที่ไหนในอาเรย์แบบเต็ม

ตัวอย่างบางส่วนในกรณีที่คำอธิบายของฉันสับสน

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

นี่ "321" หมายถึงมันเป็นองค์ประกอบที่ 1 ขององค์ประกอบที่ 2 ของอาร์เรย์ที่ 3

กฎ:

• พิกัดและมิติ ( n) สามารถเป็นดัชนี 0 หรือ 1
• คุณอาจถือว่าnเป็นตัวเลขหลักเดียวต่ำกว่า 10 สำหรับตัวเลือกการทำดัชนีทั้งสองเพื่อป้องกันไม่ให้ผลลัพธ์ที่ไม่ชัดเจน
• IO ยืดหยุ่นได้
  • โดยเฉพาะอย่างยิ่งพิกัดสามารถเป็นอาร์เรย์สตริง ฯลฯ ตราบใดที่พวกเขามีความชัดเจน "321" => [3,2,1]
  • เอาต์พุตสามารถเป็นจำนวนเต็มในฐาน 10 โดยมีหรือไม่มีศูนย์นำหน้า
  • พิกัดอาจอยู่ในลำดับกลับกันหากคุณต้องการตราบใดที่มันสอดคล้องกัน "321" => "123"
  • ผลลัพธ์ไม่จำเป็นต้องเป็นโครงสร้างอาร์เรย์ในภาษาของคุณ ตราบใดที่มีเครื่องหมายที่แตกต่างกันชัดเจนสำหรับการเริ่มต้นของอาเรย์สิ้นสุดของอาเรย์และสำหรับการแยกองค์ประกอบ
  • เอาต์พุตสำหรับn=1สามารถเป็น 1 ได้
  • หากผลลัพธ์ของคุณผิดปกติตรวจสอบให้แน่ใจเพื่ออธิบายรูปแบบ
• นี่คือรหัสกอล์ฟเพื่อให้ทางออกที่สั้นที่สุดในแต่ละภาษาชนะ!

Dyalog APL , 5 3 ไบต์

⍳⍴⍨

-2 ไบต์ขอบคุณFrownyFrog

ลองออนไลน์!

⍳ให้ดัชนีทั้งหมดที่มีรูปร่างของอาร์เรย์ เช่น2 3
⍴ปรับรูปร่าง ARG ด้านขวาให้เป็นขนาดของ ARG ด้านซ้าย ⍨ทำให้ทั้งคู่เป็น ARG ที่เหมาะสม

Python 3 , 56 ไบต์

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

ลองออนไลน์!

Mr. Xcoder บันทึก 2 ไบต์สลับเป็น Python 3 เพื่อนำออกมาติดดาว

ภาษา Wolfram (Mathematica) , 32 22 ไบต์

^{-10 ไบต์ขอบคุณ @alephalpha}

Array[List,#~Table~#]&

ลองออนไลน์!

J , 18 ไบต์

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

ลองออนไลน์!

โซลูชันวนซ้ำไม่มีสินค้าคาร์ทีเซียนในตัว นี่คือสิ่งที่ยอด J ดูเหมือนว่า

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

เยลลี่ , 8 7 ไบต์

ṗ³s³$³¡

ลองออนไลน์!

คำอธิบาย

ใช้อาร์กิวเมนต์ 2 เป็นตัวอย่าง

ṗ³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.

หาก¡ไม่ได้เปลี่ยนแปลงมันจะเป็นการโต้แย้งที่ถูกต้องสำหรับการทำซ้ำสิ่งนี้จะเป็น 4 ไบต์:ṗs³¡

J, 13 ไบต์

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

ลองออนไลน์!

สิ่งที่น่าสนใจนี้มีความยาวมากกว่าคำตอบของ APL (แม้ว่าฉันอาจไม่เห็นคำแปลที่ดีกว่านี้)

คำอธิบาย

[: { [ ;/@$ ,:@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 ไบต์

ฉันมีคำตอบที่แตกต่างกันเมื่อได้อ่านกฎการท้าทายอีกครั้ง แต่ฉันจะออกจากความพยายามก่อนหน้านี้ด้านล่างเนื่องจากมันแตกต่างและยังสนุกที่จะดู

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

คำอธิบาย

                        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

สิ่งนี้จะส่งออกอาร์เรย์ n- มิติของสตริงซึ่งเป็น 0 ดัชนี

คำตอบก่อนหน้า (89 ไบต์)

กอล์ฟครั้งแรกของฉัน! อาจลดลงได้มากกว่านี้ แต่ฉันคิดว่าฉันโพสต์สิ่งที่ฉันมี

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

คำอธิบาย

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

เอาต์พุต x ที่ส่วนท้ายเพื่อให้โซลูชัน

คล้ายกับโพสต์ MATLAB อื่น ๆ เอาต์พุตเป็นอาเรย์ n-มิติยกเว้นว่าจะใช้ตัวเลขเพื่อแสดงพิกัด ใช้งานได้กับทุกค่าแม้ว่าลูปจะไม่ดีใน MATLAB แต่เริ่มทำงานช้าลงอย่างมีนัยสำคัญประมาณ n = 8

แก้ไข: -2 ไบต์ขอบคุณ Luis Mendo ลบเซมิโคลอนสุดท้ายออกเพื่อพิมพ์เอาต์พุต

สนิม ,201 176 167 166 154 ไบต์

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

ลองออนไลน์!

ชนิดเอาต์พุตเป็นชนิดผลรวมที่มีสองรูปแบบเนื่องจากภาษาถูกพิมพ์อย่างเคร่งครัด มันอาจเป็นได้Lซึ่งเป็นชนิดรายการที่มีประเภทผลรวมนี้หรือSเป็นประเภทผลลัพธ์ (สตริง) ผลลัพธ์สามารถมีลักษณะเช่นนี้

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

และจัดรูปแบบใหม่โดยใช้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 ไบต์

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

ลองออนไลน์!

• ดัชนี 1 รายการย้อนกลับ
• น่าเสียดายที่ R เก็บเมทริกซ์ทีละคอลัมน์มิฉะนั้นเราสามารถลงไปได้ที่73 ไบต์
• บันทึก -9 ไบต์ด้วยคำแนะนำ @Giuseppe เพื่อใช้การwhichจัดทำดัชนีอาร์เรย์

Java 10, 144 ไบต์

fการแก้ปัญหาคือวิธีการ มันผลิตการเป็นตัวแทนสตริงของอาร์เรย์

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,"");}

ลองใช้ออนไลน์

Ungolfed

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, "");
}

กิตติกรรมประกาศ

• ขอบคุณการประหยัดแบบไบต์ไปยังKonrad Borowski

05AB1E , 7 ไบต์

LsãsGsô

ลองออนไลน์!

คำอธิบาย

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 ไบต์

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

ลองออนไลน์! เอาท์พุทเป็นดัชนี 0 แก้ไข: บันทึก 2 ไบต์ด้วย @JoKing และอีก 2 ไบต์ขอบคุณ @Arnauld

MATLAB, 116 108 104 ไบต์

ฉันรู้สึกว่าต้องมีวิธีที่สั้นกว่านี้ในการทำเช่นนี้เนื่องจากความสัมพันธ์ของ MATLAB ต่อการฝึกอบรมหลายมิติ ... ขอบคุณลูอิสสำหรับ 4 ไบต์จากการส่งแบบระยะสั้น

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

คำอธิบาย

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

เอาต์พุตเป็นอาร์เรย์เซลล์ n-มิติโดยที่แต่ละองค์ประกอบเป็นอาร์เรย์ของค่าพิกัด ทำงานได้nโดยไม่ต้องมีความกำกวมเนื่องจากเอาต์พุตอาร์เรย์ที่เป็นตัวเลขตราบใดที่n^(n+1)องค์ประกอบอาร์เรย์สามารถเก็บไว้ใน RAM!

ถ่าน 26 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย:

Ｎθ

nอินพุต

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

สร้างทุกnⁿ nหมายเลข -digit nในฐาน

Ｆθ≔⪪υθυ

แยกพวกเขาnครั้งเป็นอาร์เรย์มิติที่แต่ละมิติที่มีขนาดnn

υ

พิมพ์อาร์เรย์ รูปแบบเอาต์พุตเริ่มต้นคือแต่ละองค์ประกอบในบรรทัดของตัวเองจากนั้นแต่ละบล็อกของnบรรทัดจะถูกยกเลิกด้วยบรรทัดว่างจากนั้นแต่ละบล็อกของnบล็อกของnบรรทัดจะถูกยกเลิกโดยบรรทัดว่างที่สองและอื่น ๆ จนถึงn-1บรรทัดว่างที่ระดับบนสุด .

เยลลี่ขนาด 7 ไบต์

ṗṁẋ`ŒṬ$

ลองออนไลน์!