{{ message }}

Instantly share code, notes, and snippets.

# ericnormand/00 Nested lists.md

Created Jan 11, 2021

Nested lists

Write a function that nests the elements of a list one level deeper by repeating that element inside a new list a given number of times.

Examples

```(nest [:a :b :c] 2) ;=> ((:a :a) (:b :b) (:c :c))
(nest [] 10) ;=> ()
(nest [1 2 3 4] 1) ;=> ((1) (2) (3) (4))
(nest [1 2 3] 0) ;=> (()()())```

Thanks to this site for the challenge idea where it is considered Hard in Java.

### NPException commented Jan 11, 2021 • edited

Looks like I ended up with the same thing like most people:

```(defn nest [col n]
(map (partial repeat n) col))```

Here's my solution to the slightly different original problem: https://edabit.com/challenge/5mANMR3X6gEfWephD

```(defn array-multiplier [col]
(map (partial repeat (count col)) col))```

### diavoletto76 commented Jan 11, 2021

```(defn nest [xs n]
(map (partial repeat n) xs))```

### chopmo commented Jan 11, 2021 • edited

```(defn nest [list num]
(map #(repeat num %) list))```

### zackteo commented Jan 12, 2021 • edited

Happy to be able to make my first submission for this :)

```(defn nest [l n]
(map #(repeat n %) l))```

### frndmg commented Jan 12, 2021

well, trying to bring functional to python too (ignore the imports 😉).

disclaimer: not as beautiful as the clojure version

```from itertools import repeat
from functools import reduce, partial

compose = lambda *F: reduce(lambda f, g: lambda x: f(g(x)), F)
nest = lambda xs, n: compose(list, partial(map, compose(list, partial(repeat, times=n))))(xs)```

### sztamas commented Jan 12, 2021

@frndmg I see what you're trying to do :-), but for python I would prefer the more idiomatic:

```def nest(xs, n):
return [[x] * n for x in xs]```

### ndonolli commented Jan 14, 2021

My clojure solution was essentially identical to many solutions posted here already. So for fun, I'll show an ES6 javascript solution:

`const nest = (xs, n) => xs.map(x => new Array(n).fill(x));`

### Toni-zgz commented Jan 17, 2021 • edited

My clojure solution. I know isn't the best but i think is clearer than other solutions for beginners as me.

```(ns nest)
(require '[clojure.test :as test])

(defn nest [vect num-rep]
(let [funcion (fn [elt] (repeat num-rep elt))]
(map funcion vect)))

(test/deftest nest-test
(test/is (= '((:a :a) (:b :b) (:c :c))  (nest [:a :b :c] 2)))
(test/is (= '() (nest [] 10)))
(test/is (= '((1) (2) (3) (4))  (nest [1 2 3 4] 1)))
(test/is (= '(()()()) (nest [1 2 3] 0))))

(test/run-tests 'nest)```

### cristiano-belloni commented Jan 19, 2021

Javascript oneliner for comparison:

`(a, n) => a.map(a => new Array(n).fill(a)) `

### steffan-westcott commented Jan 20, 2021

@Toni-zgz Welcome to Clojure! Since you asked for some suggestions:

• To write formatted Clojure code in Github comments, write ````clojure` as the first line and ````` as the last line. See the Github docs on syntax hightlighting
• `map` on an empty collection will evaluate to an empty sequence. You don't need to explicitly check for an empty input collection in your answer.

### Toni-zgz commented Jan 20, 2021

`(defn nest [ns k] (map (partial repeat k) ns))`