Votre tâche est simple: dites-moi qui gagne la bataille des lettres.

Les troupes

Il y a trois "troupes" différentes dans cette bataille, résumées par ce tableau.

name | health | damage
   A       25       25
   B      100        5
   C       10       50

Vous pouvez utiliser trois caractères uniques pour représenter les troupes, mais vous devez spécifier s'il ne s'agit pas de ces lettres.

La bataille

Supposons que nous ayons un exemple de bataille:

ABC # army 1
CBA # army 2

Chaque armée tire à plusieurs reprises sur l'unité la plus à gauche, jusqu'à ce qu'elle soit morte; puis ils se déplacent vers la troupe à droite et répètent. Donc, l'armée 2 attaque Adans l'armée 1 jusqu'à ce qu'elle Asoit morte, puis passez à B, puis C. L'armée 1 attaque d' Cabord, puis Bensuite A. Supposons que les armées attaquent en même temps, et donc les troupes tireront toujours si elles étaient vivantes avant le round et peuvent s'entretuer en même temps. Ils tirent dans l'ordre de gauche à droite.

La bataille se déroulerait comme suit:

ABC
CBA

BC # A (25 hp) killed by C (-50 hp), B (100 hp) attacked by B (-5 hp) and A (-25 hp), has 70 hp
BA # C (10 hp) killed by A (-25 hp), B (100 hp) attacked by B (-5 hp) and C (-50 hp), has 45 hp

BC # B (70 hp) attacked by B (-5 hp) and A (-25 hp), has 40 hp
A  # B (45 hp) killed by B (-5 hp) and C (-50 hp)

BC # B (40 hp) attacked by A (-25 hp), has 15 health
   # A (25 hp) killed by B (-5 hp) and C (-50 hp), army 2 dead

Par conséquent, l'armée 1 gagne la bataille!

Contribution

Deux cordes, la première représentant l'armée 1 et la deuxième armée 2. Elles ne sont pas nécessairement de la même taille (car qui a dit que ce serait un combat loyal?)

Production

Trois valeurs constantes uniques pour représenter la victoire de l'armée 1, la victoire de l'armée 2 ou l'événement improbable d'une égalité. Oui, il est possible que les dernières troupes s'entretuent, se terminant par une égalité.

Batailles

ABC
CBA
Army 1

CCCCC
CCCCC
Tie

CABCAB
ABBABBA
Army 2

Des échappatoires standard s'appliquent . Vous devez soumettre un programme complet.

C'est le code-golf , la solution la plus courte l'emporte.

Pyth 145 97 octets

=Y.d[,\A,25 25,\B,*TT5,\C,T*5T)Km=G@YdzJm=H@YdwW&KJMX0hG_smedH gKJ gJKI<hhK0=tK)I<hhJ0=tJ;?K1?J2Z

Un peu moins naïf qu'avant.

Essayez-le en ligne!

Explications:

Coupons le programme en plusieurs parties.

=Y.d[,\A,25 25,\B,*TT5,\C,T*5T)

     ,\A,25 25                     Create this list: ['A', [25, 25]]
              ,\B,*TT5             Create this list: ['B', [100, 5]]
                      ,\C,T*5T     Create this list: ['C', [10, 50]]
  .d[                         )    From the three lists, create a dictionary whose keys are the letters, and values are the inner lists
=Y                                 Assign to the variable Y

Le dictionnaire Yest: {'A': [25, 25], 'C': [10, 50], 'B': [100, 5]}. Alors:

Km=G@YdzJm=H@YdwMX0hG_smedH

 m=G@Ydz                           For all letters in first input string, make a copy of Y[letter]. Make a list of all those values...
K                                  ...and assign the list to the variable K
         m=H@Ydw                   For all letters in second input string, make a copy of Y[letter]. Make a list of all those values...
        J                          ...and assign the list to the variable J
                MX0hG_smedH        Create a function g which takes two lists of couples, and subtract the sum of the second elements of the couples of the second list from the first element of the first couple of the first list

À ce stade, Kest une liste de couples qui représente la première armée. Chaque couple de cette liste est une lettre de l'armée et est (health, damage)pour cette lettre. Jest exactement la même chose, mais pour la deuxième armée. gest une fonction qui prend deux armées et inflige les dégâts infligés par la deuxième armée à la première. Maintenant:

W&KJ gKJ gJKI<hhK0=tK)I<hhJ0=tJ;

W&KJ                               While K not empty and J not empty
     gKJ                           Call g(K,J). That computes the damages to first army
         gJK                       Call g(J,K). That computes the damages to second army
            I<hhK0=tK)             If the first army's first letter is dead, remove it
                      I<hhJ0=tJ    If the second army's first letter is dead, remove it
                               ;   End of while loop

Lorsque la boucle while est terminée, Ket Jont leur valeur finale. S'ils sont tous les deux vides, c'est une cravate; sinon l'armée non vide gagne. Cela est géré par le dernier morceau de code:

?K1?J2Z

