En:  Suficiente memoria y un entero positivo N

Fuera:  N-N N ^ N matriz llena de N, donde N ^ N significa N términos de N-por-N-por-N-por ...

Ejemplos:

1: [1]que es una matriz 1D (una lista) de longitud 1, que contiene un solo 1

2: [[2,2],[2,2]]que es una matriz 2D (una tabla) con 2 filas y 2 columnas, llenas de 2

3: [[[3,3,3],[3,3,3],[3,3,3]],[[3,3,3],[3,3,3],[3,3,3]],[[3,3,3],[3,3,3],[3,3,3]]]que es una matriz 3D (un cubo) con 3 capas, 3 filas y 3 columnas, llenas de 3

4: [[[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]]],[[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]]],[[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]]],[[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]]]]

5 y 6: Vea una de las respuestas.

Python , 32 bytes

lambda n:eval('['*n+'n'+']*n'*n)

Pruébalo en línea!

Hace una cadena como "[[[n]*n]*n]*n"con nmultiplcaciones, y la evalúa como código Python. Como la evaluación se realiza dentro del alcance de la función, el nombre de la variable se nevalúa como entrada de la función.

J, 4 bytes

$~#~

Pruébalo en línea!

Explicación

$~#~  Input: integer n
  #~  Create n copies of n
$~    Shape n into an array with dimensions n copies of n

APL (Dyalog APL) , 4 bytes

⍴⍨⍴⊢

Pruébalo en línea!

Mathematica, 22 20 bytes

(t=Table)@@t[#,#+1]&

(* or *)

Table@@Table[#,#+1]&

R, 26

Esta es la respuesta obvia, pero ¿quizás hay algo más inteligente?

n=scan();array(n,rep(n,n))

JavaScript (ES6),  44  40 bytes

f=(n,k=i=n)=>i--?f(n,Array(n).fill(k)):k

Manifestación

f=(n,k=i=n)=>i--?f(n,Array(n).fill(k)):k

console.log(JSON.stringify(f(1)))
console.log(JSON.stringify(f(2)))
console.log(JSON.stringify(f(3)))
console.log(JSON.stringify(f(4)))

Haskell , 52 bytes

f n=iterate(filter(>'"').show.(<$[1..n]))(show n)!!n

Pruébalo en línea!

Inspirado por la respuesta de @ nimi , pero usando más funciones predefinidas.

• Utiliza iteratey en !!lugar de una función de ayuda recursiva.
• En lugar de construir delimitadores de lista "a mano", se utiliza filter(>'"').showpara formatear una lista de cadenas y luego se eliminan los "caracteres adicionales .

05AB1E (heredado) , 6 5 bytes

-1 gracias a Kevin Cruijssen

F¹.D)

Pruébalo en línea!

F     # For 0 .. input
 ¹.D) # Push <input> copies of the result of the last step as an array

Octava, 35 33 25 23 20 bytes

@(N)ones(N+!(1:N))*N

Pruébalo en línea!

@(N)ones(N*ones(1,N))*N

@(N)repmat(N,N*ones(1,N))

Gracias a @LuisMendo ahorró 8 bytes

@(N)ones(num2cell(!(1:N)+N){:})*N

Pruébalo en línea!

Respuesta anterior:

@(N)repmat(N,num2cell(!(1:N)+N){:})

Pruébalo en línea!

Haskell, 62 bytes

n#0=show n
n#l='[':tail((',':)=<<n#(l-1)<$[1..n])++"]"
f n=n#n

Ejemplo de uso: f 2-> "[[2,2],[2,2]]". Pruébalo en línea! .

El sistema de tipo estricto de Haskell impide una función que devuelve listas anidadas de diferentes profundidades, por lo que construyo el resultado como una cadena.

Cómo funciona:

n#l=                         n with the current level l is
    '[':                     a literal [ followed by
           n#(l-1)<$[1..n]   n copies of   n # (l-1)
        (',':)=<<            each prepended by a , and flattened into a single list
      tail                   and the first , removed
                  ++"]"      followed by a literal ]

n#0=show n                   the base case is n as a string

f n=n#n                      main function, start with level n         

MATL, 8 bytes

