Multiply numbers by their depth

Question

Given a ragged list, we can define an element's depth as the number of arrays above it, or the amount that it is nested.

For example, with the list [[1, 2], [3, [4, 5]]] the depth of the 2 is 2, as it is nested within two lists: The base list, and the list [1, 2]. The depth of the 4 is 3 as it is nested within three lists.

Your challenge is to, given a ragged list of positive integers, multiply them by their depths.

For example, given the list [[1, 2], [3, [4, 5]], 6]:

• The depth of 1 is 2, so double it -> 2
• The depth of 2 is also 2, so double it -> 4
• The depth of 3 is 2, so double it -> 6
• The depth of 4 is 3, so triple it -> 12
• The depth of 5 is 3, so triple it -> 15
• The depth of 6 is 1, so leave it alone -> 6

So, the result is [[2, 4], [6, [12, 15]], 6].

Another way of viewing it:

[[1, 2], [3, [4, 5 ]], 6]  - Original list
[[2, 2], [2, [3, 3 ]], 1]  - Depth map
[[2, 4], [6, [12,15]], 6]  - Vectorising product

You can assume the list won't contain empty lists.

This is code-golf, shortest wins!

Testcases

[[1, 2], [3, [4, 5]], 6] => [[2, 4], [6, [12, 15]], 6]
[[3, [2, 4]]] => [[6, [6, 12]]]
[[9, [[39], [4, [59]]]], 20] => [[18, [[156], [16, [295]]]], 20]
[2, [29]] => [2, [58]]
[[[[[[[[9]]]]]]]] => [[[[[[[[72]]]]]]]]

Answer 1

Vyxal, 4 bytes

⁽L€*

Try it Online!

⁽L€*
⁽ €  # At each value in the input, all the way down, run the following on the multi-dimensional index of the current value:
 L   # Length. This gets the current depth
   * # Vectorizically (is that a word?) multiply by the input

Answer 2

Wolfram Language (Mathematica), 12 bytes

#0/@#-#&@-#&

Try it online!

         -# negate
#0/@#  &@   at each level:
     -#       subtract original value(s)
            (atoms: #0/@#-# = #-# = 0)

Answer 3

Python, 51 49 44 43 bytes

f=lambda l,d=0:l*d*-1or[f(s,d-1)for s in l]

Attempt This Online!

This is a really fun abuse of the overloading of the * operator:

• If l is a positive integer, then l*d*-1 equals l*-d, which is always truthy (because the integers are always positive, so non-zero), so it returns l*-d, where d is the negation of the depth.
• If l is an array, then l*d produces d copies of the list joined together, which is actually interpreted as 0 copies of the list joined together (because d is negative), i.e. []. So l*d*-1 equals equals []*-1 equals [], which is falsy, so the second part of the conditional is run.

---

-1 bytes from @loopywalt by flipping the sign of d.

Answer 4

K (ngn/k), 17 bytes

{$[x~*x;0;x+o'x]}

Try it online!

Answer 5

Jelly, 5 bytes

ŒJẈṁ×

Try it online!

ŒJ       All multidimensional indices, in flat order.
  Ẉ      Get the length of each index (= depth of value at index).
   ṁ     Mold to the structure of the input,
    ×    and multiply corresponding elements.

Answer 6

BQN, 9 bytes

{+⟜𝕊⍟=¨𝕩}

Try it here!

-5 bytes thanks to @att!

Explanation

• {...¨𝕩} for each element n over input...
  • ...⍟= if rank of n > 0 (i.e. n is a list)...
    • +⟜𝕊 n + F(n)

Answer 7

JavaScript, 32 bytes

(g=k=>a=>a.map?.(g(-~k))??a*k)()

f =

(g=k=>a=>a.map?.(g(-~k))??a*k)()

testcases = `
[[1, 2], [3, [4, 5]], 6] => [[2, 4], [6, [12, 15]], 6]
[[3, [2, 4]]] => [[6, [6, 12]]]
[[9, [[39], [4, [59]]]], 20] => [[18, [[156], [16, [295]]]], 20]
[2, [29]] => [2, [58]]
[[[[[[[[9]]]]]]]] => [[[[[[[[72]]]]]]]]
`.trim().split('\n').map(l => l.split(' => ').map(t => JSON.parse(t)));
testcases.forEach(([i, e]) => {
  console.log(JSON.stringify(f(i)) === JSON.stringify(e), JSON.stringify(f(i)));
});

The submitted function is partial invoked currying function. Maybe the first time I try to use this pattern in a code-golf.

However, the a.map?.(…)??… pattern is quite common for ragged-list.

Answer 8

Retina 0.8.2, 51 bytes

\d+
$*
1(?=((\[)|(?<-2>])|(])|[^][])+)
$#3$*
1+
$.&

Try it online! Link includes test cases. Explanation:

\d+
$*

Convert to unary.

1(?=((\[)|(?<-2>])|(])|[^][])+)
$#3$*

Replace each 1 with the number of unmatched ]s in the input's suffix, which equals its depth, thereby multiplying each number by its depth.

1+
$.&

Convert to decimal.

Just creating the depth map can be readily achieved with the following code:

\d+(?=((\[)|(?<-2>])|(])|[^][])+)
$#3

Retina 1 can perform multiplication as part of a substitution, solving the original problem as follows:

