Inspirado por esta conversación en el chat.

Tu objetivo en este desafío es emular a un ninja y contar cuántas muertes le quedan.

Especificaciones

Tu ninja comienza con 9 muertes restantes. También obtiene una salud inicial integral como entrada.

Luego, toma como entrada una lista de eventos en su vida que alteran su salud. Estos pueden ser enteros negativos, positivos o cero.

En cualquier momento, si su salud llega a cero o por debajo de él, pierde una vida y su salud vuelve a la salud inicial.

Su programa debe informar la cantidad de muertes que le quedan. Si le queda cero o menos, en su deadlugar , debe generar .

Este es el código de golf , por lo que gana el código más corto en bytes .

Casos de prueba

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

Jalea , 30 28 26 bytes

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

Pruébalo en línea!

Cómo 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)¬²ª`Ü%

Pruébalo en línea!

Cómo funciona

Mientras trataba de campo de esta última noche (lejos de una computadora, nada menos), me encontré con un reemplazo interesante para >0: ¬. En los números, esto toma la raíz cuadrada, que devuelve NaNlos números negativos. NaNes falso, por lo que esto devuelve exactamente el mismo verdadero / falso que >0.

La extensión de este truco un poco más lejos, podemos restablecer T a T si y sólo si es >=0en sólo cinco bytes: T¬²ªU. ¿Como funciona esto? Vamos a ver:

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 puede ver, T¬²devuelve NaNsi Tes negativo; de lo contrario, vuelve T. Puesto que NaNy 0son ambos Falsy, esto proporciona una manera fácil de restablecer la salud del ninja con ªU. Este truco también se usa para devolver las vidas del ninja si ese número es positivo o "dead"negativo.

Poniendo todo esto junto:

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

Si se garantiza que la entrada no es negativa, o incluso positiva, podemos jugar golf de 1 o 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 gracias a @ETHproductions

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

Pruébelo en línea (todos los navegadores funcionan)

Explicación

(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"?

Pruébalo en línea!

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

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

Pyth, 32

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

Tenga en cuenta que hay un espacio principal. Probablemente este no sea el mejor enfoque, pero fue lo primero que se me ocurrió. Reduce el exceso de entrada al agregar los valores a la salud del ninja e incrementar un contador y restablecer la salud cuando cae por debajo de cero. Agregamos un cero al final de la lista para contar si el último cambio mata al ninja, y luego solo verificamos si el ninja está muerto. El caso de salud de inicio cero está codificado.

Banco de pruebas

MATL, 32

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

Explicación

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

La pila ahora se ve así (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

Pop la matriz y el bucle

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

Si la salud es cero, establezca el contador de muertes en cero. Manejo de casos especiales para initial health = 0.

g        # health to bool
*        # multiply with death counter

Eliminar el valor de recarga de la pila

wx

Si el contador de muertes es cero o menos, elimínelo e imprima 'muerto' en su lugar.

t0>~?x'dead'

TeaScript , 36 34 31 bytes

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

Similar a mi respuesta de JavaScript. Los últimos 4 caracteres son la descompresión de la cadena "muerto".

El intérprete en línea de TeaScript no admite la entrada de matriz, por lo que deberá abrir la consola y ejecutar esto escribiendo:

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

Explicación

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

Gracias a @RikerW por -16 bytes. :(

Gracias 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]

Primero escriba salud, luego ingrese, luego eventos en 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());}}

Toma la entrada a través del flujo de argumentos. El primer argumento es la cantidad de salud y todo lo demás es la lista de eventos.

Versión legible / sin golf

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

Ejemplos:

• CSharp.exe 3 => 9

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

(Psst.) CSharp.exe es el nombre utilizado como ejemplo. Debe llamar así en realidad: argumentos [nombre_programa.exe], sin paréntesis cuadrados.