ttY"l$l*

Pruébelo en MATL Online (he agregado un código que muestra el tamaño real de la salida ya que todas las salidas n-dimensionales en MATL se muestran como matrices 2D donde todas las dimensiones> 2 se aplanan en la segunda dimensión).

Explicación

        % Implicitly grab the input (N)
tt      % Make two copies of N
Y"      % Perform run-length decoding to create N copies of N
l$1     % Create a matrix of ones that is this size  
*       % Multiply this matrix of ones by N
        % Implicitly display the result  

Python 2 , 36 bytes

-2 bytes gracias a @CalculatorFeline

a=n=input()
exec"a=[a]*n;"*n
print a

Pruébalo en línea!

CJam , 12 bytes

ri:X{aX*}X*p

Pruébalo en línea!

Explicación

ri:X          Read an integer from input, store it in X (leaves it on the stack)
    {   }X*   Execute this block X times:
     a          Wrap the top of stack in an array
      X*        Repeat the array X times
           p  Print nicely

Jalea , 5 bytes

⁾Wẋẋv

Pruébalo en línea!

¿Cómo?

⁾Wẋẋv - Main link: n                            e.g.       3
⁾Wẋ   - character pair literal ['W','ẋ']                  "Wẋ"
   ẋ  - repeat list n times                               "WẋWẋWẋ"
    v - evaluate as Jelly code with input n          eval("WẋWẋWẋ", 3)
      - ...
        WẋWẋ... - toEval: n                e.g. 3
        W        - wrap                        [3]
         ẋ       - repeat list n times         [3,3,3]
          Wẋ     - wrap and repeat            [[3,3,3],[3,3,3],[3,3,3]]
            ...  - n times total             [[[3,3,3],[3,3,3],[3,3,3]],[[3,3,3],[3,3,3],[3,3,3]],[[3,3,3],[3,3,3],[3,3,3]]]

Java 97 96 95 bytes

Object c(int n,int i){Object[]a=new Object[n];for(int j=0;j<n;)a[j++]=i<2?n:c(n,i-1);return a;}

Sin golf:

public class N_Dim {

    public static Object create(int n) {
        return create(n, n);
    }

    public static Object create(int n, int i) {
        Object[] array = new Object[n];
        for(int j=0;j<n;j++) {
            array[j] = i<2?n:create(n, i - 1);
        }
        return array;
    }

    public static void main(String[] args) {
        System.out.println(Arrays.deepToString((Object[]) create(3)));
    }

}

JavaScript (ES6), 38 bytes

f=(n,m=n)=>m?Array(n).fill(f(n,m-1)):n

La versión de esto que necesita mucha memoria es de 45 bytes:

f=(n,m=n)=>m?[...Array(n)].map(_=>f(n,m-1)):n

Bash + utilidades GNU, 117 bytes

n=$[$1**$1]
seq -f$1o%.fd$n+1-p $n|dc|rev|sed -r "s/(0+|$[$1-1]*).*$/\1/;s/^(0*)/\1$1/;s/^1/[1]/"|tr \\n0$[$1-1] \ []

Pruébalo en línea!

El programa esencialmente cuenta de 0 a (n ^ n) -1 en la base n, donde n es la entrada. Para cada número base-n k en el recuento, hace lo siguiente:

1. Si k termina con al menos un dígito 0, imprima un '[' para cada dígito 0 al final de k.
2. Imprimir n.
3. Si k termina con al menos un dígito n-1, imprima un ']' para cada dígito n-1 al final de k.

(El valor n = 1 necesita tener corchetes agregados como un caso especial. Este valor de entrada también genera algo de salida para stderr, que puede ignorarse bajo las reglas estándar de PPCG).

Quizás haya una forma más corta de implementar esta idea.

Ejecución de muestra:

./array 3
[[[3 3 3] [3 3 3] [3 3 3]] [[3 3 3] [3 3 3] [3 3 3]] [[3 3 3] [3 3 3] [3 3 3]]]

Jalea , 4 bytes

R»µ¡

Pruébalo en línea!

