Electrical outlet

Question

This is a problem from NCPC 2005. Roy has an apartment with only one single electrical outlet, but he has a bunch of power strips. Compute the maximum number of outlets he can have using the power strips he has. The number of outlets per power strip is given as input.

It turns out that if the number of outlets of the strips respectively are

$$p_1, p_2, \dots, p_n$$

then the number of outlets is $$1 - n + \sum_i p_i$$ ,

or

$$1 + p_1-1 + p_2-1 + \dots + p_n-1$$.

The input to the program or function is a non-empty series of positive integers.

Examples

2 3 4
> 7
2 4 6
> 10
1 1 1 1 1 1 1 1
> 1
100 1000 10000
> 11098

Answer 1

Jelly, 3 bytes

’S‘

Decrement (all), sum, increment. Try it here.

Answer 2

Retina, 3 bytes

 1

The trailing linefeed is significant.

Input is a space-separated list of unary numbers.

Try it online!

Explanation

The code simply removes all spaces as well as the 1 after them from the string. Here is why that works:

Addition in unary is simple: just concatenate the numbers which is the same as removing the delimiters. Decrementing by 1 is also simple: just remove a 1 from each number. We want 1 more than the sum of the decremented inputs though, so we simply only remove the 1s we find after spaces, thereby decrementing all but the first input.

Answer 3

Hexagony, 18 14 bytes

