Inspirado por esta conversa no chat.

Seu objetivo neste desafio é imitar um ninja e contar quantas mortes ele deixou.

Especificações

Seu ninja começa com 9 mortes restantes. Ele também recebe uma saúde inicial integral como insumo.

Então, ele toma como entrada uma lista de eventos em sua vida que alteram sua saúde. Estes podem ser números inteiros negativos, positivos ou zero.

A qualquer momento, se sua saúde atingir um valor igual ou inferior a zero, ele perde uma vida e sua saúde volta ao estado inicial.

Seu programa deve relatar o número de mortes que ele deixou. Se ele tiver zero ou menos à esquerda, você deve imprimir dead.

Isso é código-golfe , então o código mais curto em bytes vence!

Casos de teste

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

Geléia , 30 28 26 bytes

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

Experimente online!

Como funciona

;@ñ\<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 bytes

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

Experimente online!

Como funciona

Ao tentar golf esta última noite (longe de um computador, não menos), deparei com um substituto interessante para >0: ¬. Nos números, isso leva a raiz quadrada, que retorna NaNpara números negativos. NaNé falso, então isso retorna exatamente o mesmo de verdade / falsidade que >0.

Estendendo este truque um pouco mais, podemos redefinir T de U sse é >=0em apenas cinco bytes: T¬²ªU. Como é que isso funciona? Vamos dar uma olhada:

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

Como você pode ver, T¬²retorna NaNse Tfor negativo; caso contrário, ele retornará T. Desde NaNe 0ambos são falsos, isso fornece uma maneira fácil de restaurar a saúde dos ninjas ªU. Esse truque também é usado para devolver a vida do ninja, se esse número for positivo ou "dead"negativo.

Juntando tudo isso:

           // 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 a entrada for garantida como não negativa ou até positiva, podemos jogar golfe de 1 ou 4 bytes:

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 bytes

Guardado 4 bytes graças a @ETHproductions

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

Experimente online (todos os navegadores funcionam)

Explicação

(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 bytes

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

Experimente online!

Haskell, 81 77 75 bytes

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

Exemplo de uso: p 10 0 100 [-20, 5, -50, 15, -30, -30, 10]->"8"

Pyth, 32

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

Observe que há um espaço à esquerda. Esta provavelmente não é a melhor abordagem, mas foi a primeira coisa que veio à mente. Reduz o excesso de entrada adicionando valores à saúde do ninja, aumentando um contador e redefinindo a saúde quando cai abaixo de zero. Adicionamos um zero ao final da lista para contar se a última alteração mata o ninja e, em seguida, apenas verificamos se o ninja está morto. O caso de integridade inicial zero é codificado.

Suíte de teste

MATL, 32

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

Explicação

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

A pilha agora se parece com esta (para entrada 100, [-20, 5, -50, 15, -30, -30, 10]):

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

reload   deaths    health
value    left

Estale a matriz e faça um loop

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

Se a saúde for zero, defina o contador de mortes como zero. Manuseio de caso especial para initial health = 0.

g        # health to bool
*        # multiply with death counter

Excluir o valor de recarga da pilha

wx

Se o contador de mortes for zero ou menos, exclua-o e imprima 'morto'.

t0>~?x'dead'

TeaScript , 36 34 31 bytes

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

Semelhante à minha resposta JavaScript. os últimos 4 caracteres são a descompactação da string "dead".

O intérprete on-line do TeaScript não suporta entrada de matriz, portanto, você precisará abrir o console e executar isso digitando:

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

Explicação

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

Graças a @RikerW por -16 bytes. :(

Graças a @ Maltysen por -11 bytes. :(

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]

Primeiro digite health, depois insira e depois os eventos em forma de lista.

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());}}

Leva a entrada através do fluxo de argumentos. O primeiro argumento é a quantidade de integridade e todo o resto é a lista de eventos.

Versão legível / não protegida

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());
    }
}

Exemplos:

• CSharp.exe 3 => 9

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

(Psst.) CSharp.exe é o nome usado como exemplo. Você deve chamar assim na realidade: argumentos [program_name.exe], sem os parênteses quadrados.