R»µ¡
R     Range. 2 -> [1, 2]
 »    Max between left arg and right arg. Vectorizes. -> [2, 2]
  µ   Separates into a new chain.
   ¡  Repeat 2 times. After another iteration this yields [[2, 2], [2, 2]].

Lo mismo pero con una sola mónada y sin necesidad del separador de cadena:

4 bytes

»€`¡

Jalea , 5 bytes

Wẋ³µ¡

Pruébalo en línea!

Explicación

         Implicit input: N
   µ¡    Apply N times to input:
Wẋ³        “N copies of”

Python 3 , 57 53 50 38 bytes

f=lambda n,c=0:n-c and[f(n,c+1)*n]or 1

Pruébalo en línea!

-4 bytes gracias a @CalculatorFeline

34 bytes:

f=lambda c,n:c and[f(c-1,n)*n]or 1

Necesita ser llamado como f(4,4)

Rubí, 28 26 bytes

¡Gracias a Cyoce por guardar 2 bytes!

->n{eval'['*n+'n'+']*n'*n}

Robado descaradamente de la excelente respuesta de xnor .

Rubí, 27 bytes

->a{(z=a).times{z=[z]*a};z}

Solo 1 byte más pero usando un enfoque diferente en lugar del truco 'eval' de la maravillosa respuesta de Python de xnor.

Perl 6 , 25 bytes

{($^n,{$_ xx$n}...*)[$n]}

Comienza con n, y aplica iterativamente los tiempos de transformación "repetir n veces" n, creando cada vez un nivel adicional de Listanidamiento.

Pruébalo en línea!

PHP, 70 62 bytes

Esto es lo más simple que se me ocurre.

for(;$i++<$n=$argv[1];)$F=array_fill(0,$n,$F?:$n);print_r($F);

Toma la entrada como primer argumento e imprime la matriz resultante en la pantalla.

¡Gracias a @ user59178 por salvarme 8 bytes !

Clojure, 36 bytes

#(nth(iterate(fn[a](repeat % a))%)%)

Itera la función que repite sus ntiempos de argumento , produce una secuencia infinita de tales elementos y luego toma su nelemento th.

Véalo en línea

Rebol, 45 bytes

func[n][array/initial append/dup copy[]n n n]

Lote, 141 bytes

@set t=.
@for /l %%i in (2,1,%1)do @call set t=%%t%%,.
@set s=%1
@for /l %%i in (1,1,%1)do @call call set s=[%%%%t:.=%%s%%%%%%]
@echo %s%

Batch en realidad no tiene matrices, por lo que solo imprime la representación de cadena de una matriz. Explicación: Las dos primeras líneas crean un patrón repetido de N .s separado por N-1 ,s en la variable t. La cuarta línea luego usa esto como un patrón de sustitución Nveces para crear la Nmatriz dimensional. El doble calles necesario debido a cómo funcionan las declaraciones fory set. Primero, el forcomando sustituye variables. Como sucede, todos mis %signos se duplican, por lo que esto no hace nada más que ponerlos entre comillas, lo que resulta en call call set s=[%%t:.=%s%%%]. Luego repite los Ntiempos de declaración resultantes . Cada vez, el callcomando sustituye variables. En este punto, la svariable solo tiene un único conjunto de%s, por lo que se sustituye, lo que resulta en (por ejemplo) call set s=[%t:.=[2,2]%]. La llamada interna luego sustituye la tvariable, lo que resulta en (por ejemplo) set s=[[2,2],[2,2]], realizar la asignación deseada. sLuego se imprime el valor final de .

Clojure, 49 bytes

(defmacro r[n]`(->> ~n ~@(repeat n`(repeat ~n))))

No es el ejemplo más corto de Clojure, pero me divertí con las citas y las citas.

I , 7 bytes

Obtuve esto de mi colega, el creador de I.

#Bbhph~

#Bb     la copia #función B ound a ab ncontrar
   hp   h ook el argumento para (la derecha) de la p función ower (repetición)
     h~ h ook el argumento a la izquierda ~(de la totalidad de la función resultante)

Pruébalo en línea!

Lisp común, 128102 95 79 bytes

(defun f(x &optional y)(if(if y(< y 2))x(fill(make-list x)(f x(if y(1- y)x)))))

Pruébalo en línea!