.?<_(@'")>{+.!

Unfolded:

  . ? <
 _ ( @ '
" ) > { +
 . ! . .
  . . .

Try it online!

I don't think side-length 2 is possible, but there must might be a more efficient side-length 3 solution that this.

This is the usual "decrement all, sum, increment" approach, but I'll have to add diagrams later to show how exactly it works in Hexagony.

Answer 4

Python, 24 bytes

lambda*n:1-len(n)+sum(n)

Try it online

Answer 5

Mathematica, 9 bytes

Tr[#-1]+1&

Answer 6

Haskell, 17 15 bytes

foldl1$(+).pred

Usage example: ( foldl1$(+).pred ) [2,4,6] -> 10.

Old version, different approach, 17 bytes: succ.sum.map pred.

Answer 7

J, 6 bytes

+/+1-#

Sum plus one minus length. Parenthesize and apply it, like so:

   (+/+1-#) 2 3 4
7

Answer 8

Labyrinth, 9 bytes

"?;)!@
+(

Try it online!

The usual primer:

• Labyrinth is 2D and stack-based. Stacks have an infinite number of zeroes on the bottom.
• When the instruction pointer reaches a junction, it checks the top of the stack to determine where to turn next. Negative is left, zero is forward and positive is right.

Here we start at the top left ", a no-op, heading rightward. Next is ?, which reads an int from STDIN (throwing away chars it can't parse as an integer, e.g. spaces). Now we have two cases:

If the input is positive, we turn right, performing:

(            decrement top of stack
+            add top two stack elements
             [continue loop]

If the input is zero (which occurs at EOF), we go straight ahead, performing:

;            pop zero from EOF
)            increment top of stack
!            output top of stack as number
@            halt program

Answer 9

Pyth, 5 bytes

hstMQ

increment(sum(map(decrement, input)))

Answer 10

ES6, 25 bytes

a=>a.map(n=>r+=n-1,r=1)|r

Answer 11

MATL, 3 bytes

qsQ

Try it online.

Explanation

qsQ
q      thread decrement over the input array
  s    sum
   Q   increment

Answer 12

Starry, 26 24 bytes

, + '`      + ** `, +'*.

Expects newline-separated integers. Try it online!

Thanks to @MartinBüttner for -2 bytes.

,           Read line as integer
 + '        Dupe and jump to label 1 if nonzero
`           Set label 0
      +     Push 1
 *          Sub
*           Add
 `          Set label 1
,           Read line as integer
 + '        Dupe and jump to label 0 if nonzero
*           Add
.           Output as integer

The loop is unrolled so that the first number is not decremented, negating the need to increment. Pushing numbers is expensive in Starry...

Answer 13

05AB1E, 4 bytes

Code:

E<O>

Explanation:

E     # Evaluates input
 <    # Decrement on list
  O   # Compute the total sum
   >  # Increment on the sum
      # Implicit: output top of the stack

Takes input like an array (e.g. [3, 4, 5]).

Answer 14

Bash + GNU utilities, 16

If there are N power strips, then there should be N-1 separators in the comma-separated input list. All we need to do is replace the separators with - 1 + and arithmetically evaluate:

sed s/,/-1+/g|bc

Or using the same trick:

Pure Bash (no external utilities), 19

echo $[${1//,/-1+}]

Answer 15

APL (NARS 2000), 13 10 bytes

{1+(+/⍵)-⍴∊⍵}

Edit: Down to 10 with Lynn's (better) approach.

{1++/1-⍨⍵}

Answer 16

CJam, 7 bytes

q~:(:+)

Test it here.

Same approach as Lynn's (decrement all, sum, increment). This also works for 8 bytes (and is maybe a bit more interesting):

q~{(+}*

This folds "decrement, add" over the list. By doing that, the decrement is only applied to all elements except the first, such that we don't need to take care of the increment separately.

Answer 17

gs2, 5 bytes

(CP437-encoded.)

W&Φd'

That’s read-nums dec m1 sum inc.

Answer 18

Seriously, 7 bytes

,;l@Σ-u

Try it online!

Explanation:

,;l@Σ-u
,        push input
 ;       dupe
  l@     push length (n), swap
    Σ-u  push sum, subtract n, add one

Answer 19

C, 60 59 55 bytes

x;main(s){while(~scanf("%i",&x))s+=x-1;printf("%i",s);}

Answer 20

Perl 6, 14 bytes

{1+[+] --«@_}

usage

my &f = {1+[+] --«@_}

say f([2,3,4]) # 7
say f([2,4,6]) # 10
say f([1,1,1,1,1,1,1,1]) # 1
say f([100,1000,10000]) # 11098

Answer 21

Perl 6, 20 bytes

put 1+sum --«@*ARGS

( You can use << instead of « )

Usage:

$ perl6 -e 'put 1+sum --«@*ARGS' 100 1000 10000
11098

Answer 22

Perl 5 23+2=25 or 19+2=21

Requires -ap flags:

map{$.+=($_-1)}@F;$_=$.

Saved in a file and run as

perl -ap file.pl

EDIT: Another answer, smaller (19+2) but basically copied from dev-null answer:

$.+=$_-1for@F;$_=$.

Answer 23

F#, 25 bytes

Seq.fold(fun s n->s+n-1)1

This is a function that takes in an array/list/sequence of integers and returns the required result.

How it works:

Seq.fold allows you to apply a function to every element of a sequence while carrying some state around while it does so. The result of the function as applied to the first element will give the state that will be put into the function for the second element, and so forth. For example, to sum up the list [1; 3; 4; 10], you'd write it like this:

Seq.fold (fun sum element -> sum + element) 0 [1; 3; 4; 10]
         (       function to apply        ) ^ (sequence to process)
                                     ( initial state )

Which would be applied like so:

// First, initial state  + first element
0 + 1  = 1
// Then, previous state + next element until the end of the sequence
1 + 3  = 4
4 + 4  = 8
8 + 10 = 18

With the last state being the return value of Seq.fold.

Answer 24

, 5 chars / 7 bytes

ï⒭+‡_

Try it here (Firefox only).

Uses a custom encoding with 10-bit chars (thx @Dennis!). Run encode('ï⒭+‡_') in the JS console to get encoded form, and decode(/*ENCODED TEXT HERE*/) to decode encoded form.

Explanation

Translates to Javascript ES6 as:

i=>i.reduce(($,_)=>$+--_)

Answer 25

Mornington Crescent, 1909 1873 1839 bytes

Take Northern Line to Stockwell
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Circle Line to Victoria
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Cannon Street
Take Circle Line to Hammersmith
Take Circle Line to Cannon Street
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Turnham Green
Take District Line to Hammersmith
Take District Line to Turnham Green
Take District Line to Notting Hill Gate
Take Circle Line to Notting Hill Gate
Take Circle Line to Bank
Take Circle Line to Embankment
Take Northern Line to Stockwell
Take Northern Line to Embankment
Take Circle Line to Temple
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Blackfriars
Take Circle Line to Embankment
Take District Line to Parsons Green
Take District Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Parsons Green
Take District Line to Embankment
Take Circle Line to Blackfriars
Take Circle Line to Bank
Take Northern Line to Angel
Take Northern Line to Bank
Take Circle Line to Bank
Take District Line to Upminster
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Mornington Crescent

Try it online!

Answer 26

APL Nars 9 chars

{1++/⍵-1}

test

f←{1++/⍵-1}
  f 2 3 4
7
  f 2 4 6
10
  f 1 1 1 1 1 1 1 1
1
  f 100 1000 10000
11098

Answer 27

TIS, 93 bytes

Code:

@0
MOV ANY ANY
@1
MOV UP ACC
JGZ G
SWP
ADD 1
MOV ACC DOWN
G:SUB 1
MOV ACC ANY
SWP
ADD ANY
SWP

Layout:

1 2 CC
I1 NUMERIC -
O1 NUMERIC -

Try it online!

Note that this solution requires the list to be terminated by a zero (or more accurately, a non-positive value).

With TIS, we'd need to choose one of the following a) a terminating character, b) a length-prefixed array, or c) a running output for every value. Otherwise, a program would never print any output because there (theoretically) could be more input on the way.

Explanation:

Each node has two accumulators, called ACC and BAK. BAK can only be accessed by the SWP instruction, which swaps the values in ACC and BAK. In the following, I will use variables X and Y to track the values more directly. I'll also use Z as shorthand for the entire node 0.

Additionally, each node implicitly loops back to the top when it reaches the bottom.

                                  |    Input 0    | Input as whitespace-delimited numbers
                  +--------+------+--------+------+
                  | Node 0 |      | Node 1 |      |
Node 0 is just an +--------+      +--------+      |
extra memory cell | MOV ANY ANY   | MOV UP ACC    | Put input value into X
so we can perform |               | JGZ G         | If X>0, jump to label G
logic on input    |               | SWP           | Swap focus to Y
values easier     |               | ADD 1         | Y++
                  |               | MOV ACC DOWN  | Output the value Y
                  |               |               | (end program -- see note 1 below)
                  |               | G:SUB 1       | Label G: X--
                  |               | MOV ACC ANY   | Z = X (also see note 2 below)
                  |               | SWP           | Swap focus to Y
                  |               | ADD ANY       | Y += Z (also see note 2 below)
                  |               | SWP           | Swap focus to X
                  +---------------+---------------+
                                  |   Output 0    | Output as whitespace-delimited numbers

Note 1, regarding the termination of this program:

The TIS emulator I am using here will terminate the program once there is no more active processing. The most common reason for getting into such a state is to exhaust all available input, though things like deadlocks can also get us to this state.

Once the value in this program has been output, calculation will continue on at label G, mangling the data in the registers (it forgets which register is X and which is Y). However, it will quickly return to the line that reads input, and because the input will now be exhausted, the program will terminate.

Some minor modifications may be made to adjust the program to handle data after the terminator:

• Adding the instruction HCF just before the label G will cause the program to forcibly terminate at this point instead of relying on input exhaustion.
• Adding the instructions SWP and JRO -99 just before the label G will cause the program to return to a good state, then jump back to top (relative jumps can't wrap, so anything further than -15 will always go to the top line; offhand, I think -7 is the exact value needed here). This turns the terminator into a 'print' instruction instead.
• The value Y could be reset to zero, in addition to the jump described above, to treat extended input as two or more distinct invocations.

Note 2, regarding the use of ANY in node 1:

The use of ANY on the two marked lines of Node 1 is possible due to an implementation detail (this quirk is true in both this emulator and in the original Zachtronics game).

When ANY is used as the source, it looks at the node's neighbors in this order: LEFT, RIGHT, UP, DOWN. When ANY is used as the destination, it looks at the neighbors in this order: UP, LEFT, RIGHT, DOWN. (The destination ordering is a consequence of both the source ordering and the order in which the nodes are run.)

Of course, the nodes not only need to be present but also be ready to send/receive a value to be selected.

Since LEFT appears before UP as a source, and before DOWN as a destination, ANY will always be LEFT in this case.

To make this program "implementation-independent", simply replace those two ANYs with LEFTs.

The reason that the ANYs in node 0 are of no concern is that node 0 only ever has one neighbor to talk to.

Answer 28

K (oK), 6 bytes

1+/-1+

Try it online!

Answer 29

Python 3, 79 bytes

import sys
print(sum(map(lambda x: int(x)-1, sys.stdin.readline().split()))+1)

Answer 30

Perl, 21 + 2 = 23 bytes

$a+=$_-1for@F;say++$a

Requires -a and -E:

$ perl -aE'$a+=$_-1for@F;say++$a'<<<'2 3 4'
7

Answer 31

Ruby, 30 bytes

$*.inject(1){|s,v|s+=v.to_i-1}

Simple enough - starting from 1, add up the supplied numbers, each -1 (command line args are in $*). Shame inject is such a long word.

Answer 32

PowerShell, 19 bytes

$args-join'-1+'|iex

Note that 1 + p1-1 + p2-1 + ... + pn-1 is equivalent to p1-1 + p2-1 + ... + pn.

Takes input as separate command-line arguments with $args. We -join those together with a -1+ delimiter to create a string, such as 2-1+3-1+4. The string is then piped to Invoke-Expression (similar to eval), and outputs the result.

Answer 33

Brainfuck, 15 bytes

Assumption: The , operator returns 0 once all input has been exhausted, and there are no extension cords with 0 plugs. Also, the IO needs to be in byte values instead of ASCII character codes.

+>,[-[-<+>],]<.

Explanation: This uses 2 registers. A "Value" accumulator register, representing the number of devices that can be plugged in, and a "current cord" register that keeps track of the value of the current cord. It starts off by incrementing the value by 1, for the existing outlet. Then, for each extension cord, it subtracts one from the value since a plug is being taken up, then increments the value by the number of plugs.

Most online interpreters don't operate in raw byte input mode. To test it online, use this code:

+>,[->-[>+<-----]>---[-<+>]<[-<->]<[-<+>],]<.

Answer 34

PARI/GP, 17 bytes

Completely straightforward.

v->vecsum(v)-#v+1

Answer 35

Pylons, 6

Takes a list of space separated numbers on the command line then sums them all and subtracts the length.

1(i)-s

How it works:

1   # Push 1 to the stack.
(   # Start a list.
 i  # Get command line input.
  ) # End a list.
-   # Subtract the top two elements of the stack. In the case where one of the elements is
    # a list, it does matrix subtraction.
s   # Sum the stack.
    # Print the stack implicitly. 

Answer 36

R, 24 14 bytes

sum(1,scan()-1)

Edit: Fixed bug!

Answer 37

Python, 10+22=32 bytes

s=input();print(sum(s)-len(s)+1)

Main issue is not having a default input variable in Python, or implicit printing.

Answer 38

Dodos, 27 bytes

	dot dip +
+
	
	dot dab dot

Try it online!

Explanation:

The main function (top line, implicitly named main) is called at the start of the program. It contains this command:

dot dip +

+ is called on the tuple given as separate command-line arguments. This is +:

dot dab dot

The empty command simply returns the argument as-is. The other command, dot dab dot, returns 0. It has to be able to convert any given tuple to zero, so here's how this does it, right-to-left:

First of all, dot returns a 1-element tuple that contains the sum of the input's elements. The actual sum doesn't matter here, what matters is that dot will always return a 1-element tuple, so that we can use dab on it to remove its first (i.e. only) element, since there's no built-in to empty a tuple. The sum of an empty tuple is 0, so we just dot this empty tuple to return the singleton 0.

After this process, the two results of the + function (the input and 0) are implicitly concatenated. We now return to main.

The dip command will decrement each positive number by 1, and convert each 0 to 1, in +'s result. This will decrement each number of available outlets, and also increment the final 0, so we don't miss a free outlet.

Finally, the tuple will be dotted again, so we're computing the number of available outlets over all of the power strips, minus the number of power strips, plus one (no strip occupies an outlet of the last strip).

Answer 39

Common Lisp, 40 bytes

(lambda(x)(1+(-(reduce'+ x)(length x))))

Try it online!