\d+(?=((\[)|(?<-2>])|(])|[^][])+)
$.($#3**

Try it online! Link includes test cases. Explanation: The ** causes the capture result (the depth) to be implicitly multiplied by the matched integer, converted to unary, and the $.( then converts back to decimal.

Answer 9

PARI/GP, 25 bytes

f(a)=if(#a',a+apply(f,a))

Attempt This Online!

Answer 10

Racket, 88 63 bytes

(define(m l[d 0])(if(list? l)(map(λ(n)(m n(+ 1 d)))l)(* l d)))

Try it online!

-25 from removing whitespace, ty @emanresu A!

Answer 11

lin, 26 bytes

"deps1> (.+ \@ ' + ) e&".'

Try it here! Uses stack as nested list.

For testing purposes (use -i flag when running locally):

[[1 2] [3 [4 5]] 6] \; '
"deps1> (.+ \@ ' + ) e&".'

Explanation

Prettified:

( deps 1> (.+ \@ ' + ) e& ).'

• (...).' map...
  • deps 1> (...) e& if depth > 1 (i.e. is list)...
  • .+ \@ ' + recurse and vector-add to current element

Answer 12

05AB1E, 16 bytes

_"Ddië®δ.V>"©.V*

Try it online or verify all test cases.

Explanation:

First step of this 05AB1E answer of mine.

_            # Transform each integer in the (implicit) input to 0
 "..."       # Push the recursive string explained below
      ©      # Store it in variable `®` (without popping)
       .V    # Evaluate and execute it as 05AB1E code
             # (we now have the depth of each item in the ragged input-list)
         *   # Multiply each by the value in the (implicit) input-list at the same
             # positions
             # (after which the result is output implicitly)

  D          # Duplicate the current list
   dië       # If it's not an integer (so it's a list):
       δ     #  Map over each item:
      ® .V   #   Do a recursive call
          >  #  Then increase each integer in this list by 1

Answer 13

05AB1E, 23 16 15 bytes

.γd}DžuSδ¢ÆηO*J

Try it online!

-2 thanks to @Kevin Cruijssen

Takes the input list as a string, using ( and ).

If a and b are valid list boundaries, then it's -1 for replacing žu with A. Try it online!

Answer 14

Perl 5 -p, 33 bytes

s/\d+/$&*($`=~y|[||-$`=~y|]||)/ge

Try it online!

For each number, depth is determined by counting the number of [ and subtracting the number of ] that come before it in the string.

Answer 15

Ruby, 38 bytes

f=->a,d=0{a*0==0?a*d:a.map{f[_1,d+1]}}

Attempt This Online!

Answer 16

Ruby, 38 bytes

f=->a,i=1{a.map{f[_1,i+1]rescue _1*i}}

Attempt This Online!

An alternative to Razetime's answer for the same byte count.

Answer 17

Knight, 124 118 bytes

;=p++=o""=i=d 0P;W<=i+1iLp;=n=cGp i 1I>c"9";=d-d-1*2<c"]"=o+o cI<"/"c;W&<=tGp+1i 1"["<"/"t;=i+1i=n+n t=o+o*d n=o+o cOo

Try it online!

Nice, big ole fat Knight program. Parses it as a string lol

Ungolfed and commented:

; = p + + = o "" = i = d 0 PROMPT                # p = (o = "") + (i = d = 0) + input()
; W < = i + 1 i LENGTH p                         # while (i = i + 1) < len(p):
  ; = n = c GET p i 1                            #   n = c = p[i]
  : IF > c "9"                                   #   if c > "9":
    ; = d - d - 1 * 2 < c "]"                    #     d = d - (1 - 2 * (c < "["))
    : = o + o c                                  #     o = o + c
  # ELSE                                         #   else:
    : IF < "/" c                                 #     if "/" < c:
      ; WHILE & < = t GET p + 1 i 1 "[" < "/" t  #       while ((t = p[i + 1]) < "[") and ("/" < t):
        ; = i + 1 i                              #         i = i + 1
        : = n + n t                              #         n = n + t
      : = o + o * d n                            #       o = o + d * n
    # ELSE                                       #     else:
      : = o + o c                                #       o = o + c
: OUTPUT o                                       # print(o)

-6 bytes thanks to Adam.

Answer 18

Charcoal, 35 bytes

⊞υ⟦¹θ⟧ＦυＵＭ⊟ι⎇⁺⟦⟧κ∧⊞Ｏυ⟦⊕Σικ⟧κ×Σικ⭆¹θ

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

⊞υ⟦¹θ⟧

Start by considering the input list at depth 1.

Ｆυ

Loop through the list and its sublists.

ＵＭ⊟ι

Loop through the elements of the current list.

⎇⁺⟦⟧κ

If this is a sublist, then...

∧⊞Ｏυ⟦⊕Σικ⟧κ

... push it with the incremented depth to the list of sublists, but don't actually change the list itself yet, otherwise...

×Σικ

... multiply the element by the current depth.

⭆¹θ

Pretty-print the result, since Charcoal's default formatting is not designed for ragged lists.

Answer 19

J, 12 bytes

Takes input as a boxed array.

*L:0#L:1@{::

Attempt This Online!

{:: Map; replaces each leaf by its multidimensional index.
#L:1 At level 1 (for each index vector), take the length.
*L:0 multiply with input at level 0 (leafs).

Answer 20

jq, 31 bytes

def f(n):map(f(n+1))?//.*n;f(0)

Try it online!

The key to the base case: If map() fails (since we try to map over a number instead of an array), ? suppresses the error, // substitutes the alternate value of .*n

Answer 21

brev, 46 bytes

(c(fn(if(list? y)(map(c f(+ x 1))y)(* y x)))0)

Classic lispy depth first tree walking: map if not atom