?K1                                If K non-empty, display 1. Else...
   ?J2                             ...if J non-empty, display 2. Else...
      Z                            ...display zero

C'est ça!

Haskell , 199 193 179 179 176 171 octets

a!b=(t<$>a)?(t<$>b)
t v=[(5,5),(20,1),(2,10)]!!(fromEnum v-65)
m=sum.map snd
f=filter((>0).fst)
[]?[]=0
[]?_=2
_?[]=1
a@((c,d):e)?b@((h,i):j)=f((c-m b,d):e)?f((h-m a,i):j)

Essayez-le en ligne!

Petit truc: divisé toutes les statistiques de l'armée par 5.

C #, 446 octets

using System.Linq;(c,d)=>{int z=c.Length,v=d.Length,j=0,k=0,l=0,m=0,q=0;int[]e=(c+d).Select(x=>x!='A'?x=='B'?100:10:25).ToArray(),f=e.Skip(z).ToArray();e=e.Take(z).ToArray();int[]g=(c+d).Select(x=>x!='A'?x=='B'?5:100:25).ToArray(),h=g.Skip(z).ToArray();g=g.Take(z).ToArray();try{for(;;){for(q=l;q<z;q++){if(e[j]<=0)j++;e[j]-=h[q];}for(q=k;q<v;q++){if(f[m]<=0)m++;f[m]-=g[q];}if(e[k]<=0)k++;if(f[l]<=0)l++;}}catch{}return k-z>=l-v?k-z>l-v?0:2:1;};

Version formatée:

         (c, d) => {
                int z = c.Length, v = d.Length, j = 0, k = 0, l = 0, m = 0, q = 0;

                int[] e = (c + d).Select(x => x != 'A' ? x == 'B' ? 100 : 10 : 25).ToArray(), f = e.Skip(z).ToArray();
                e = e.Take(z).ToArray();

                int[] g = (c + d).Select(x => x != 'A' ? x == 'B' ? 5 : 100 : 25).ToArray(), h = g.Skip(z).ToArray();
                g = g.Take(z).ToArray();

                try {
                    for (;;) {
                        for (q = l; q < z; q++) {
                            if (e[j] <= 0) j++; e[j] -= h[q];
                        }
                        for (q = k; q < v; q++) {
                            if (f[m] <= 0) m++; f[m] -= g[q];
                        }
                        if (e[k] <= 0) k++; if (f[l] <= 0) l++;
                    }
                }
                catch {
                }

                return k - z >= l - v ? k - z > l - v ? 0 : 2 : 1;
            };

Sorties 1 si armée1 gagne, 2 pour armée2 et 0 pour égalité

Javascript (ES6) - 316 269 ​​octets

Je suis sûr que cela peut être joué comme un enfer, mais c'est ce que j'ai trouvé :) J'ai réussi à raser 47 octets!

Sorties 0 pour égalité, 1 pour l'équipe 1 et 2 pour l'équipe 2.

l=(d,f)=>{for(t=[d,f].map(g=>g.split``.map(k=>[[25,100,10],[25,5,50]].map(m=>m[k.charCodeAt()-65])));(w=t.map(g=>g.some(k=>0<k[0])))[0]&&w[1];)t.forEach((g,k,m)=>m[k].sort(o=>0>o[0])[0][0]-=m[+!k].filter(o=>0<o[0]).reduce((o,p)=>o+p[1],0));return w[0]||w[1]?w[0]?1:2:0}

Lisible :

function ltt(a,b){
    t=[a,b].map(x=>x.split``.map(c=>[[25,100,10],[25,5,50]].map(e=>e[c.charCodeAt()-65])))
    while((w=t.map(_=>_.some(x=>x[0]>0)))[0]&&w[1]){
        t.forEach((y,i,n)=>n[i].sort(j=>j[0]<0)[0][0]-=n[+!i].filter(x=>x[0]>0).reduce((h,v)=>h+v[1],0))
    }
    return(!w[0]&&!w[1])?0:(w[0])?1:2
}

Démo :

l=(d,f)=>{for(t=[d,f].map(g=>g.split``.map(k=>[[25,100,10],[25,5,50]].map(m=>m[k.charCodeAt()-65])));(w=t.map(g=>g.some(k=>0<k[0])))[0]&&w[1];)t.forEach((g,k,m)=>m[k].sort(o=>0>o[0])[0][0]-=m[+!k].filter(o=>0<o[0]).reduce((o,p)=>o+p[1],0));return w[0]||w[1]?w[0]?1:2:0}

var prnt=(g,h)=>{
  n=l(g,h);
  return(n==0)?"Tie!":`Team ${n} wins!`
}

console.log("ABCB - ABC: " + prnt("ABCB","ABC"));
console.log("BAAA - BBC: " + prnt("BAAA","BBC"));
console.log("AAAA - BBC: " + prnt("AAAA","BBC"));
console.log("ABC - BBC: " + prnt("ABC","BBC"));
console.log("ABC - CBA: " + prnt("ABC","CBA"));