Este é um problema do NCPC 2005 . Roy tem um apartamento com apenas uma única tomada elétrica, mas ele tem várias tomadas de força. Calcule o número máximo de tomadas que ele pode ter usando as réguas de energia que possui. O número de tomadas por filtro de linha é fornecido como entrada.

Acontece que se o número de saídas das tiras, respectivamente, for

então o número de pontos de venda é ,

ou

A entrada para o programa ou função é uma série não vazia de números inteiros positivos.

Exemplos

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

Gelatina, 3 bytes

’S‘

Decremento (todos), soma, incremento. Experimente aqui.

Retina , 3 bytes

 1

O avanço de linha à direita é significativo.

Entrada é uma lista separada por espaços de números unários .

Experimente online!

Explicação

O código simplesmente remove todos os espaços, bem como o 1depois deles, da string. Aqui está o porquê disso funcionar:

A adição em unário é simples: basta concatenar os números, o mesmo que remover os delimitadores. Decrementar por 1 também é simples: basta remover a 1de cada número. Porém, queremos 1 a mais do que a soma das entradas decrementadas, portanto, apenas removemos os 1s que encontramos após os espaços, diminuindo assim tudo, exceto a primeira entrada.

Hexagonia , 18 14 bytes

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

Desdobrado:

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

Experimente online!

Não acho que o comprimento do lado 2 seja possível, mas deve haver uma solução mais eficiente do lado do comprimento 3 do que isso.

Essa é a abordagem usual "decrementar tudo, somar, incrementar", mas terei que adicionar diagramas mais tarde para mostrar como exatamente funciona no Hexagony.

Python, 24 bytes

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

Experimente online

Mathematica, 9 bytes

Tr[#-1]+1&

Haskell, 17 15 bytes

foldl1$(+).pred

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

Versão antiga, abordagem diferente, 17 bytes: succ.sum.map pred.

J, 6 bytes

+/+1-#

Soma mais um comprimento negativo. Entre parênteses e aplique-o, da seguinte maneira:

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

Labirinto , 9 bytes

"?;)!@
+(

Experimente online!

A cartilha usual:

• O labirinto é 2D e baseado em pilha. As pilhas têm um número infinito de zeros na parte inferior.
• Quando o ponteiro de instrução atinge uma junção, ele verifica o topo da pilha para determinar para onde virar a seguir. Negativo é deixado, zero é para frente e positivo é direito.

Aqui começamos no canto superior esquerdo ", no-op, indo para a direita. A seguir ?, leia um int de STDIN (jogando fora caracteres que ele não pode analisar como um número inteiro, por exemplo, espaços). Agora temos dois casos:

Se a entrada for positiva, viramos à direita, executando:

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

Se a entrada for zero (o que ocorre no EOF), seguimos em frente, executando:

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

Pitão, 5 bytes

hstMQ

incremento (soma (mapa (decremento, entrada))))

ES6, 25 bytes

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

MATL, 3 bytes

qsQ

Experimente online.

Explicação

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

05AB1E , 4 bytes

Código:

E<O>

Explicação:

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

Recebe entrada como uma matriz (por exemplo [3, 4, 5]).

Estrelado , 26 24 bytes

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

Espera números inteiros separados por nova linha. Experimente online!

Obrigado 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

O loop é desenrolado para que o primeiro número não seja diminuído, negando a necessidade de incrementar. Empurrar números é caro em Starry ...

Utilitários Bash + GNU, 16

Se houver Nréguas de energia, deve haver N-1separadores na lista de entradas separadas por vírgula. Tudo o que precisamos fazer é substituir os separadores - 1 +e avaliar aritmeticamente:

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

Ou usando o mesmo truque:

Pure Bash (sem utilitários externos), 19

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

APL (NARS 2000), 13 10 bytes

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

Editar: até 10 com a abordagem (melhor) de Lynn.

{1++/1-⍨⍵}

gs2, 5 bytes

(Codificado em CP437.)

W&Φd'

É isso read-nums dec m1 sum inc.

CJam, 7 bytes

q~:(:+)

Teste aqui.

Mesma abordagem que a de Lynn (decrementa tudo, soma, incremento). Isso também funciona para 8 bytes (e talvez seja um pouco mais interessante):

q~{(+}*

Isso dobra "decremento, adicione" sobre a lista. Ao fazer isso, o decréscimo é aplicado apenas a todos os elementos, exceto o primeiro, de modo que não precisamos cuidar do incremento separadamente.

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

Sério, 7 bytes

,;l@Σ-u

Experimente online!

Explicação:

,;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

(Você pode usar em <<vez de «)

Uso:

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

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

Requer -apsinalizadores:

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

Salvo em um arquivo e executado como

perl -ap file.pl

EDIT: Outra resposta, menor (19 + 2), mas basicamente copiada da resposta dev-null:

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

F #, 25 bytes

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

Esta é uma função que recebe uma matriz / lista / sequência de números inteiros e retorna o resultado necessário.

Como funciona:

Seq.foldpermite que você aplique uma função a todos os elementos de uma sequência enquanto carrega algum estado enquanto o faz. O resultado da função aplicada ao primeiro elemento fornecerá o estado que será colocado na função para o segundo elemento e assim por diante. Por exemplo, para resumir a lista [1; 3; 4; 10], escreva-a assim:

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

O que seria aplicado assim:

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

Com o último estado sendo o valor de retorno de Seq.fold.

, 5 caracteres / 7 bytes

ï⒭+‡_

Try it here (Firefox only).

Usa uma codificação personalizada com caracteres de 10 bits (thx @Dennis!). Execute encode('ï⒭+‡_')no console JS para obter o formulário codificado e decode(/*ENCODED TEXT HERE*/)decodificar o formulário codificado.

Explicação

Traduz para 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

Experimente online!

Python 3, 79 bytes

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

Ruby, 30 bytes

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

Simples o suficiente - a partir de 1, some os números fornecidos, cada -1 (os argumentos da linha de comando estão dentro $*). Vergonha injecté uma palavra tão longa.

PowerShell, 19 bytes

$args-join'-1+'|iex

Note que 1 + p1-1 + p2-1 + ... + pn-1é equivalente a p1-1 + p2-1 + ... + pn.

Recebe entrada como argumentos separados da linha de comando com $args. Nós, -joinjunto com um -1+delimitador, criamos uma string, como 2-1+3-1+4. A sequência é então canalizada para Invoke-Expression(semelhante a eval) e gera o resultado.

Perl, 21 + 2 = 23 bytes

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

Requer -ae -E:

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

Brainfuck, 15 bytes

Suposição: O operador, retorna 0 quando todas as entradas estiverem esgotadas e não há cabos de extensão com 0 plugues. Além disso, o IO precisa estar em valores de bytes, em vez de códigos de caracteres ASCII.

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

Explicação: Utiliza 2 registros. Um registro acumulador "Value", representando o número de dispositivos que podem ser conectados, e um registro "cord atual" que rastreia o valor do cabo atual. Ele começa incrementando o valor em 1 para a tomada existente. Em seguida, para cada cabo de extensão, subtrai um do valor desde que um plugue está sendo retirado e depois incrementa o valor pelo número de plugues.

A maioria dos intérpretes online não opera no modo de entrada de bytes brutos. Para testá-lo online, use este código:

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