Tableau N ^ N N-dimensionnel rempli de N

62

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.

code-golf array-manipulation integer generation data-structures Adam
la source
Si notre langue ne prend pas en charge les tableaux, quel serait un format de sortie acceptable?
Okx le
17
Comme "Assez mémoire" fait partie de l'entrée, je souhaite voir une réponse qui commande à un robot de prendre la mémoire en entrée et de la brancher avant de l'utiliser.
user2357112
1
Est-ce que tous les tableaux doivent être des objets distincts?
Neil
1
@ user2357112 Je pense qu'il s'agit davantage d'un problème de type de condition préalable. Je doute que l'op attend réellement que la fonction accepte la mémoire en tant qu'entrée.
Le grand canard
2
@TheGreatDuck Correct, mais je suis presque sûr que user2357112 l'a voulu dire comme une blague.
Adám

Réponses:

50

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.

Xnor
la source
3
l'astuce de portée est géniale
Griffin
+1, cette astuce eval fait perdre beaucoup d'octets
MilkyWay90
31

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
milles
la source
6
Quand j'ai vu le titre du challenge, j'ai tout de suite pensé à J. Assez cool que J bat même Jelly (le langage du golf inspiré par J).
Dane
1
Il y a aussi $~$~ce qui est équivalent en se répétant également
miles
2
$~$~traduit en anglais ... ARGENT, gagnez plus, ARGENT, gagnez plus ...
Urne Magique Octopus
12

Mathematica, 22 à 20 octets

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

(* or *)

Table@@Table[#,#+1]&
JungHwan Min
la source
9

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))
Flet
la source
est scan()nécessaire?
Adám
En regardant les autres réponses, il semble que cela doit être soit une fonction, soit accepter une entrée?
Flounderer
1
Oui, je ne sais pas du tout R. Je pensais juste que vous pourriez spécifier une fonction d'une manière ou d'une autre.
Adám
Oui, vous pouvez remplacer n=scan();par function(n)mais cela le rend plus long.
Flounderer
5
Vous pouvez enregistrer un octet en mettant l' naffectation à l' intérieur de array: array(n<-scan(),rep(n,n)).
rturnbull
8

JavaScript (ES6),  44  40 octets

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

Démo

Afficher l'extrait de code

Arnauld
la source
8

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 .
Ørjan Johansen
la source
8

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
Riley
la source
L'interligne Dpeut être supprimé car l'entrée est utilisée de manière implicite (vous ne savez pas s'il s'agissait de quelque chose lorsque vous avez posté la réponse, mais vous n'avez plus besoin de l'explicite Dmaintenant).
Kevin Cruijssen le
1
@KevinCruijssen Je pense que c'est l'une des réponses qui nous a donné l'idée de prendre implicitement plusieurs entrées :)
Riley
Ah ok. Je m'attendais en effet à ce que cela ne soit pas encore implicite au moment de la publication, mais je me suis rendu compte qu'après avoir posté mon commentaire (que j'ai édité). ;) Parfois, il est drôle de voir combien de choses explicites sont faites avec une ancienne réponse (généralement avant 2017), et combien cela peut être plus court maintenant.
Kevin Cruijssen le
7

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!

rahnema1
la source
@LuisMendo Rats, j'allais juste poster celui-là;)
bécher le
@beaker Whoops :-)
Luis Mendo Le
7

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
nimi
la source
Nous pouvons faire la même idée plus courte avec des fonctions plus builtin: f n=iterate(filter(>'#').show.(<$[1..n]))(show n)!!n.
Ørjan Johansen
@ ØrjanJohansen: c'est une excellente idée. S'il vous plaît poster comme une réponse séparée.
nimi
Pourriez-vous vous raser un octet avec (#0)=show? Pas très familier avec Haskell
Cyoce
@Cyoce: Non, c'est une erreur de syntaxe. Pour une syntaxe correcte, je pourrais retourner les arguments et les utiliser (#)0=show, mais toutes les définitions d'une fonction doivent avoir le même nombre d'arguments. La deuxième ligne ( n#l='['...) a besoin de deux arguments, la première ligne doit également avoir deux arguments.
nimi
6

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
Suever
la source
Je ne peux pas vraiment dire de MATL Online si votre soumission fait la bonne chose. ressemble à chaque réponse est une matrice large.
Adám
4
@ Adám Les dimensions au-delà de la seconde sont affichées comme étant réduites à la seconde. Ainsi, l'exemple montre un tableau 3x9 au lieu du tableau 3x3x3 produit. Si vous ajoutez Zyà la fin du code, cela indique la taille réelle
Luis Mendo Le
6

Python 2 , 36 octets

-2 octets grâce à @CalculatorFeline

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

Essayez-le en ligne!

Trelzevir
la source
~-n== (n-1).
CalculatriceFeline
Serait-il possible d'inclure un lien TIO ?
Adám
1
En fait, ça! (-8 octets en raison de l'algorithme optimisé, +9 octets pour ajouter une sortie)
CalculatorFeline le
@CalculatorFeline Vous pouvez insérer des éléments dans l'en-tête et le pied de page pour éviter toute inclusion dans le nombre d'octets.
Adám
1
Les entrées et sorties ne sont-elles pas requises dans les soumissions complètes du programme?
CalculatriceFeline
5

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
Chat d'affaires
la source
5

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]]]
Jonathan Allan
la source
Deuxième réponse de gelée de 5 octets. Encore trop long comparé à J :-)
Adám
2
... et pas faute d'essayer: D
Jonathan Allan
5

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

}
anacron
la source
1
pouvez-vous remplacer i<=1par i<2?
cliffroot
Oui @ Cliffrott. Ça a marché. Merci!!
Anacron
1
Vous pouvez économiser quelques octets avec un lambda:(n,i)->{...}
Java 8 lambdas ftw
1
Hmm, on dirait que cela prend une entrée supplémentaire. Vous devrez créer une méthode distincte d'un seul paramètre pour que cela soit valide.
Jakob
5

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
Neil
la source
5

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]]]
Mitchell Spector
la source
5

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

