Ispirato da questa conversazione in chat.

Il tuo obiettivo in questa sfida è emulare un ninja e contare quante morti gli sono rimaste.

Specifiche

Il tuo ninja inizia con 9 morti rimasti. Riceve anche una salute iniziale iniziale come input.

Quindi, prende come input un elenco di eventi nella sua vita che alterano la sua salute. Questi possono essere numeri interi negativi, positivi o zero.

In qualsiasi momento, se la sua salute raggiunge lo zero o al di sotto di esso, perde una vita e la sua salute torna alla salute iniziale.

Il tuo programma dovrebbe riportare il numero di decessi rimasti. Se gli rimane zero o meno, dovresti deadinvece produrre .

Questo è code-golf , quindi vince il codice più breve in byte !

Casi test

3, [] -> 9
100, [-20, 5, -50, 15, -30, -30, 10] -> 8
10, [-10, -10, -10, -10] -> 5
10, [-10, -10, -10, -10, -10, -10, -10, -10, -10] -> dead
0, [] -> dead
0, [1] -> dead
100, [10, -100] -> 9

Gelatina , 30 28 26 byte

»0o⁴+
;@ñ\<1S_9«0N“dead”×?

Provalo online!

Come funziona

;@ñ\<1S_9«0N“dead”×?  Main link. Input: e (events), h (initial health)

;@                    Prepend h to e.
  ñ\                  Reduce the resulting array by the next, dyadic link.
                      This returns the array of intermediate results.
    <1                Check each intermediate value for non-positivity.
      S               Sum. This calculates the number of event deaths.
       _9             Subtract 9 from the result.
         «0           Take the minimum of the result and 0. This yields 0 if no
                      lives are left, the negated amount of lives otherwise.
                   ?  Conditional:
                  ×     If the product of the minimum and h is non-zero:
           N              Return the negated minimum.
            “dead”      Else, return "dead".


»0o⁴+                 Dyadic helper link. Arguments: x, y

»0                    Take the maximum of x and 0.
                      This yields x if x > 0 and 0 otherwise.
  o⁴                  Take the logical OR of the result and the second input (h).
    +                 Take the sum of the result and y.

Japt, 40 39 32 byte

U¬©(9-Vf@T=X+(T¬²ªU)<1} l)¬²ª`Ü%

Provalo online!

Come funziona

Durante il tentativo di golf questa ultima notte (lontano da un computer, non meno), mi sono imbattuto in un sostituto interessante per >0: ¬. Sui numeri, prende la radice quadrata, che restituisce NaNnumeri negativi. NaNè falsa, quindi restituisce esattamente la stessa verità / falsità di >0.

Estensione di un po 'più questo trucco, siamo in grado di ripristinare T U se e solo se è >=0in soli cinque byte: T¬²ªU. Come funziona? Diamo un'occhiata:

T    ¬      ²       ªU
     sqrt   square  if falsy, set to U (JS's || operator)
4    2      4       4
7   ~2.646  7       7
0    0      0       U
-4   NaN    NaN     U
-7   NaN    NaN     U

Come puoi vedere, T¬²ritorna NaNse Tè negativo; altrimenti, ritorna T. Poiché NaNe 0sono entrambi falsi, questo fornisce un modo semplice per ripristinare la salute del ninja ªU. Questo trucco è anche usato per restituire le vite del ninja rimaste se quel numero è positivo o "dead"se negativo.

Mettendo tutto insieme:

           // Implicit: U = starting health, V = events, T = 0
U©        // If U is positive,
Vf@     }  // Filter out the items X in V that return truthily from this function:
 T=X+      //  Set T to X plus
 (T¬²ªU)   //   If T is positive, T; otherwise, U.
           //  This keeps a running total of the ninja's health, resetting upon death.
 <1        //  Return (T < 1).
9-    l)   // Take the length of the resulting array and subtract from 9.
           // This returns the number of lives the ninja has left.
¬²         // If the result is negative, set it to NaN.
ª`Ü%       // If the result of EITHER of the two parts above is falsy, return "dead".
           //  (`Ü%` is "dead" compressed.)
           // Otherwise, return the result of the middle part (lives left).
           // Implicit: output last expression

Se l'input è garantito per essere non negativo o anche positivo, possiamo giocare a golf di 1 o 4 byte:

U©(9-Vf@T=X+(T¬²ªU)<1} l)¬²ª`Ü%  // U is non-negative
9-Vf@T=X+(T¬²ªU)<1} l)¬²ª`Ü%     // U is positive

JavaScript ES6, 62 60 58 byte

Salvato 4 byte grazie a @ETHproductions

(a,b,d=9,l=a)=>b.map(i=>l=l+i<1?d--&&a:l+i,a)|d<1?"dead":d

Provalo online (tutti i browser funzionano)

Spiegazione

