Este es un problema de NCPC 2005 . Roy tiene un departamento con una sola toma de corriente, pero tiene un montón de enchufes. Calcule el número máximo de salidas que puede tener usando las tiras de energía que tiene. El número de salidas por regleta se da como entrada.

Resulta que si el número de salidas de las tiras respectivamente son

entonces el número de salidas es ,

o

.

La entrada al programa o función es una serie no vacía de enteros positivos.

Ejemplos

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

Jalea, 3 bytes

’S‘

Decremento (todo), suma, incremento. Pruébalo aquí.

Retina , 3 bytes

 1

El avance de línea final es significativo.

La entrada es una lista separada por espacios de números unarios .

Pruébalo en línea!

Explicación

El código simplemente elimina todos los espacios, así como los 1siguientes, de la cadena. Aquí es por qué eso funciona:

La adición en unario es simple: simplemente concatene los números, lo que equivale a eliminar los delimitadores. Disminuir en 1 también es simple: simplemente elimine a 1de cada número. Sin embargo, queremos 1 más que la suma de las entradas decrementadas, por lo que simplemente eliminamos los 1s que encontramos después de los espacios, disminuyendo así todos menos la primera entrada.

Hexagonia , 18 14 bytes

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

Desplegado:

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

Pruébalo en línea!

No creo que la longitud lateral 2 sea posible, pero hay debe haber una solución de longitud lateral 3 más eficiente que esta.

Este es el enfoque habitual de "decrementar todo, suma, incremento", pero tendré que agregar diagramas más adelante para mostrar cómo funciona exactamente en Hexagony.

Python, 24 bytes

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

Pruébalo en línea

Mathematica, 9 bytes

