Inspiré par cette conversation dans le chat.

Votre objectif dans ce défi est d'imiter un ninja et de compter le nombre de morts qu'il lui reste.

Spécifications

Votre ninja commence avec 9 morts. Il obtient également une santé de départ intégrale en entrée.

Ensuite, il prend en entrée une liste d'événements de sa vie qui altèrent sa santé. Il peut s'agir d'entiers négatifs, positifs ou nuls.

À tout moment, si sa santé atteint zéro ou moins, il perd une vie et sa santé revient à sa santé de départ.

Votre programme devrait signaler le nombre de décès qu'il lui reste. S'il reste zéro ou moins, vous devez deadplutôt produire .

C'est le code-golf , donc le code le plus court en octets gagne!

Cas de 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

Gelée , 30 28 26 octets

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

Essayez-le en ligne!

Comment ça fonctionne

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

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

Essayez-le en ligne!

Comment ça fonctionne

Tout en essayant de golf hier soir (loin d'un ordinateur, pas moins), je suis tombé sur un remplacement intéressant pour >0: ¬. Sur les nombres, cela prend la racine carrée, qui renvoie NaNpour les nombres négatifs. NaNest fausse, donc cela retourne exactement la même vérité / fausse que >0.

L' extension de cette astuce un peu plus loin, nous pouvons réinitialiser T à U ssi il est >=0en seulement cinq octets: T¬²ªU. Comment cela marche-t-il? Nous allons jeter un coup d'oeil:

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

Comme vous pouvez le voir, T¬²renvoie NaNif Test négatif; sinon, il revient T. Depuis NaNet 0sont tous deux fausses, cela fournit un moyen facile de réinitialiser la santé du ninja ªU. Cette astuce est également utilisée pour restituer les vies du ninja si ce nombre est positif ou "dead"négatif.

Mettre tout cela ensemble:

           // 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 l'entrée est garantie non négative, voire positive, on peut jouer au golf de 1 ou 4 octets:

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 octets

4 octets enregistrés grâce à @ETHproductions

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

Essayez-le en ligne (tous les navigateurs fonctionnent)

Explication

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

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

Essayez-le en ligne!

Haskell, 81 77 75 octets

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

Exemple d'utilisation: p 10 0 100 [-20, 5, -50, 15, -30, -30, 10]->"8"

Pyth, 32

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

Notez qu'il y a un espace de tête. Ce n'est probablement pas la meilleure approche, mais c'est la première chose qui m'est venue à l'esprit. Il réduit la sur-entrée en ajoutant des valeurs à la santé du ninja, en incrémentant un compteur et en réinitialisant la santé lorsqu'elle tombe en dessous de zéro. Nous ajoutons un zéro à la fin de la liste pour compter si le dernier changement tue le ninja, puis vérifions simplement si le ninja est mort. Le cas de santé de départ zéro est codé en dur.

Suite de tests

MATL, 32

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

Explication

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

La pile ressemble maintenant à ceci (pour l'entrée 100, [-20, 5, -50, 15, -30, -30, 10]):

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

reload   deaths    health
value    left

Pop le tableau et la boucle

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

Si la santé est nulle, mettez le compteur de morts à zéro. Traitement des cas spéciaux pour initial health = 0.

g        # health to bool
*        # multiply with death counter

Supprimer la valeur de rechargement de la pile

wx

Si le compteur de décès est de zéro ou moins, supprimez-le et imprimez «mort» à la place.

t0>~?x'dead'

TeaScript , 36 34 31 octets

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

Similaire à ma réponse JavaScript. les 4 derniers caractères sont la décompression de la chaîne "morte".

L'interpréteur en ligne de TeaScript ne prend pas en charge l'entrée de tableau, vous devrez donc ouvrir la console et l'exécuter en tapant:

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

Explication

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

Merci à @RikerW pour -16 octets. :(

Merci à @Maltysen pour -11 octets. :(

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]

Saisissez d'abord la santé, puis entrez, puis les événements sous forme de liste.

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

Prend l'entrée via le flux d'arguments. Le premier argument est la quantité de santé et tout le reste est la liste des événements.

Version lisible / non golfée

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

Exemples:

• CSharp.exe 3 => 9

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

(Psst.) CSharp.exe est le nom utilisé comme exemple. Vous devez appeler comme ceci en réalité: [program_name.exe] arguments, sans les parenthèses carrées.