Nesting list with a value repeated `n` amount of times

Question

Given the input of n and value. The code is supposed to nest the single element list with value repeated n times. The final output should be a multilevel nested list with single repeated values in all sublists.

This is code-golf, so the shortest code in bytes wins!

Test cases:

n = 1, value = 'a': ['a']
n = 2, value = 'a': ['a', ['a']]
n = 3, value = 'a': ['a', ['a', ['a']]]
n = 4, value = 'a': ['a', ['a', ['a', ['a']]]]
n = 5, value = 'a': ['a', ['a', ['a', ['a', ['a']]]]]
n = 6, value = 'a': ['a', ['a', ['a', ['a', ['a', ['a']]]]]]

Answer 1

Python 2, 33 30 bytes

-3 bytes thanks to @xnor

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

Try it online!

Answer 2

05AB1E, 3 bytes

F‚Ù

Try it online.

Explanation:

F     # Loop the first input amount of times:
 ‚    #  Pair the (implicit) second input-value with the current list
  Ù   #  And uniquify it (which only does something in the first iteration,
      #  transforming the pair of values to a single wrapped value)
      # (after the loop, the result is output implicitly)

Answer 3

Vyxal r, 4 bytes

(⁰"U

Try it Online!

The joys of golfing language :)

Explained

(⁰"U
(     # n times:
 ⁰    #   push the value
  "U  #   pair and uniquify - a port of the 05ab1e answer

Answer 4

Python, 34 bytes

f=lambda x,n:n and[x,f(x,n-1)][:n]

Attempt This Online!

Thanks to loopy walt for this one.

---

Old answers:

Python, 36 bytes

f=lambda x,n:[x][n>1:]or[x,f(x,n-1)]

Attempt This Online!

Python, ³⁶ 35 bytes

f=lambda x,n:n*[1]and[[x]+f(x,n-1)]

Attempt This Online!

Outputs as a singleton list, but that feels like cheating here.

Python, 39 bytes

f=lambda x,n:[x]+(~-n*[1]and[f(x,n-1)])

Attempt This Online!

Python, 37 bytes

f=lambda x,n:x+(~-n*[1]and[f(x,n-1)])

Attempt This Online!

Inputs as a singleton list.

Answer 5

Proton, 25 bytes

n=>v=>((a=>[v,a])*n)([v])

Try it online!

n=>v=>((a=>[v,a])*n)([v])    This language is stupid
n=>                          Given n
  v=>                        and v
       (a=>[v,a])            pair v with the current accumulator
                 *n          n times
      (            )([v])    and call that on [v]

Answer 6

Wolfram Mathematica, 30 21 bytes

Print[""@@#~Nest~##]&

-9 bytes from @att!

Try it online!

Sample I/O:

Print[""@@#~Nest~##]&@@{a,3}

[a[a[a]]]

Print[""@@#~Nest~##]&@@{17,3}

[17[17[17]]]

Print[""@@#~Nest~##]&@@{Pi,6}

\$[\pi [\pi [\pi [\pi [\pi [\pi ]]]]]]\$

Answer 7

R, 46 bytes

function(n,v)Reduce(list,rep(v,n-1),list(v),T)

Try it online!

Non-recursive approach. Pretty-printing and test harness taken from Dominic van Essen who insisted I post this as my own.

Answer 8

BQN, 9 bytes

∾⟜⋈´⥊⟜⋈⟜⋈

^{Pins and bowties FTW}

Anonymous tacit function that takes two arguments and returns a nested list. This is why the list formatting looks weird. Run it online!

Explanation

The left argument is the count; the right argument is the value. The example uses a left argument of 2 and a right argument of 0.

∾⟜⋈´⥊⟜⋈⟜⋈
          ⟜⋈  Wrap the right argument in a list: ⟨ 0 ⟩, and then
       ⟜⋈     Wrap that list in a list: ⟨ ⟨ 0 ⟩ ⟩, and then
     ⥊        Reshape to a length equaling the left argument: ⟨ ⟨ 0 ⟩ ⟨ 0 ⟩ ⟩
    ´          Right-fold that list on this function:
 ⟜⋈             Wrap the right argument in a list: ⟨ ⟨ 0 ⟩ ⟩, and then
∾                Concatenate with the left argument: ⟨ 0 ⟩ ∾ ⟨ ⟨ 0 ⟩ ⟩ → ⟨ 0 ⟨ 0 ⟩ ⟩

Answer 9

Husk, 13 bytes

+J',R¹e'[²R']

Try it online!

Not an ideal challenge for a language that doesn't support ragged lists...

+              # join together:
    R¹         #  arg1 repeats of
      e        #   2-element list of
       '[      #    '[' and
         ²     #    arg2,
 J',           #  joined by commas,
               #  and
     R']       #  arg1 repeats of ']'

Answer 10

Jelly, 5 bytes

W{Ɱṭ/

Try it online!

Value on left, \$n\$ on right

W        The value wrapped in a singleton list
 {Ɱ      for each 1..n.
   ṭ/    Reduce by Funky Reverse Append™.

Answer 11

Ruby, 29 23 bytes

->n,a{eval'[a,'*n+?]*n}

Try it online!

Stole the eval trick from dingledooper

Answer 12

R, 49 bytes

f=function(n,v)`if`(n-1,list(v,f(n-1,v)),list(v))

Try it online!

Answer 13

Racket, 49 bytes

(define(f x n)(if(= n 1)`(,x)`(,x,(f x(- n 1)))))

Try it online!

Answer 14

Wolfram Language (Mathematica), 24 bytes

t&@Do[t={#,t},Set@t;#2]&

Try it online!

Input [n, value].

Answer 15

Wolfram Language (Mathematica), 24 bytes

0-indexed

Fold[List,{#},Table@##]&

Try it online!

Answer 16

MathGolf, 5 bytes

a*Åαç

Outputs reversed (e.g. [[["a"],"a"],"a"] instead of ["a",["a",["a"]]]), which is allowed based on the comments under the challenge.

Try it online.

Explanation:

a      # Wrap the (implicit) input-string into a list
       #  e.g. "abc" → ["abc"]
 *     # Repeat it the (implicit) input-integer amount of times
       #  e.g. 5 → ["abc","abc","abc","abc","abc"]
  Å    # For-each over these strings,
       # using the following 2 characters as inner code-block:
   α   #  Wrap the top two values into a list
       #  (which will wrap with the implicit loop-index 0 in the first iteration)
       #   e.g. [0,"abc"] in the first iteration
       #        [["abc"],"abc"] in the second iteration
       #        [[["abc"],"abc"],"abc"] in the third, etc.
    ç  #  Remove all 0s from the list with a falsey filter
       #  (only relevant for the first iteration: [0,"abc"] → ["abc"])
       # (after the loop, the entire stack is output implicitly as result)

Answer 17

HBL, 11 bytes

1,(?(-.)(1('?(-.),)?)?

Try it!

Explanation

A recursive function:

1,(?(-.)(1('?(-.),)?)?
1                       Cons
 ,                      the second argument with:
  (?(-.)                 If the first argument decremented is truthy (> 1):
        (1          )     Cons
          ('?     )        Recursive call with
             (-.)           First argument decremented
                 ,          Second argument unchanged
                   ?      with nil (empty list)
                         Else (the first argument is 1):
                     ?    Nil (empty list)

I.e., if the first argument is 1, we get (cons arg2 nil), which simply creates a singleton list containing the second argument; and if the first argument is greater than 1, we get (cons arg2 (cons [recursive-call] nil)), which wraps the result of the recursive call in a singleton list and then prepends the second argument to it.

Answer 18

APL+WIN, 28 bytes

Prompts for n followed by value

(¯1↓∊n⍴⊂'[',⎕,','),(n←⎕)⍴']'

Try it online! Thanks to Dyalog Classic

Answer 19

PHP, 56 55 bytes

function($n,$a){for($r=[$a];--$n;)$r=[$a,$r];return$r;}

Try it online!

Like often, PHP makes the worst score, akin only to C, but dirtier and with lots of $

EDIT: -1 byte, these dollars allow us some trickery with the parser after all

Answer 20

PHP 50 bytes

function f($c,$n){return --$n?[$c,f($c,$n)]:[$c];}

Try it online!

Answer 21

PowerShell Core, 41 bytes

$n,$a=$args
1..$n|%{$r=$a,@($r)|?{$_}}
$r

Try it online!

Please note that this does not work for n = 1, for some reason PowerShell treats it as a string. Even when forcing to return an array.

Let me know if not OK and I'll withdraw this answer!

Answer 22

Pari/GP, 29 bytes

f(a,n)=if(n--,[a,f(a,n)],[a])

Try it online!

Answer 23

Charcoal, 15 bytes

ＦＮ≔⟦⁺⟦η⟧υ⟧υ⭆¹⊟υ

Try it online! Link is to verbose version of code. Explanation:

ＦＮ

Repeat n times...

≔⟦⁺⟦η⟧υ⟧υ

... prepend value to the initially predefined empty list, then wrap that in another list.

⭆¹⊟υ

Unwrap the very last wrapper list and pretty-print it.

Answer 24

Pip -p, 14 13 bytes

-1 byte by porting Neil's Charcoal answer

Lal:[lPEb]l@0

Try it online!

Explanation

Lal:[lPEb]l@0
               l is empty list; a,b are command-line args
La             Loop a times:
        b       b
      PE        Prepended to
     l          Current list
    [    ]      Wrap that result in a singleton list
  l:            Assign back to l
          l    After the loop, l is our desired result wrapped in a singleton list
           @0  So get the first element
               and autoprint it, formatted as a list (-p flag)

Answer 25

JavaScript (ES6), 24 bytes

-2 thanks to @tsh

n=>g=x=>--x?[n,g(x)]:[n]

Answer 26

JavaScript (ES6), 27 bytes

f=(c,n)=>--n?[c,f(c,n)]:[c]

Try it out online.

Answer 27

Lua, 50 bytes

n,v=...t={v}for i=2,n do t={v,t}n=n-1 end return t

Try it online!

Answer 28

Retina, 31 bytes

L$`¶
$`*$([$', )$`*]
, (]+)$
$1

Try it online! Takes n and value on separate lines. Explanation:

L$`¶

Match the newline between n and value. This puts n in $` and value in $'.

$`*$([$', )$`*]

Wrap value in n lists.

, (]+)$
$1

Remove the trailing comma in the innermost list.

Answer 29

C (clang), 56 bytes

i;f(*x,n){for(i=~n;++i<n;)printf(i<0?",[%s"-i/n:"]",x);}

Try it online!

Takes a string literal as value and n , prints to std out the result.

for(i=~n;++i<n;)      - iterate from -n to n

printf(i<0?  - select format string:
",[%s"-i/n..x)  * new nest, -i/n to skip comma at first stage
:"]"            * close nest
```

Answer 30

Python, 38 bytes:

f=lambda n,v:[v,f(n-1,v)]if n>1else[v]

Try It Online!