Stanco di chiederti sempre quanti altri Pokémon devi catturare per ottenere evoluzioni di alto livello? Non chiedo più! Ora scriverai un programma o una funzione completa per calcolarlo per te!

La sfida:

Come input, il tuo programma riceverà un elenco dei costi in caramelle per far evolvere un Pokémon al livello successivo. (Questo elenco può essere separato da qualsiasi delimitatore di tua scelta o come argomento di funzione). Il tuo programma quindi restituirà o stamperà il numero di Pokémon che devono essere catturati, incluso quello che si evolverà, per evolversi attraverso tutti i livelli indicati.

Come si calcola questo? In questo modo:
1. Aggiungi tutti i costi delle caramelle: 12 + 50 = 62
2. Sottrai 3 caramelle dal totale, essendo questo da uno dei Pokémon che tieni in evoluzione: 62 - 3 = 59
3. Dividi questo numero per 4 (3 per catturare, 1 per darlo al Professore), prendendo sempre ceil()il risultato: ceil(59/4) = 15
4. Infine, aggiungi 1 a questo totale per ottenere il numero totale di Pokémon che devi catturare, 16!

Esempio Input -> Output:

[4] -> 2
[50] -> 13
[12, 50] -> 16
[25, 100] -> 32
[19, 35, 5, 200] -> 65

Vincente:

L'app ha già occupato gran parte dello spazio sul telefono, quindi il programma deve essere il più breve possibile. Il programma completo o la funzione con il numero di byte più piccolo verrà accettato tra due settimane! (con eventuali vincoli risolti dalla prima iscrizione inviata!)

05AB1E , 4 byte

O4÷>

Spiegazione

O    # sum
 4÷  # integer division by 4
   > # increment

Provalo online

Gelatina, 5 4 byte

S:4‘

Provalo online!

Sum, numero intero diviso :per 4e incremento ‘.

Brain-Flak 112 byte

([]<([()])>){{}({}{})([][()])}{}{({}[()])<>(({}[()()()]<({}())>)){{}(<({}()()()()<({}[()])>)>)}{}<>}{}<>{}({}())

Provalo online!

Spiegazione

Somma la pila, ne sottrae una, la divide per quattro e ne aggiunge una.

C # REPL, 15 byte

n=>n.Sum()/4+1;

Lancia a Func<IEnumerable<int>, int>.

In realtà, 4 byte

Σ¼≈u

Provalo online!

Spiegazione:

Σ¼≈u
Σ     sum
 ¼    divide by 4
  ≈   floor
   u  add 1

Brachylog , 5 byte

+:4/+

Provalo online!

Spiegazione

Una risposta molto originale ...

+        Sum
 :4/     Integer division by 4
    +    Increment

Python 2, 21 byte

lambda a:~-sum(a)/4+1

Ideone esso!

Formula: ((sum(a)-1)//4)+1dove //è floor-div.

BASH (sed + bc) 19

sed 's~)~+4)/4~'|bc

L'input è un +elenco separato su stdin
Ad esempio:
echo '(19+35+5+200)'| sed 's~)~+4)/4~'|bc

Haskell, 17 byte

(+1).(`div`4).sum

Pyke, 4 byte

seeh

Provalo qui!

((sum(input)/2)/2)+1

Pyth, 5 byte

h/sQ4

Provalo qui!

Sommare input con sQ, dividere per 4 con /4e infine incrementare h.

CJam, 7 byte

{:+4/)}

Provalo qui!

Definisce un blocco senza nome che prevede l'input nello stack e lascia il risultato lì.
:+somma l'elenco, 4/divide il risultato per 4 e lo )incrementa.

Retina , 18 17 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1.

$
¶4
.+|¶
$*
1111

L'ingresso è separato dall'alimentazione di linea.

Provalo online!

R, 22 byte

floor(sum(scan())/4+1)

JavaScript, 29 byte

x=>x.reduce((a,b)=>a+b)/4+1|0

SILOS 100 99 103 caratteri + 22 per input di esempio

Codice con cablaggio di prova.

set 512 52
set 513 10
GOSUB e
GOTO f
funce
a = 0
i = 511
lblE
i + 1
b = get i
a + b
if b E
a / 4
a + 1
return
lblf
printInt a

input come una serie di comandi set per modificare i punti dell'heap a partire dal punto 512.
Provalo online!

Python 2, 40 byte

import math
lambda s:math.ceil(sum(s)/4)