(a,b,    // a = 1st input, b = 2nd input
 d=9)=>  // Lives counter

  (b.reduce((l,i)=>     // Loop through all the health changes
    l+i<1                 // If (health + health change) < 1
    ?(d--,a)              // Decrease life, reset health
    :l+i                  // Return new health
  ,a)                   // Sets starting health to `a`
  ,d<1?        // Lives is less than 1
   "dead":d);  // Output "dead" otherwise lives left

CJam, 35 byte

q~_@{+_1<{W$}&}/](\,_A<@*A@-"dead"?

Provalo online!

Haskell, 81 77 75 byte

p l i h a|l<1="dead"|i<1=p(l-1)h h a|[]<-a=show l|x:y<-a=p l(i+x)h y
p 10 0

Esempio di utilizzo: p 10 0 100 [-20, 5, -50, 15, -30, -30, 10]->"8"

Pyth, 32

 u+?>GZG&=hZQH+E0Q?&Q<Z9-9Z"dead

Nota che c'è uno spazio iniziale. Questo probabilmente non è l'approccio migliore, ma è stata la prima cosa che mi è venuta in mente. Riduce l'input eccessivo aggiungendo i valori alla salute del ninja, incrementando un contatore e ripristinando la salute quando scende sotto lo zero. Aggiungiamo uno zero alla fine dell'elenco per contare se l'ultima modifica uccide il ninja, quindi facciamo un po 'di controllo per vedere se il ninja è morto. Il caso di salute iniziale zero è codificato.

Test Suite

MATL, 32

9yi"@+t0>~?x1-y]]g*wxt0>~?x'dead'

Spiegazione

9        # push 9
y        # duplicate 2nd value to top (there is none -> get it from input first)
i        # get input and push it

Lo stack ora appare così (per input 100, [-20, 5, -50, 15, -30, -30, 10]):

100        9        100        [-20, 5, -50, 15, -30, -30, 10]

reload   deaths    health
value    left

Pop l'array e il loop

"            ]    # loop
 @+               # add to health
   t0>~?    ]     # if health is zero or less
        x1-y      # delete health counter, decrement life counter, reload health

Se la salute è zero, imposta il contatore della morte su zero. Gestione di casi speciali per initial health = 0.

g        # health to bool
*        # multiply with death counter

Elimina il valore di ricarica dallo stack

wx

Se il contatore della morte è zero o inferiore, eliminalo e stampa invece 'morto'.

t0>~?x'dead'

TeaScript , 36 34 31 byte

yR#l+i<1?e─·x:l+i,x);e≥0?e:D`Ü%

Simile alla mia risposta JavaScript. gli ultimi 4 caratteri sono la decompressione della stringa "morta".

L'interprete online di TeaScript non supporta l'input dell'array, quindi dovrai aprire la console ed eseguirlo digitando:

TeaScript( `yR#l+i<1?(e─,x):l+i,x);─e>0?e:D\`Ü%` ,[
  10, [-10, -10, -10, -10]
],{},TEASCRIPT_PROPS);

Spiegazione

      // Implicit: x = 1st input, y = 2nd input
yR#   // Reduce over 2nd input
  l+i<1?  // If pending health is less then 1
  (e─,x): // then, decrease life counter, reset health
  l+i     // else, modify health
,x);  // Set starting health
─e>0? // Ninja is alive?
e:    // Output lives left
D`Ü%  // Decompress and output "dead"

Python 2.7, 82 66 55 106 byte

Grazie a @RikerW per -16 byte. :(

Grazie a @Maltysen per -11 byte. :(

i=input;h=[i()]*9;d=i()
if 0==h[0]:print'dead';exit()
for x in d:
 h[0]+=x
 if h[0]<=0:h=h[1:]
y=len(h)
print['dead',y][y!=0]

Digita prima lo stato, quindi inserisci, quindi gli eventi in forma di elenco.

C # 207

class P{static void Main(string[]a){int h=int.Parse(a[0]),H=h,l=9,i=1;if(a.Length!=1){for(;i<a.Length;i++){H+=int.Parse(a[i]);if(H<=0){l--;H=h;}}}System.Console.Write(h==0?"dead":l<=0?"dead":l.ToString());}}

Accetta l'input tramite il flusso di argomenti. Il primo argomento è la quantità di salute e tutto il resto è l'elenco degli eventi.

Versione leggibile / non modificata

class Program
{
    static void Main(string[]a)
    {
        int health = int.Parse(a[0]);
        int Health = health;
        int lives = 9;

        if(a.Length!=1)
        {
            for (int i = 1;i < a.Length;i++)
            {
                Health += int.Parse(a[i]);
                if (Health <= 0)
                {
                    lives--;
                    Health = health;
                }
            }
        }

        System.Console.Write(health == 0 ? "dead" : lives <= 0 ? "dead" : lives.ToString());
    }
}

Esempi:

• CSharp.exe 3 => 9

• CSharp.exe 100-20 5-50 15-30-30 10 => 8

(Psst.) CSharp.exe è il nome usato come esempio. In realtà devi chiamare in questo modo: argomenti [nome_programma.exe], senza le parentesi quadre.