Il s'agit d'un problème du NCPC 2005 . Roy a un appartement avec une seule prise électrique, mais il a un tas de multiprises. Calculez le nombre maximum de prises qu'il peut avoir en utilisant les multiprises dont il dispose. Le nombre de prises par multiprise est donné en entrée.

Il s'avère que si le nombre de sorties des bandes respectivement est

alors le nombre de sorties est ,

ou

.

L'entrée du programme ou de la fonction est une série non vide d'entiers positifs.

Exemples

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

Gelée, 3 octets

’S‘

Décrémenter (tout), somme, incrément. Essayez-le ici.

Rétine , 3 octets

 1

Le saut de ligne arrière est important.

L'entrée est une liste de nombres unaires séparés par des espaces .

Essayez-le en ligne!

Explication

Le code supprime simplement tous les espaces ainsi que 1les suivants de la chaîne. Voici pourquoi cela fonctionne:

L'ajout dans unaire est simple: il suffit de concaténer les nombres, ce qui revient à supprimer les délimiteurs. La décrémentation de 1 est également simple: il suffit de supprimer un 1de chaque nombre. Nous voulons cependant 1 de plus que la somme des entrées décrémentées, donc nous ne supprimons que les 1s que nous trouvons après les espaces, décrémentant ainsi toutes les entrées sauf la première.

Hexagonie , 18 14 octets

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

Déplié:

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

Essayez-le en ligne!

Je ne pense pas que la longueur du côté 2 soit possible, mais il doit y avoir une solution plus efficace du côté 3 que cela.

C'est l'approche habituelle "décrémenter tout, somme, incrémenter", mais je devrai ajouter des diagrammes plus tard pour montrer comment cela fonctionne exactement dans Hexagony.

Python, 24 octets

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

Essayez-le en ligne

Mathematica, 9 octets

Tr[#-1]+1&

Haskell, 17 15 octets

foldl1$(+).pred

Exemple d'utilisation: ( foldl1$(+).pred ) [2,4,6]->10 .

Ancienne version, approche différente, 17 octets: succ.sum.map pred.

J, 6 octets

+/+1-#

Somme plus une longueur moins. Entre parenthèses et appliquez-le, comme ceci:

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

Labyrinthe , 9 octets

"?;)!@
+(

Essayez-le en ligne!

Le primaire habituel:

• Labyrinth est 2D et basé sur la pile. Les piles ont un nombre infini de zéros en bas.
• Lorsque le pointeur d'instruction atteint une jonction, il vérifie le haut de la pile pour déterminer où tourner ensuite. Le négatif est à gauche, le zéro est en avant et le positif est à droite.

Ici, nous commençons en haut à gauche ", un no-op, se dirigeant vers la droite. Ensuite ?, qui lit un entier dans STDIN (jetant les caractères qu'il ne peut pas analyser comme un entier, par exemple des espaces). Maintenant, nous avons deux cas:

Si l'entrée est positive, nous tournons à droite en effectuant:

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

Si l'entrée est nulle (ce qui se produit à EOF), nous allons tout droit en effectuant:

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

Pyth, 5 octets

hstMQ

incrément (somme (mappage (décrémentation, entrée)))

ES6, 25 octets

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

MATL, 3 octets

qsQ

Essayez-le en ligne.

Explication

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

05AB1E , 4 octets

Code:

E<O>

Explication:

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

Prend l'entrée comme un tableau (par exemple [3, 4, 5]).

Étoilé , 26 24 octets

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

Attend des entiers séparés par des sauts de ligne. Essayez-le en ligne!

Merci à @ MartinBüttner pour -2 octets.

,           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

La boucle est déroulée afin que le premier nombre ne soit pas décrémenté, ce qui annule la nécessité d'incrémenter. Pousser les chiffres coûte cher dans Starry ...

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+}]

APL (NARS 2000), 13 10 bytes

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

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

{1++/1-⍨⍵}

gs2, 5 bytes

(CP437-encoded.)

W&Φd'

That’s read-nums dec m1 sum inc.

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~{(+}*

Cela replie "décrémenter, ajouter" sur la liste. En faisant cela, la décrémentation n'est appliquée qu'à tous les éléments à l'exception du premier, de sorte que nous n'avons pas besoin de prendre soin de l'incrément séparément.

C, 60 59 55 octets

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

Perl 6, 14 octets

{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

Sérieusement, 7 octets

,;l@Σ-u

Essayez-le en ligne!

Explication:

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

Perl 6 , 20 octets

put 1+sum --«@*ARGS

(Vous pouvez utiliser <<au lieu de« )

Usage:

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

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

Nécessite des -apdrapeaux:

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

Enregistré dans un fichier et exécuté en tant que

perl -ap file.pl

EDIT: Une autre réponse, plus petite (19 + 2) mais essentiellement copiée à partir de la réponse dev-null:

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

F #, 25 octets

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

Il s'agit d'une fonction qui prend dans un tableau / liste / séquence d'entiers et renvoie le résultat requis.

Comment ça marche:

Seq.foldvous permet d'appliquer une fonction à chaque élément d'une séquence tout en portant un état tout en le faisant. Le résultat de la fonction appliquée au premier élément donnera l'état qui sera mis dans la fonction du deuxième élément, et ainsi de suite. Par exemple, pour résumer la liste [1; 3; 4; 10], vous l'écririez comme ceci:

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

Ce qui serait appliqué ainsi:

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

Le dernier état étant la valeur de retour de Seq.fold.

𝔼𝕊𝕄𝕚𝕟, 5 caractères / 7 octets

ï⒭+‡_

Try it here (Firefox only).

Utilise un encodage personnalisé avec des caractères 10 bits (thx @Dennis!). Exécutez encode('ï⒭+‡_')dans la console JS pour obtenir un formulaire encodé, etdecode(/*ENCODED TEXT HERE*/) pour décoder le formulaire codé.

Explication

Se traduit en Javascript ES6 comme:

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

Mornington Crescent , 1909 1873 1839 octets

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

Essayez-le en ligne!

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}

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

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.

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

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:

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