In:  Memória suficiente e um número inteiro positivo N

Fora:  N-dimensional N ^ N matriz preenchida com N, onde N ^ N significa N termos de N-por-N-por-N-por ...

Exemplos:

1: [1]que é uma matriz 1D (uma lista) de comprimento 1, contendo um único 1

2: [[2,2],[2,2]]que é uma matriz 2D (uma tabela) com 2 linhas e 2 colunas, preenchida com 2s

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 é uma matriz 3D (um cubo) com 3 camadas, 3 linhas e 3 colunas, preenchidas com 3s

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 e 6: Veja uma das respostas.

Python , 32 bytes

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

Experimente online!

Cria uma string como "[[[n]*n]*n]*n"com nmultiplicações e avalia como código Python. Como a avaliação ocorre no escopo da função, o nome da variável é navaliado na entrada da função.

J, 4 bytes

$~#~

Experimente online!

Explicação

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

APL (Dyalog APL) , 4 bytes

⍴⍨⍴⊢

Experimente online!

Mathematica, 22 20 bytes

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

(* or *)

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

R, 26

Esta é a resposta óbvia, mas talvez haja algo mais 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

Demo

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

Experimente online!

Inspirado na resposta de @ nimi , mas usando funções mais predefinidas.

• Usa iteratee, em !!vez de uma função de ajuda recursiva.
• Em vez de construir delimitadores de lista "à mão", usa filter(>'"').showpara formatar uma lista de seqüências de caracteres e, em seguida, retira os "caracteres extras .

05AB1E (herdado) , 6 5 bytes

-1 graças a Kevin Cruijssen

F¹.D)

Experimente online!

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

Oitava, 35 33 25 23 20 bytes

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

Experimente online!

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

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

Graças a @LuisMendo salvou 8 bytes

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

Experimente online!

Resposta anterior:

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

Experimente online!

Haskell, 62 bytes

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

Exemplo de uso: f 2-> "[[2,2],[2,2]]". Experimente online! .

O sistema de tipo estrito de Haskell evita uma função que retorna listas aninhadas de diferentes profundidades; portanto, construo o resultado como uma string.

Como 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*

Experimente no MATL Online (adicionei algum código que mostra o tamanho real da saída, pois todas as saídas n-dimensionais no MATL são mostradas como matrizes 2D, onde todas as dimensões> 2 são achatadas na segunda dimensão).

Explicação

        % 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 graças a @CalculatorFeline

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

Experimente online!

CJam , 12 bytes

ri:X{aX*}X*p

Experimente online!

Explicação

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

Gelatina , 5 bytes

⁾Wẋẋv

Experimente online!

Quão?

⁾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;}

Ungolfed:

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

A versão que requer muita memória é de 45 bytes:

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

Utilitários Bash + 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] \ []

Experimente online!

O programa conta essencialmente de 0 a (n ^ n) -1 na base n, onde n é a entrada. Para cada número de base n na contagem, ele faz o seguinte:

1. Se k terminar com pelo menos um dígito 0, imprima um '[' para cada dígito 0 no final de k.
2. Imprimir n.
3. Se k terminar com pelo menos um dígito n-1, imprima um ']' para cada dígito n-1 no final de k.

(O valor n = 1 precisa ter colchetes adicionados como um caso especial. Esse valor de entrada também gera alguma saída para o stderr, que pode ser ignorada pelas regras padrão do PPCG.)

Talvez haja uma maneira mais curta de implementar essa ideia.

Exemplo de execução:

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

Gelatina , 4 bytes

R»µ¡

Experimente online!

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

A mesma coisa, mas com uma única mônada e sem a necessidade do separador de correntes:

4 bytes

»€`¡

Gelatina , 5 bytes

Wẋ³µ¡

Experimente online!

Explicação

         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

Experimente online!

-4 bytes graças a @CalculatorFeline

34 bytes:

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

Precisa ser chamado como f(4,4)

Ruby, 28 26 bytes

Agradecimentos a Cyoce por economizar 2 bytes!

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

Roubado descaradamente a partir xnor 's excelente resposta .

Ruby, 27 bytes

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

Apenas 1 byte a mais, mas usando uma abordagem diferente em vez do truque 'eval' da maravilhosa resposta Python do xnor.

Perl 6 , 25 bytes

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

Inicia ne aplica iterativamente os tempos de transformação "repetir n vezes" n, sempre criando um nível adicional de Listaninhamento.

Experimente online!

PHP, 70 62 bytes

Este é o mais simples que eu posso apresentar.

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

Pega a entrada como o primeiro argumento e imprime a matriz resultante na tela.

Obrigado a @ user59178 por me salvar 8 bytes !

Clojure, 36 bytes

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

Repete a função que repete seus ntempos de argumento , produz uma sequência infinita de tais elementos e, em seguida, pega seu nth elemento.

Veja on-line

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%

O lote não possui matrizes, portanto, isso apenas imprime a representação de sequência de uma matriz. Explicação: As duas primeiras linhas constroem um padrão repetido de N .s separado por N-1 ,s na variável t. A quarta linha usa isso como um padrão de substituição Nvezes para criar a Nmatriz -dimensional. O duplo callé necessário por causa de como as instruções fore setfuncionam. Primeiro, o forcomando substitui variáveis. Por acaso, todos os meus %sinais são duplicados, então isso não faz nada, exceto para citar todos eles, resultando em call call set s=[%%t:.=%s%%%]. Em seguida, repete os Ntempos de instrução resultantes . Cada vez, o callcomando substitui variáveis. Nesse ponto, a svariável possui apenas um único conjunto de%s, para que seja substituído, resultando em (por exemplo) call set s=[%t:.=[2,2]%]. A chamada interna substitui a tvariável, resultando em (por exemplo) set s=[[2,2],[2,2]], executando a atribuição desejada. O valor final de sé então impresso.

Clojure, 49 bytes

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

Não é o exemplo mais curto de Clojure, mas me diverti com as citações e as citações.

I , 7 bytes

Eu recebi isso do meu colega, o criador de I.

#Bbhph~

#Bb     a cópia #função B ound para b inding
   hp   h ook o argumento de (a direita) da p função ower (repetição)
     h~ h ook o argumento para a esquerda ~(de toda a função resultante)

Experimente online!

Lisp comum, 128 102 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)))))

Experimente online!