»€`¡
Dylnan
la source
4

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)

ovs
la source
Pourquoi vos lignes de code sont-elles inversées par rapport à votre lien TIO?
Adám
Vous pouvez remplacer c>1par c pour sauvegarder 1 octet. (Markdown, arrêtez de dédupliquer des espaces sur `s)
CalculatriceFeline
@CalculatorFeline Je ne pense pas qu'il puisse le faire. ce serait c>0dans ce cas particulier.
Erik l'Outgolfer
Puis changez la fin en <space>n. Problème résolu et bonus - plus d'octets enregistrés! : D (Donc, les espaces à la fin du code en ligne est possible, mais pas le début? C'est étrange ...) TIO link
CalculatorFeline
@ Adám: Sur TIO pour permettre à la fonction principale d'être attribuée dans l'en-tête et ici pour garder la fonction principale sur la dernière ligne.
CalculatriceFeline
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 .

adrianmp
la source
1
Avez-vous besoin de ces parens?
Cyoce
4

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.

GB
la source
3

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!

smls
la source
Utilisez $_plutôt pour enregistrer un octet
Jo King
@JoKing: J'utilise déjà $_comme paramètre du bloc interne, je ne peux donc pas l'utiliser également comme paramètre du bloc externe.
smls
Oui, mais $net $_toujours avoir la même valeur. Essayez-le en ligne!
Jo King
3

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 !

Ismael Miguel
la source
La pré-affectation de telles variables est inutile en l'état $l. Déposer le $i=0,& remplacer $lpar $n enregistre 7 octets. Un octet supplémentaire peut être sauvegardé en n'assignant pas $F, en assignant $ndans le conditionnel et en utilisant un ternaire $F?:$ndans learray_fill()
user59178
@ user59178 Je ne sais pas si c'est ce que vous aviez à l'esprit ou non, mais merci pour les conseils. Vous m'avez sauvé 8 octets!
Ismael Miguel
3

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

cliffroot
la source
3

Rebol, 45 octets

func[n][array/initial append/dup copy[]n n n]
draegtun
la source
3

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.

Neil
la source
+1 Wow, je ne m'y attendais pas. Tous saluent l'humble fichier .bat!
Adám
3

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.

MattPutnam
la source
3

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!

Adam
la source
3

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!

plafondcat
la source