Tr[#-1]+1&

Haskell, 17 15 bytes

foldl1$(+).pred

Ejemplo de uso: ( foldl1$(+).pred ) [2,4,6]-> 10.

Versión antigua, enfoque diferente, 17 Bytes: succ.sum.map pred.

J, 6 bytes

+/+1-#

Suma más uno menos longitud. Paréntesis y aplíquelo, así:

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

Laberinto , 9 bytes

"?;)!@
+(

Pruébalo en línea!

La cartilla habitual:

• Labyrinth es 2D y está basado en pila. Las pilas tienen un número infinito de ceros en la parte inferior.
• Cuando el puntero de instrucción alcanza una unión, comprueba la parte superior de la pila para determinar a dónde girar a continuación. Negativo es izquierdo, cero es hacia adelante y positivo es correcto.

Aquí comenzamos en la parte superior izquierda ", un no-op, hacia la derecha. El siguiente es ?, que lee un int de STDIN (descartando caracteres que no puede analizar como un entero, por ejemplo, espacios). Ahora tenemos dos casos:

Si la entrada es positiva, giramos a la derecha, realizando:

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

Si la entrada es cero (que ocurre en EOF), seguimos adelante, realizando:

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

Pyth, 5 bytes

hstMQ

incremento (suma (mapa (decremento, entrada)))

ES6, 25 bytes

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

MATL, 3 bytes

qsQ

Pruébalo en línea.

Explicación

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

05AB1E , 4 bytes

Código:

E<O>

Explicación:

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

Toma la entrada como una matriz (por ejemplo [3, 4, 5]).

Estrellado , 26 24 bytes

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

Espera enteros separados por nueva línea. Pruébalo en línea!

Gracias a @ MartinBüttner por -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

El bucle se desenrolla para que el primer número no disminuya, lo que niega la necesidad de incrementar. Empujar números es caro en Starry ...

Bash + GNU utilidades, 16

Si hay Ntiras de alimentación, entonces debería haber N-1separadores en la lista de entrada separada por comas. Todo lo que necesitamos hacer es reemplazar los separadores con - 1 +y evaluar aritméticamente:

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

O usando el mismo truco:

Pure Bash (sin utilidades externas), 19

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

APL (NARS 2000), 13 10 bytes

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

Editar: hasta 10 con el enfoque (mejor) de Lynn.

{1++/1-⍨⍵}

gs2, 5 bytes

(CP437-codificado)

W&Φd'

Eso es read-nums dec m1 sum inc.

CJam, 7 bytes

q~:(:+)

Pruébalo aquí.

El mismo enfoque que el de Lynn (decrementar todo, suma, incremento). Esto también funciona para 8 bytes (y quizás sea un poco más interesante):

q~{(+}*

Esto pliega "decremento, agregar" sobre la lista. Al hacerlo, la disminución solo se aplica a todos los elementos, excepto al primero, de modo que no necesitamos ocuparnos del incremento por separado.

C, 60 59 55 bytes

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

Perl 6, 14 bytes

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

uso

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

En serio, 7 bytes

,;l@Σ-u

Pruébalo en línea!

Explicación:

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

Perl 6 , 20 bytes

put 1+sum --«@*ARGS

(Puedes usar en <<lugar de «)

Uso:

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

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

Requiere -apbanderas:

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

Guardado en un archivo y ejecutado como

perl -ap file.pl

EDITAR: Otra respuesta, más pequeña (19 + 2) pero básicamente copiada de la respuesta dev-null:

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

F #, 25 bytes

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

Esta es una función que toma una matriz / lista / secuencia de enteros y devuelve el resultado requerido.

Cómo funciona:

Seq.foldle permite aplicar una función a cada elemento de una secuencia mientras lleva algún estado mientras lo hace. El resultado de la función aplicada al primer elemento dará el estado que se colocará en la función para el segundo elemento, y así sucesivamente. Por ejemplo, para resumir la lista [1; 3; 4; 10], la escribiría así:

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

Que se aplicaría así:

// 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

Con el último estado siendo el valor de retorno de Seq.fold.

𝔼𝕊𝕄𝕚𝕟, 5 caracteres / 7 bytes

ï⒭+‡_

Try it here (Firefox only).

Utiliza una codificación personalizada con caracteres de 10 bits (thx @Dennis!). Ejecute encode('ï⒭+‡_')en la consola JS para obtener un formulario codificado y decode(/*ENCODED TEXT HERE*/)decodificar el formulario codificado.

Explicación

Se traduce a Javascript ES6 como:

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

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

Pruébalo en línea!

Python 3, 79 bytes

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

Rubí, 30 bytes.

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

Suficientemente simple: a partir de 1, sume los números proporcionados, cada -1 (los argumentos de la línea de comando están incluidos $*). Vergüenza injectes una palabra tan larga.

PowerShell, 19 bytes

$args-join'-1+'|iex

Tenga en cuenta que 1 + p1-1 + p2-1 + ... + pn-1es equivalente a p1-1 + p2-1 + ... + pn.

Toma datos como argumentos de línea de comandos separados con $args. Nosotros, -joinjunto con un -1+delimitador para crear una cadena, como 2-1+3-1+4. La cadena se canaliza a Invoke-Expression(similar a eval) y genera el resultado.

Perl, 21 + 2 = 23 bytes

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

Requiere -ay -E:

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

Brainfuck, 15 bytes

Suposición: El operador devuelve 0 una vez que toda la entrada se ha agotado y no hay cables de extensión con enchufes 0. Además, el IO debe estar en valores de bytes en lugar de códigos de caracteres ASCII.

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

Explicación: Esto utiliza 2 registros. Un registro de acumulador de "Valor", que representa el número de dispositivos que se pueden enchufar, y un registro de "cable actual" que realiza un seguimiento del valor del cable actual. Comienza incrementando el valor en 1, para la salida existente. Luego, para cada cable de extensión, resta uno del valor ya que se está tomando un enchufe, luego incrementa el valor por el número de enchufes.

La mayoría de los intérpretes en línea no funcionan en modo de entrada de bytes sin procesar. Para probarlo en línea, use este código:

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