Écrivez un programme ou une fonction qui, étant donné un entier n, construit un tableau avec des ndimensions de nlongueur, où chaque élément est un identifiant de ses propres coordonnées. Autrement dit, en commençant par un tableau, remplissez-le avec des ntableaux, où chacun d'entre eux contient nplus de tableaux, jusqu'à une profondeur de n-1. Les éléments des tableaux les plus profonds sont les coordonnées décrivant où ils se trouvent dans le tableau complet.

Quelques exemples au cas où mon explication serait déroutante.

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

Ici, "321" signifie qu'il s'agit du 1er élément du 2e élément du 3e tableau.

Règles:

• Les coordonnées et la dimension ( n) peuvent être indexées de 0 ou 1
• Vous pouvez supposer qu'il ns'agit d'un seul chiffre, inférieur à 10 pour les deux options d'indexation afin d'éviter les sorties ambiguës
• IO est flexible.
  • En particulier, les coordonnées peuvent être des tableaux, des chaînes, etc. tant qu'elles sont claires. "321" => [3,2,1]
  • La sortie peut être des nombres entiers en base 10 avec ou sans zéros non significatifs.
  • Les coordonnées peuvent être dans l'ordre inverse si vous le souhaitez, tant qu'elles sont cohérentes. "321" => "123"
  • La sortie ne doit pas nécessairement être une structure de tableau dans votre langue. Tant qu'il y a des marqueurs distincts clairs pour le début d'un tableau, la fin d'un tableau et pour séparer les éléments.
  • La sortie pour n=1peut simplement être 1
  • Si votre sortie est atypique, assurez-vous d'expliquer le format.
• C'est le code-golf, donc la solution la plus courte dans chaque langue gagne!

Dyalog APL , 5 3 octets

⍳⍴⍨

-2 octets grâce à FrownyFrog

Essayez-le en ligne!

⍳donne tous les indices étant donné la forme d'un tableau. par exemple 2 3 .
⍴remodèle l'argument de droite pour qu'il soit de la taille de l'arg de gauche. ⍨fait que les deux soient le bon argument.

Python 3 , 56 octets

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

Essayez-le en ligne!

M. Xcoder a économisé 2 octets en passant à Python 3 pour le décompression étoilé.

Wolfram Language (Mathematica) , 32 22 octets

^{-10 octets grâce à @alephalpha}

Array[List,#~Table~#]&

Essayez-le en ligne!

J , 18 octets

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

Essayez-le en ligne!

Solution itérative, pas de produit cartésien intégré. Voici à quoi ressemble le pic 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] ]      |

Gelée , 8 7 octets

ṗ³s³$³¡

Essayez-le en ligne!

Explication

Utilisez l'argument 2 comme exemple.

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

Si ¡cela ne variait pas, c'est le bon argument sur les itérations pour les dyades, alors ce serait 4 octets:ṗs³¡

J, 13 octets

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

Essayez-le en ligne!

Intéressant, c'est beaucoup plus long que la réponse APL (bien que cela puisse être mon incapacité à voir une meilleure traduction)

explication

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

J'ai une réponse différente après avoir relu les règles du défi, mais je vais laisser la tentative précédente ci-dessous car elle est différente et toujours amusante à regarder.

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

Explication

                        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

Cela génère un tableau à n dimensions de chaînes indexées à 0.

Réponse précédente (89 octets)

Mon premier golf! Cela peut probablement être réduit davantage, mais je pensais publier ce que j'avais.

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

Explication

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

Sorties x à la fin pour donner la solution

Semblable à l'autre post MATLAB, la sortie est un tableau à n dimensions, sauf qu'il utilise des nombres pour afficher les coordonnées. Cela fonctionne pour n'importe quelle valeur, bien que parce que les boucles sont mauvaises dans MATLAB, cela commence à ralentir considérablement autour de n = 8.

Edit: -2 octets grâce à Luis Mendo. Le dernier point-virgule a également été supprimé pour imprimer la sortie.

Rouille ,201 176 167 166 154 octets

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

Essayez-le en ligne!

Le type de sortie est un type somme avec deux variantes car la langue est strictement typée. Il peut s'agir soit d' Lun type de liste contenant ce type de somme, soit d' Sun type de résultat (une chaîne). Le résultat peut ressembler à ceci.

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

Aussi, reformaté en utilisant 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 octets

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

Essayez-le en ligne!

• 1 indexé, inversé
• malheureusement, R stocke la matrice par colonne, sinon nous pourrions descendre à 73 octets
• -9 octets enregistrés grâce à la suggestion de @Giuseppe d'utiliser l' whichindexation des tableaux

Java 10, 144 octets

La solution est la méthode f. Il produit une représentation sous forme de chaîne du tableau.

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

Essayez-le en ligne

Non golfé

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

Remerciements

• économie d'octets grâce à Konrad Borowski

05AB1E , 7 octets

LsãsGsô

Essayez-le en ligne!

Explication

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 octets

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

Essayez-le en ligne! La sortie est indexée 0. Edit: 2 octets enregistrés grâce à @JoKing et 2 octets supplémentaires grâce à @Arnauld.

MATLAB, 116 108 104 octets

J'ai l'impression qu'il doit y avoir un moyen plus court de le faire, étant donné l'affinité de MATLAB pour les matrices multidimensionnelles ... Merci à Luis pour les 4 octets de quelques raccourcis

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

Explication

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

La sortie est un tableau de cellules à n dimensions, où chaque élément est un tableau des valeurs de coordonnées. Fonctionne pour tout nsans ambiguïté en raison de la sortie du tableau numérique, tant qu'un n^(n+1)tableau d'éléments peut être stocké dans la RAM!

Fusain , 26 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

Ｎθ

Entrée n.

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

Générez tous les nⁿ nnombres à chiffres dans la base n.

Ｆθ≔⪪υθυ

Divisez-les nfois en un ntableau -dimensional où chaque dimension est de taille n.

υ

Imprimez le tableau. Le format de sortie par défaut est chaque élément sur sa propre ligne, puis chaque bloc de nlignes se termine par une ligne vierge, puis chaque bloc de nblocs de nlignes se termine par une deuxième ligne vierge, et ainsi de suite jusqu'à n-1des lignes vides au niveau supérieur .

Gelée , 7 octets

ṗṁẋ`ŒṬ$

Essayez-le en ligne!