Escriba un programa o función que, dado un número entero n, construya una matriz con ndimensiones de nlongitud, donde cada elemento es un identificador de sus propias coordenadas. Es decir, comenzando con una matriz, llénela con nmatrices, donde cada una de ellas contiene nmás matrices, hasta una profundidad de n-1. Los elementos de las matrices más profundas son las coordenadas que describen dónde están en la matriz completa.

Algunos ejemplos en caso de que mi explicación fuera 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"]
  ]
]

Aquí, "321" significa que es el primer elemento del segundo elemento de la tercera matriz.

Reglas:

• Las coordenadas y la dimensión ( n) pueden ser 0 o 1 indexadas
• Puede suponer que ntiene un solo dígito, debajo de 10 para ambas opciones de indexación para evitar salidas ambiguas
• IO es flexible.
  • En particular, las coordenadas pueden ser matrices, cadenas, etc., siempre que estén claras. "321" => [3,2,1]
  • La salida puede ser enteros en base 10 con o sin ceros a la izquierda.
  • Las coordenadas pueden estar en orden inverso si lo desea, siempre que sea coherente. "321" => "123"
  • La salida no necesariamente tiene que ser una estructura de matriz en su idioma. Siempre y cuando haya claros marcadores distintos para el inicio de una matriz, el final de una matriz y para separar elementos.
  • La salida n=1puede ser solo 1
  • Si su salida es atípica, asegúrese de explicar el formato.
• Este es el código de golf, por lo que gana la solución más corta en cada idioma.

Dyalog APL , 5 3 bytes

⍳⍴⍨

-2 bytes gracias a FrownyFrog

Pruébalo en línea!

⍳da todos los índices dados la forma de una matriz. por ejemplo, 2 3 .
⍴da nueva forma al argumento derecho para que tenga el tamaño del argumento izquierdo. ⍨hace que ambos sean el argumento correcto.

Python 3 , 56 bytes

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

Pruébalo en línea!

El Sr. Xcoder guardó 2 bytes cambiando a Python 3 para desempacar con estrellas.

Wolfram Language (Mathematica) , 32 22 bytes

^{-10 bytes gracias a @alephalpha}

Array[List,#~Table~#]&

Pruébalo en línea!

J , 18 bytes

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

Pruébalo en línea!

Solución iterativa, sin producto cartesiano incorporado. Así es como se ve el pico 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] ]      |

Jalea , 8 7 bytes

ṗ³s³$³¡

Pruébalo en línea!

Explicación

Use el argumento 2 como ejemplo.

ṗ³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 ¡no variara, es el argumento correcto sobre las iteraciones para díadas, entonces esto sería 4 bytes:ṗs³¡

J, 13 bytes

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

Pruébalo en línea!

Es interesante que esto sea mucho más largo que la respuesta APL (aunque esa puede ser mi incapacidad para ver una mejor traducción)

explicación

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

Tengo una respuesta diferente al volver a leer las reglas del desafío, pero dejaré el intento anterior a continuación, ya que es diferente y aún divertido de ver.

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

Explicación

                        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

Esto genera una matriz n-dimensional de cadenas que están indexadas en 0.

Respuesta anterior (89 bytes)

Mi primer golf! Es probable que esto se reduzca más, pero pensé en publicar lo que tengo.

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

Explicación

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

Salidas x al final para dar solución

Similar a la otra publicación de MATLAB, la salida es una matriz n-dimensional, excepto que usa números para mostrar las coordenadas. Funciona para cualquier valor, aunque debido a que los bucles son malos en MATLAB, comienza a disminuir significativamente alrededor de n = 8.

Editar: -2 bytes gracias a Luis Mendo. También se eliminó el punto y coma final para imprimir la salida.

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

Pruébalo en línea!

El tipo de salida es un tipo de suma con dos variantes, ya que el idioma está estrictamente escrito. Puede ser L, que es un tipo de lista que contiene este tipo de suma o Sque es un tipo de resultado (una cadena). El resultado puede verse así.

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

Además, formateado 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 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})

Pruébalo en línea!

• 1 indexado, invertido
• desafortunadamente R almacena la matriz por columna, de lo contrario podríamos bajar a 73 bytes
• -9 bytes guardados gracias a la sugerencia de @Giuseppe para usar la whichindexación de matrices

Java 10, 144 bytes

La solución es el método f. Produce una representación de cadena de la matriz.

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

Pruébalo en línea

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

Expresiones de gratitud

• byte de ahorro gracias a Konrad Borowski

05AB1E , 7 bytes

LsãsGsô

Pruébalo en línea!

Explicación

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

Pruébalo en línea! La salida está indexada en 0. Editar: Guardado 2 bytes gracias a @JoKing y otros 2 bytes gracias a @Arnauld.

MATLAB, 116 108 104 bytes

Siento que debe haber una forma más corta de hacer esto, dada la afinidad de MATLAB hacia las matrices multidimensionales ... Gracias a Luis por los 4 bytes de alguna entrega corta

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

Explicación

% 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 salida es una matriz de celdas n-dimensionales, donde cada elemento es una matriz de los valores de coordenadas. Funciona para cualquier persona nsin ambigüedad debido a la salida de la matriz numérica, ¡siempre que una n^(n+1)matriz de elementos se pueda almacenar en la RAM!

Carbón , 26 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Ｎθ

Entrada n.

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

Genere todos los nⁿ nnúmeros de dígitos en la base n.

Ｆθ≔⪪υθυ

Dividirlos nen una nmatriz dimensional donde cada dimensión es de tamaño n.

υ

Imprime la matriz. El formato de salida predeterminado es cada elemento en su propia línea, luego cada bloque de nlíneas termina con una línea en blanco, luego cada bloque de nbloques de nlíneas termina con una segunda línea en blanco, y así sucesivamente hasta n-1las líneas en blanco en el nivel superior .

Jalea , 7 bytes

ṗṁẋ`ŒṬ$

Pruébalo en línea!