Dans:  assez de mémoire et un entier positif N

Out:  tableau N ^ N N-dimensionnel rempli de N, où N ^ N signifie N termes de N-by-N-by-N-by ...

Exemples:

1: [1]qui est un tableau 1D (une liste) de longueur 1, contenant un seul 1

2: [[2,2],[2,2]]qui est un tableau 2D (une table) à 2 lignes et 2 colonnes, rempli 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]]]qui est un tableau 3D (un cube) avec 3 couches, 3 lignes et 3 colonnes, rempli avec 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 et 6: S'il vous plaît voir l'une des réponses.

Python , 32 octets

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

Essayez-le en ligne!

Crée une chaîne comme "[[[n]*n]*n]*n"avec nmultiplcations et l'évalue en tant que code Python. Étant donné que l'évaluation se produit dans l'étendue de la fonction, le nom de la variable correspond nà l'entrée de la fonction.

J, 4 octets

$~#~

Essayez-le en ligne!

Explication

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

APL (Dyalog APL) , 4 octets

⍴⍨⍴⊢

Essayez-le en ligne!

Mathematica, 22 à 20 octets

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

(* or *)

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

R, 26

C'est la réponse évidente, mais peut-être qu'il y a quelque chose d'intelligent?

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

JavaScript (ES6),  44  40 octets

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

Démo

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 octets

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

Essayez-le en ligne!

Inspiré par la réponse de @ nimi , mais utilisant davantage de fonctions prédéfinies.

• Utilise iterateet à la !!place d'une fonction d'aide récursive.
• Au lieu de construire des délimiteurs de liste "à la main", utilise filter(>'"').showpour formater une liste de chaînes, puis supprimer les "caractères supplémentaires .

05AB1E (ancien) , 6 5 octets

-1 merci à Kevin Cruijssen

F¹.D)

Essayez-le en ligne!

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

Octave, 35 33 25 23 20 octets

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

Essayez-le en ligne!

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

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

Merci à @LuisMendo d'économiser 8 octets

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

Essayez-le en ligne!

Réponse précédente:

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

Essayez-le en ligne!

Haskell, 62 octets

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

Exemple d'utilisation: f 2-> "[[2,2],[2,2]]". Essayez-le en ligne! .

Le système de types strict de Haskell empêche une fonction de retourner des listes imbriquées de profondeurs différentes. Je construis donc le résultat sous forme de chaîne.

Comment ça fonctionne:

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 octets

ttY"l$l*

Essayez-le sur MATL Online (j'ai ajouté un code indiquant la taille réelle de la sortie, car toutes les sorties à n dimensions en MATL sont affichées sous forme de matrices 2D où toutes les dimensions> 2 sont aplaties dans la deuxième dimension).

Explication

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

-2 octets grâce à @CalculatorFeline

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

Essayez-le en ligne!

CJam , 12 octets

ri:X{aX*}X*p

Essayez-le en ligne!

Explication

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

Gelée , 5 octets

⁾Wẋẋv

Essayez-le en ligne!

Comment?

⁾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 octets

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 octets

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

La version gourmande en mémoire de cela est 45 octets:

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

Utilitaires Bash + GNU, 117 octets

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

Essayez-le en ligne!

Le programme compte essentiellement de 0 à (n ^ n) -1 en base n, où n est l’entrée. Pour chaque nombre n base k dans le décompte, il effectue les opérations suivantes:

1. Si k se termine par au moins un chiffre 0, insérez un '[' pour chaque chiffre 0 à la fin de k.
2. Imprimer n.
3. Si k se termine par au moins un chiffre n-1, insérez un ']' pour chaque chiffre n-1 à la fin de k.

(La valeur n = 1 nécessite l'ajout de crochets en guise de cas spécial. Cette valeur d'entrée génère également une sortie vers stderr, qui peut être ignorée selon les règles PPCG standard.)

Peut-être y a-t-il un moyen plus court de mettre en œuvre cette idée.

Échantillon échantillon:

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

Gelée , 4 octets

R»µ¡

Essayez-le en ligne!

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

Même chose mais avec une seule monade et pas besoin de séparateur de chaîne:

4 octets

»€`¡

Gelée , 5 octets

Wẋ³µ¡

Essayez-le en ligne!

Explication

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

Python 3 , 57 53 50 38 octets

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

Essayez-le en ligne!

-4 octets grâce à @CalculatorFeline

34 octets:

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

Doit être appelé comme f(4,4)

Ruby, 28 26 octets

Merci à Cyoce d' avoir économisé 2 octets!

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

Volé sans vergogne de l' excellente réponse de xnor .

Ruby, 27 octets

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

Un octet de plus mais en utilisant une approche différente au lieu de l'astuce 'eval' de la merveilleuse réponse Python de xnor.

Perl 6 , 25 octets

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

Commence par n, et applique de manière itérative les temps de transformation "répéter n fois" en ncréant chaque fois un niveau supplémentaire d' Listimbrication.

Essayez-le en ligne!

PHP, 70 62 octets

C'est le plus simple que je puisse trouver.

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

Prend l'entrée en tant que premier argument et affiche le tableau résultant à l'écran.

Merci à @ user59178 de m'avoir économisé 8 octets !

Clojure, 36 octets

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

Itère une fonction qui répète ses ntemps d' argument , elle produit une séquence infinie de tels éléments et prend ensuite son nélément th.

Voir en ligne

Rebol, 45 octets

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

Lot, 141 octets

@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 n'a pas réellement de tableaux, donc ceci affiche simplement la représentation sous forme de chaîne d'un tableau. Explanation: Les deux premières lignes constituent un motif répété de N .s séparé par N-1 ,s dans la variable t. La quatrième ligne utilise ensuite ce paramètre comme modèle de substitution Npour créer le Ntableau à deux dimensions. Le double callest nécessaire en raison de la façon dont les déclarations foret setfonctionnent. Tout d'abord, la forcommande substitue des variables. En fait, tous mes %signes sont doublés, cela ne fait donc que les annuler tous, ce qui entraîne call call set s=[%%t:.=%s%%%]. Il répète ensuite les Ntemps de relevé résultants . A chaque fois, la callcommande substitue des variables. À ce stade, la svariable ne possède qu'un seul ensemble de%s, donc il est substitué, résultant en (par exemple) call set s=[%t:.=[2,2]%]. L'appel interne substitue ensuite la tvariable, ce qui a pour résultat (par exemple) l' set s=[[2,2],[2,2]]exécution de l'affectation souhaitée. La valeur finale de sest ensuite imprimée.

Clojure, 49 octets

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

Le plus court exemple de Clojure, mais je me suis amusé à citer et à ne pas citer.

I , 7 octets

Je l'ai reçu de mon collègue, le créateur de I.

#Bbhph~

#Bb     la copie #fonction B ound à sur b rouver
   hp   h ook l'argument (droite) de la p de la fonction de tournesol (répétition)
     h~ h ook l'argument à la gauche ~(sur la totalité de la fonction résultante)

Essayez-le en ligne!

Common Lisp, 128 102 95 79 octets

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

Essayez-le en ligne!