# Sum the array times n, except the last

I've been posting relatively hard challenges recently, so here goes an easy one.

Given an array $$\A\$$ and a number $$\n\$$, calculate the sum of all numbers of $$\A\$$ multiplied by $$\n\$$, except the last one. All numbers (the elements of $$\A\$$ and the value of $$\n\$$) are positive integers, and $$\A\$$ is non-empty. Shortest code in bytes wins.

I have a 3-byte J solution. Can you find it (or beat it in a different language)?

## Test cases

A           N   Ans   Explanation
3 1 4 1 5   10  95    (3+1+4+1)*10+5
3 1 4 1 5   1   14    (3+1+4+1)*1+5
1           999 1     1
• Can we take the list in reverse?
– user92069
Commented Jul 11, 2020 at 8:20
• @Third-party'Chef' No. Commented Jul 11, 2020 at 8:26
• I wonder if your J solution used mixed base conversion
– xnor
Commented Jul 11, 2020 at 9:37
• Can we take the input as numbers instead of a single array? Commented Jul 11, 2020 at 9:54
• @HighlyRadioactive Yes, that's fine. Commented Jul 11, 2020 at 12:19

# J, 3 bytes

That was fun to find.

&+/

Try it online!

### How it works

10 (&+/) 3 1 4 1 5 will bind 10 as an argument of + as 10&+, one verb that gets inserted between the elements of the list by /. So we have: 3 (10&+) 1 (10&+) 4 (10&+) 1 (10&+) 5. Now x n&v y means that y gets applied to n&v for x times. With J's right to left evaluation we get: to 5 add 1 times 10, add 4 times 10, add 1 times 10, add 3 times 10. A challenge made for J's stranger parts. :-) And because + is commutative, +&/ would also be a valid solution.

• Perfect, you nailed it! Commented Jul 11, 2020 at 12:17

# JavaScript (ES6),  28  23 bytes

Saved 3 bytes thanks to @Mukundan314

Expects (A)(n).

A=>n=>eval(A.join*n+)

Try it online!

### How?

We simply join the input array with "*n+", so that [1,2,3] is turned into "1*n+2*n+3" and evaluate the resulting string.

• I'm simultaneously amazed and disgusted. Good work!
– Jhal
Commented Jul 11, 2020 at 22:02

foldr1.((+).).(*)

Try it online!

It turns out this this was close to a port of the intended J solution. The pointfree function ((+).).(*) takes the argument n to the map \a b->a*n+b, that is, to add n times the left value to the right value. This creates the same "verb" as J used, and the foldr1 does the same a J's automatic right to left evaluation. It starts with the rightmost value in the list, which never gets multiplied by n, and applies it right-to-left, effectively increasing the sum so far with n times to the new element.

# Python 3, 27 bytes

lambda a,n:a.pop()+sum(a)*n

Port of my Japt solution to python

Try it online!

• Snap! Just wrote the exact same code without looking at any answers! Commented Jul 11, 2020 at 10:31
• +1 for 2 min earlier Commented Jul 11, 2020 at 11:29

# Wolfram Language (Mathematica), 19 bytes

#2Tr@Most@#+Last@#&

Try it online!

# Python 3, 27 bytes

lambda a,n:a.pop()+sum(a)*n

Try it online!

# APL (Dyalog Unicode), 5 bytes

+⍣⎕/⎕

Try it online!

A full program, which pretty much works like the 3-byte J solution. Takes two lines of input, $$\A\$$ first and $$\n\$$ second.

### How it works

+⍣⎕/⎕
⎕  ⍝ Take the input A
/   ⍝ Reduce by...
+      ⍝   Add the left argument
⍣⎕    ⍝   n times

For n=10 and A = 3 1 4 1 5, this becomes:
+⍣10/3 1 4 1 5
3 (+⍣10) 1 (+⍣10) 4 (+⍣10) 1 (+⍣10) 5
5

# APL (Dyalog Extended), 8 bytes

1¨⍛,⊥0,⊣

Try it online!

