N-dimensional N^N array filled with N

Question

In: Enough memory and a positive integer N

Out: N-dimensional N^N array filled with N, where N^N means N terms of N-by-N-by-N-by...

Examples:

1: [1] which is a 1D array (a list) of length 1, containing a single 1

2: [[2,2],[2,2]] which is a 2D array (a table) with 2 rows and 2 columns, filled with 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]]] which is a 3D array (a cube) with 3 layers, 3 rows, and 3 columns, filled with 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 and 6: Please see one of the answers.

Answer 1

Python, 32 bytes

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

Try it online!

Makes a string like "[[[n]*n]*n]*n" with n multiplcations, and evaluates it as Python code. Since the evaluation happens within the function scope, the variable name n evaluates to the function input.

Answer 2

J, 4 bytes

$~#~

Try it online!

Explanation

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

Answer 3

APL (Dyalog APL), 4 bytes

⍴⍨⍴⊢

Try it online!

Answer 4

Mathematica, 22 20 bytes

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

(* or *)

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

Answer 5

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

Answer 6

Octave, 35 33 25 23 20 bytes

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

Try it online!

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

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

Thanks to @LuisMendo saved 8 bytes

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

Try it online!

Previous answer:

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

Try it online!

Answer 7

R, 26

This is the obvious answer but perhaps there is something cleverer?

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

Answer 8

Haskell, 52 bytes

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

Try it online!

Inspired by @nimi's answer, but using more predefined functions.

• Uses iterate and !! instead of a recursive help function.
• Instead of constructing list delimiters "by hand", uses filter(>'"').show to format a list of strings, then stripping away the extra " characters.

Answer 9

05AB1E (legacy), 6 5 bytes

-1 thanks to Kevin Cruijssen

F¹.D)

Try it online!

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

Answer 10

Haskell, 62 bytes

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

Usage example: f 2 -> "[[2,2],[2,2]]". Try it online!.

Haskell's strict type system prevents a function that returns nested lists of different depths, so I construct the result as a string.

How it works:

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         

Answer 11

Python 2, 36 bytes

-2 bytes thanks to @CalculatorFeline

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

Try it online!

Answer 12

Jelly, 5 bytes

⁾Wẋẋv

Try it online!

How?

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

Answer 13

Jelly, 4 bytes

R»µ¡

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

Same thing but with a single monad and no need for the chain separator:

4 bytes

»€`¡

Answer 14

MATL, 8 bytes

ttY"l$l*

Try it at MATL Online (I have added some code showing the actual size of the output since all n-dimensional outputs in MATL are shown as 2D matrices where all dimensions > 2 are flattened into the second dimension).

Explanation

        % 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  

Answer 15

CJam, 12 bytes

ri:X{aX*}X*p

Try it online!

Explanation

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

Answer 16

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

}

Answer 17

JavaScript (ES6), 38 bytes

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

The memory-hungry version of this is 45 bytes:

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

Answer 18

Batch, 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 doesn't actually have arrays so this just prints the string representation of an array. Explanation: The first two lines build up a repeated pattern of N .s separated by N-1 ,s in the variable t. The fourth line then uses this as a substitution pattern N times to create the N-dimensional array. The double call is necessary because of how the for and set statements work. First, the for command substitutes variables. As it happens, all of my % signs are doubled, so this does nothing except to unquote them all, resulting in call call set s=[%%t:.=%s%%%]. It then repeats the resulting statement N times. Each time, the call command substitutes variables. At this point, the s variable only has a single set of %s, so it gets substituted, resulting in (e.g.) call set s=[%t:.=[2,2]%]. The inner call then substitutes the t variable, resulting in (e.g.) set s=[[2,2],[2,2]], performing the desired assignment. The final value of s is then printed.

Answer 19

Jelly, 5 bytes

Wẋ³µ¡

Try it online!

Explanation

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

Answer 20

Python 3, 57 53 50 38 bytes

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

Try it online!

---

-4 bytes thanks to @CalculatorFeline

---

34 bytes:

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

Needs to be called as f(4,4)

Answer 21

Ruby, 28 26 bytes

Thanks to Cyoce for saving 2 bytes!

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

Stolen shamelessly from xnor's excellent answer.

Answer 22

Ruby, 27 bytes

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

Only 1 byte more but using a different approach instead of the 'eval' trick from xnor's wonderful Python answer.

Answer 23

Bash + GNU utilities, 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] \ []

Try it online!

---

The program essentially counts from 0 to (n^n)-1 in base n, where n is the input. For each base-n number k in the count, it does the following:

1. If k ends with at least one digit 0, print a '[' for each digit 0 at the end of k.
2. Print n.
3. If k ends with at least one digit n-1, print a ']' for each digit n-1 at the end of k.

(The value n=1 needs to have brackets added as a special case. This input value also generates some output to stderr, which can be ignored under standard PPCG rules.)

Maybe there's a shorter way to implement this idea.

---

Sample run:

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

Answer 24

Haskell, 51 bytes

Other than the existing Haskell solutions this constructs a usable data type not just a string representation thereof (and is shorter):

data L=N[L]|E Int
f n=iterate(N.(<$[1..n]))(E n)!!n

Try it online!

Explanation / Ungolfed

The reason why this is an interesting challenge in Haskell is that a solution to this challenge needs to return different deeply nested lists and Haskell (without importing external modules) does not support this. One workaround which turned out to be the golfiest, is to define our own data type:

data NestedList = Nest [NestedList] | Entry Int

Now we can just define a function f :: Int -> NestedList which is able to represent all the required data types:

pow n = iterate (Nest . replicate n) (Entry n) !! n

Answer 25

MathGolf, 5 4 bytes

_{a*

Try it online!

Explanation using n = 2 (note that the outermost [] are not arrays, but are just there to show the stack)

_      duplicate TOS (stack is [2, 2])
 {     loop 2 times (stack is [2])
  a    wrap in array ([2] => [[2]], [[2, 2]] => [[[2, 2]]])
   *   pop a, b : push(a*b) ([[2]] => [[2, 2]], [[[2, 2]]] => [[[2, 2], [2, 2]]])

Answer 26

Raku, 21 bytes

try it online!

{[[xx] [xx] $_ xx 3]}

Answer 27

Julia 0.6, 23 21 bytes

n->n>(n>n)...
> =fill

Try it online!

(Thanks to @MarcMush for -2 bytes.)

In Julia, binary operators are parsed as function calls, so a>b is >(a, b), which here is fill(a, b). So the above is really saying:

n->fill(n,fill(n,n)...)

The first argument to fill is the value to fill the new array with. The following arguments to that are the dimensions of the new array. Here we create those dimensions themselves using another fill call: we create an array of n ns, then splat that with ... so that the first fill call gets n number of dimension arguments, each with value n - so it creates an n-dimensional array where each dimension length is n, and filled with the value n.

Answer 28

Perl 6, 25 bytes

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

Starts with n, and iteratively applies the "repeat n times" transformation n times, each time creating an additional level of List nesting.

Try it online!

Answer 29

PHP, 70 62 bytes

This is the simplest I can come up with.

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

Takes the input as the first argument and prints the resulting array on the screen.

---

Thanks to @user59178 for saving me 8 bytes!

Answer 30

Clojure, 36 bytes

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

Iterates function which repeats its argument n times, it produces infinite sequence of such elements and then takes its nth element.

See it online