Scrivi un programma o una funzione che, dato un numero intero n, costruisca un array con ndimensioni di nlunghezza, in cui ogni elemento è un identificatore delle proprie coordinate. Cioè, a partire da un array, popolarlo con narray, in cui ciascuno di essi contiene npiù array, fino a una profondità di n-1. Gli elementi delle matrici più profonde sono le coordinate che descrivono dove si trovano nella matrice completa.

Alcuni esempi nel caso in cui la mia spiegazione fosse confusa.

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

Qui, "321" significa che è il primo elemento del secondo elemento del terzo array.

Regole:

• Le coordinate e la dimensione ( n) possono essere indicizzate 0 o 1
• Si può presumere che nsia una cifra singola, inferiore a 10 per entrambe le opzioni di indicizzazione per evitare output ambigui
• IO è flessibile.
  • In particolare, le coordinate possono essere matrici, stringhe ecc. Purché siano chiare. "321" => [3,2,1]
  • L'output può essere numeri interi in base 10 con o senza zeri iniziali.
  • Le coordinate possono essere in ordine inverso se lo si desidera, purché sia ​​coerente. "321" => "123"
  • L'output non deve necessariamente essere una struttura array nella tua lingua. Finché ci sono marcatori distinti chiari per l'inizio di un array, la fine di un array e per separare gli elementi.
  • L'output per n=1può essere solo 1
  • Se l'output è atipico, assicurati di spiegare il formato.
• Questo è code-golf, quindi vince la soluzione più breve in ogni lingua!

Dyalog APL , 5 3 byte

⍳⍴⍨

-2 byte grazie a FrownyFrog

Provalo online!

⍳dà tutti gli indici data la forma di un array. ad es. 2 3 .
⍴rimodella l'arg destro in modo che abbia le dimensioni dell'arg sinistro. ⍨rende entrambi l'arg giusto.

Python 3 , 56 byte

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

Provalo online!

Mr. Xcoder ha salvato 2 byte passando a Python 3 per il disimballaggio stellato.

Wolfram Language (Mathematica) , 32 22 byte

^{-10 byte grazie a @alephalpha}

Array[List,#~Table~#]&

Provalo online!

J , 18 byte

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

Provalo online!

Soluzione iterativa, nessun prodotto cartesiano incorporato. Questo è l'aspetto del picco 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] ]      |

Gelatina , 8 7 byte

ṗ³s³$³¡

Provalo online!

Spiegazione

Usa l'argomento 2 come esempio.

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

Se ¡non variava l'argomento giusto sulle iterazioni per le diade allora questo sarebbe di 4 byte:ṗs³¡

J, 13 byte

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

Provalo online!

Interessante questo è molto più lungo della risposta APL (anche se potrebbe essere la mia incapacità di vedere una traduzione migliore)

spiegazione

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

Ho una risposta diversa dopo aver riletto le regole della sfida, ma lascerò il precedente tentativo di seguito poiché è diverso e ancora divertente da guardare.

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

Spiegazione

                        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

Questo genera una matrice n-dimensionale di stringhe che sono 0 indicizzate.

Risposta precedente (89 byte)

Il mio primo golf! Questo può probabilmente essere ridotto di più, ma ho pensato di pubblicare quello che ho.

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

Spiegazione

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

Emette x alla fine per dare una soluzione

Simile all'altro post MATLAB, l'output è un array n-dimensionale, tranne per il fatto che utilizza i numeri per visualizzare le coordinate. Funziona per qualsiasi valore, anche se poiché i loop sono negativi in ​​MATLAB, inizia a rallentare significativamente intorno a n = 8.

Modifica: -2 byte grazie a Luis Mendo. Rimosso anche il punto e virgola finale per stampare l'output.

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

Provalo online!

Il tipo di output è un tipo di somma con due varianti poiché la lingua è tipizzata rigorosamente. Può essere uno dei due L, che è un tipo di elenco contenente questo tipo di somma o Sche è un tipo di risultato (una stringa). Il risultato può apparire così.

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

Inoltre, riformattato usando 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})

Provalo online!

• 1 indicizzato, invertito
• purtroppo R memorizza matrice per colonna, altrimenti potremmo scendere a 73 byte
• -9 byte salvati grazie al suggerimento @Giuseppe per utilizzare l' whichindicizzazione dell'array

Java 10, 144 byte

La soluzione è il metodo f. Produce una rappresentazione in formato stringa dell'array.

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

Provalo online

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

Ringraziamenti

• risparmio di byte grazie a Konrad Borowski

05AB1E , 7 byte

LsãsGsô

Provalo online!

Spiegazione

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

Provalo online! L'output è indicizzato 0. Modifica: salvato 2 byte grazie a @JoKing e altri 2 byte grazie a @Arnauld.

MATLAB, 116 108 104 byte

Sento che ci deve essere un modo più breve per farlo, data l'affinità di MATLAB nei confronti delle matrici multidimensionali ... Grazie a Luis per i 4 byte di alcune mani corte

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

Spiegazione

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

L'output è un array di celle n-dimensionale, in cui ogni elemento è un array di valori di coordinate. Funziona per tutti nsenza ambiguità a causa dell'output di array numerici, purché un n^(n+1)array di elementi possa essere archiviato nella RAM!

Carbone , 26 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

Ｎθ

Input n.

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

Genera tutti nⁿ ni numeri di cifre in base n.

Ｆθ≔⪪υθυ

Dividili i ntempi in una nmatrice tridimensionale in cui ogni dimensione è di dimensioni n.

υ

Stampa l'array. Il formato di output predefinito è ogni elemento su una propria riga, quindi ogni blocco di nrighe viene terminato da una riga vuota, quindi ogni blocco di nblocchi di nrighe viene terminato da una seconda riga vuota e così via fino alle n-1righe vuote al livello superiore .

Gelatina , 7 byte

ṗṁẋ`ŒṬ$

Provalo online!