A longer but more interesting one. A tacit dyadic function that takes $$\A\$$ on its left and $$\n\$$ on the right.

Uses mixed base conversion , which does the following:

Base:        1  1  1  ... 1    n
Digit value: n  n  n  ... n    1
Array value: 0  a1 a2 ... ax-1 ax
Total: a1n + a2n + ... + ax-1n + ax

### How the code works

1¨⍛,⊥0,⊣  ⍝ Input: left=A, right=n
1¨        ⍝ An array of ones as long as A
⍛,      ⍝ Append n, which becomes the base
0,⊣  ⍝ A prepended with single zero, which becomes the values
⊥     ⍝ Mixed base conversion as described above
• Another interesting method could be (⎕⊥,)/⎕, but I don't think you can get rid of the brackets
– Jo King
Commented Jul 16, 2020 at 1:25

## Clojure 41 bytes

#(+(last %1)(* %2(apply +(butlast %1))))

Unfortunately, + does have to be applyed.

Try It Online

• Welcome to the community! Why not add a Try-It-Online link for your code so users can try it out :)
– mkst
Commented Jul 14, 2020 at 8:45
• You can save 2 bytes by writing just % instead of %1, it is always recognized as the first argument, even when there are more. Commented Jul 15, 2020 at 12:42
• And another one by swapping the order of operands: tio.run/… Commented Jul 15, 2020 at 12:49

# 05AB1E, 5 bytes

-2 bytes thanks to @KevinCruijssen.

*²÷O

Try it online!

## Explanation

*     Multiply list by second operand
Dump
÷  Divide the last item by
²   the second operand
O Sum the stack

# 05AB1E, 7 bytes

„²*ý.VO

Try it online!

## Explanation

„       2-char string
²*     (Which does when evaluated) Multiply by the second input
ý    Join the input list by this
.V  Evaluate
O Sum the resulting stack
• Commented Jul 13, 2020 at 7:05

# APL (Dyalog Extended), 9 bytes (SBCS)

Anonymous tacit infix function. Takes $$\A\$$ as left argument and $$\n\$$ as right argument.

⊢/+.×+×∘~

Try it online!

×∘~$$\A×(1-n)\$$

+.×+$$\\big(\sum_{i=1}^N A_i×n\big)+\$$

⊢/ rightmost element (lit. right-argument reduction)

So this effectively implements: $$\Bigg(\bigg(\sum_{i=1}^N A_i×n\bigg)+A×(1-n)\Bigg)_N\\ \bigg(\sum_{i=1}^N A_i×n\bigg)+A_N×(1-n)\\ \bigg(\sum_{i=1}^N A_i×n\bigg)+A_N-n×A_N\\ \bigg(\sum_{i=1}^{N-1} A_i×n\bigg)+A_N$$

• @Bubbler Ugh, thanks, that'll be much harder to explain. Also, it isn't really related to my solution at all. You should self-answer with that, I guess.
Commented Jul 13, 2020 at 7:55

# R, 3736 35 bytes

-2 bytes with help from Giuseppe

function(l,n)rev(l)%*%n^(seq(!l)>1)

Try it online!

Reverse the vector, and perform dot product with the vector $$\(n^0, n^1, n^1, \ldots,n^1) = (1, n, n,\ldots, n)\$$.

I just discovered this behaviour of seq, which gains 1 byte on item 4 of this tip: seq(!l) is equivalent to seq(along.with = l) (giving the vector 1 2 3 ... length(l)) in all situations, even if l is of length 1. That is because !l is a logical, not an integer, and so we avoid the call to seq.int when l is a (length 1) integer.

• If the list were guaranteed to be at least length 2, this would be a byte shorter, but as it is, it's longer by one instead. Commented Jul 13, 2020 at 18:09
• @Giuseppe Good old seq_along! I parlayed it into a 36-byter. Thanks! Commented Jul 14, 2020 at 8:36
• @Giuseppe seq(!l) works and is equivalent to seq(a=l), even if l is of length 1! Commented Jul 15, 2020 at 10:59
• Wow, it's been a while since I saw such a neat and applicable golfing trick! That's probably more due to my lack of participation here than anything else. Commented Jul 15, 2020 at 18:15

