Schreibe ein Programm oder eine Funktion , die, da eine ganze Zahl n, eine Anordnung mit dem Konstrukt nDimensionen nLänge, wobei jedes Element ein Identifizierer des eigenen Koordinaten. Das heißt, beginnend mit einem Array, füllen Sie es mit nArrays, wobei jedes Array nmehr Arrays enthält, bis zu einer Tiefe von n-1. Die Elemente der tiefsten Felder sind die Koordinaten, die beschreiben, wo sie sich im vollständigen Feld befinden.

Einige Beispiele für den Fall, dass meine Erklärung verwirrend war.

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

Hier bedeutet "321", dass es sich um das 1. Element des 2. Elements des 3. Arrays handelt.

Regeln:

• Koordinaten und Dimension ( n) können entweder mit 0 oder 1 indiziert werden
• Sie können davon ausgehen n, dass beide Indizierungsoptionen einstellige Werte unter 10 aufweisen, um mehrdeutige Ausgaben zu vermeiden
• IO ist flexibel.
  • Insbesondere können Koordinaten Arrays, Strings usw. sein, solange sie klar sind. "321" => [3,2,1]
  • Die Ausgabe kann Ganzzahlen in der Basis 10 mit oder ohne führende Nullen sein.
  • Die Koordinaten können auf Wunsch in umgekehrter Reihenfolge angegeben werden, solange sie konsistent sind. 321 => 123
  • Die Ausgabe muss nicht unbedingt eine Array-Struktur in Ihrer Sprache sein. Solange es eindeutige Markierungen für den Anfang eines Arrays, das Ende eines Arrays und zum Trennen von Elementen gibt.
  • Die Ausgabe für n=1kann nur 1 sein
  • Wenn Ihre Ausgabe untypisch ist, stellen Sie sicher, dass Sie das Format erklären.
• Das ist Code-Golf, also gewinnt die kürzeste Lösung in jeder Sprache!

Dyalog APL , 5 3 Bytes

⍳⍴⍨

-2 Bytes dank FrownyFrog

Probieren Sie es online!

⍳gibt alle Indizes in der Form eines Arrays an. zB 2 3 .
⍴Formt das rechte Argument so um, dass es der Größe des linken Arguments entspricht. ⍨macht beides zum richtigen argument.

Python 3 , 56 Bytes

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

Probieren Sie es online!

Mr. Xcoder sparte 2 Bytes beim Umstieg auf Python 3 für das Entpacken mit einem Stern.

Wolfram Language (Mathematica) , 32 22 Bytes

^{-10 Bytes dank @alephalpha}

Array[List,#~Table~#]&

Probieren Sie es online!

J , 18 Bytes

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

Probieren Sie es online!

Iterative Lösung, kein eingebautes kartesisches Produkt. So sieht Peak J aus.

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

Gelee , 8 7 Bytes

ṗ³s³$³¡

Probieren Sie es online!

Erläuterung

Verwenden Sie Argument 2 als Beispiel.

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

Wenn ¡nicht das richtige Argument für Iterationen für Dyaden geändert würde, wären dies 4 Bytes:ṗs³¡

J, 13 Bytes

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

Probieren Sie es online!

Interessanterweise ist dies so viel länger als die APL-Antwort (obwohl ich möglicherweise keine bessere Übersetzung sehen kann)

Erläuterung

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

Ich habe eine andere Antwort, nachdem ich die Regeln der Herausforderung erneut gelesen habe, aber ich lasse den vorherigen Versuch unten, da er anders ist und immer noch Spaß macht.

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

Erläuterung

                        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

Dies gibt ein n-dimensionales Array von Strings aus, die mit 0 indiziert sind.

Vorherige Antwort (89 Bytes)

Mein erstes Golf! Dies kann wahrscheinlich mehr reduziert werden, aber ich dachte, ich würde posten, was ich habe.

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

Erläuterung

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

Gibt am Ende x aus, um eine Lösung zu erhalten

Ähnlich wie bei anderen MATLAB-Posts ist die Ausgabe ein n-dimensionales Array, außer dass zur Anzeige der Koordinaten Zahlen verwendet werden. Es funktioniert für jeden Wert, obwohl die Schleifen in MATLAB schlecht sind und sich um n = 8 deutlich verlangsamen.

Edit: -2 Bytes dank Luis Mendo. Das letzte Semikolon wurde ebenfalls entfernt, um die Ausgabe zu drucken.

Rust ,201 176 167 166 154 Bytes

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

Probieren Sie es online!

Der Ausgabetyp ist ein Summentyp mit zwei Varianten, da die Sprache streng typisiert ist. LDies kann entweder ein Listentyp sein, der diesen Summentyp enthält, oder Sein Ergebnistyp (eine Zeichenfolge). Das Ergebnis kann so aussehen.

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

Auch neu formatiert mit 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 Bytes

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

Probieren Sie es online!

• 1-indiziert, umgekehrt
• Leider speichert R die Matrix spaltenweise, ansonsten könnten wir auf 73 Bytes zurückgehen
• -9 Bytes gespart dank @Giuseppe Vorschlag zur Verwendung der whichArray-Indizierung

Java 10, 144 Bytes

Die Lösung ist Methode f. Es wird eine Zeichenfolgendarstellung des Arrays erstellt.

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

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

Danksagung

• Byte-Einsparungen dank Konrad Borowski

05AB1E , 7 Bytes

LsãsGsô

Probieren Sie es online!

Erläuterung

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 Bytes

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

Probieren Sie es online! Der Ausgang ist 0-indiziert. Bearbeiten: 2 Bytes dank @JoKing und weitere 2 Bytes dank @Arnauld gespeichert.

MATLAB, 116 108 104 Bytes

Angesichts der Affinität von MATLAB zu mehrdimensionalen Matrizen muss es meiner Meinung nach einen kürzeren Weg geben, dies zu tun ... Vielen Dank an Luis für die 4 Bytes, die von einigen Kürzungen stammen

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

Erläuterung

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

Die Ausgabe ist ein n-dimensionales Zellenarray, wobei jedes Element ein Array der Koordinatenwerte ist. Funktioniert für jedenn aufgrund der numerischen Array-Ausgabe ohne Mehrdeutigkeiten, solange ein n^(n+1)Element-Array im RAM gespeichert werden kann!

Holzkohle , 26 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

Ｎθ

Eingabe n.

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

Generieren Sie alle nⁿ n-stelligen Zahlen in der Basis n.

Ｆθ≔⪪υθυ

Teilen Sie sie nmal in ein neindimensionales Array auf, wobei jede Dimension eine Größe hat n.

υ

Drucken Sie das Array. Der Standardausgabeformat jedes Element in einer eigenen Zeile ist, dann wird jeder Block von nZeilen durch eine Leerzeile beendet ist, dann wird jeder Block von nBlöcken von nZeilen wird durch eine zweite Leerzeile beendet ist , und so weiter bis zu n-1Leerzeilen auf der obersten Ebene .

Gelee , 7 Bytes

ṗṁẋ`ŒṬ$

Probieren Sie es online!