# Pyramid Scheme, 407 bytes

^      ^
/l\    /+\
/oop\  ^---^
^-----^ -  /x\
/ \   / \   ---
/arg\ /set\
-----^-----^
/2\   /+\
---  ^---^
^-  /1\
^-   ---
^-
/]\
^---^
/ \ /2\
/set\---
^-----^
/x\   ^-
---  /]\
^---^
^-  /#\
/ \  ---^
/set\   / \
^-----^ /arg\
-    /+\-----^
^---^   /2\
/*\  -   ---
^---^
^-  /#\
/x\ ^---
---/ \
/arg\
^-----
/1\
---

Try it online!

Takes input through command arguments, with n as the first argument. This basically implements the algorithm:

i = 2
x = 0
o = 0
while args[i]:
o += x*args[1]
x = args[i]
i += 1

print(o + x)

But with more nesting and some shortcuts, like using the variable 2.

# K (oK), 14 13 bytes

Solution:

{*|x+/y*-1_x}

Try it online!

Explanation:

Couldn't figure out a smart way of solving this.

{*|x+/y*-1_x} / the solution
{           } / lambda taking implicity x, y
-1_x  / drop (_) 1 element from end of x
y*      / multiply by y
x+/        / sum up with x as accumulator
*|           / take last (reverse, first)

Notes:

• -1 byte thanks to coltim - thanks!
• You can trim a byte by doing {*|x+/y*-1_x} Commented Nov 19, 2020 at 14:04

# Perl 5 + -pa -MList::Util+sum, 19 bytes

$_=pop(@F)+<>*sum@F Try it online! • Did you mean -MList::Util=sum? Commented Jul 14, 2020 at 12:12 • Interesting, I didn't know = would work there. I've always used + for places where spaces can't be used without quotes or to help precedence (e.g. /\d+\D/,say+($1)x$&). Looks like a bunch of things work though. Good to know, thanks! :) Commented Jul 14, 2020 at 12:56 # Japt, 7 bytes o +V*Ux Try it online! ## Explanation o +V*Ux o // Pop and return last element of first input + // plus V* // second input times Ux // Sum of first input # Retina 0.8.2, 31 bytes \d+$*
1(?=.*,1*;(1*)|1*$)$1
1

Try it online! Link includes test cases. Explanation:

\d+
$* Convert to unary. 1(?=.*,1*;(1*)|1*$)

Try it online!

fn($a,$n)=>array_pop($a)+array_sum($a)*$n Try it online! Just trying to use all the built-ins! # Raku, 20 bytes {@^a.pop+$^b*@a.sum}

By using twigils, @^a matches the first arg (the array), and \$^b the second (the multiplier).

Try it online!

# Jelly, 5 bytes

ṪṭSƊḅ

A dyadic Link accepting a list of numbers on the left and a number on the right which yields a number.

Try it online!

ṪṭSƊḅ - Link: list of numbers, A; number n
Ṫ     -   remove the tail (of A) and yield its value
S   -   sum (the remaining elements in A)
ṭ    -   tack -> [sum_of_remaining, tail]
ḅ  - convert from base (n) -> n×sum_of_remaining+1×tail

# Q'Nial, 33 bytes (20 bytes without operator definition)

s is op n a{+link[n*front,last]a}   %full operator definition

Explanation:

+                                   sum, reduce by +
link                               list of the items of the argument
[                              atlas (argument of link operation), point-free notation
n*                            n *
front                       all elements but the last of the argument
,
last                  last element of the argument
]                 end atlas
a                array a (argument of atlas)

Intermediate results, for n=10 and a=3 1 4 1 5

10 s 3 1 4 1 5
or
s 10 (3 1 4 1 5)

or

[n*front,last] a
+-------------+-+
|+--+--+--+--+|5|
||30|10|40|10|| |
|+--+--+--+--+| |
+-------------+-+

+--+--+--+--+-+
|30|10|40|10|5|
+--+--+--+--+-+