Tu tarea es simple: dime quién gana la batalla de las letras.

Las tropas

Hay tres "tropas" diferentes en esta batalla, resumidas en esta tabla.

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

Puede usar tres caracteres únicos para representar a las tropas, pero debe especificar si no son estas letras.

La batalla

Supongamos que tenemos una muestra de batalla:

ABC # army 1
CBA # army 2

Cada ejército dispara repetidamente a la unidad situada más a la izquierda, hasta que está muerta; luego se mueven hacia la tropa a la derecha y repiten. Entonces el ejército 2 ataca Aen el ejército 1 hasta que Aesté muerto, luego muévete a B, entonces C. El ejército 1 ataca Cprimero, luego B, luego A. Asuma que los ejércitos atacan al mismo tiempo, y así las tropas siempre dispararán si estaban vivas antes de la ronda y pueden matarse entre sí al mismo tiempo. Disparan en orden de izquierda a derecha.

La batalla se desarrollaría así:

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

¡Por lo tanto, el ejército 1 gana la batalla!

Entrada

Dos cadenas, la primera que representa el ejército 1 y la segunda ejército 2. No son necesariamente del mismo tamaño (porque ¿quién dijo que sería una pelea justa?)

Salida

Cualquiera de los tres valores únicos y constantes para representar el ejército 1 ganador, el ejército 2 ganador o el evento poco probable de un empate. Sí, es posible que las últimas tropas se maten entre sí, terminando en un empate.

Batallas

ABC
CBA
Army 1

CCCCC
CCCCC
Tie

CABCAB
ABBABBA
Army 2

Se aplican lagunas estándar . Debe enviar un programa completo.

Este es el código de golf , la solución más corta gana.

Pyth 145 97 bytes

=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 poco menos ingenuo que antes.

Pruébalo en línea!

Explicaciones:

Cortemos el programa en varias partes.

=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

El diccionario Yes: {'A': [25, 25], 'C': [10, 50], 'B': [100, 5]}. Entonces:

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

En este punto, Khay una lista de parejas que representa el primer ejército. Cada par de esta lista es una carta del ejército, y es (health, damage)para esa carta. Jes exactamente lo mismo, pero para el segundo ejército. ges una función que toma dos ejércitos y reparte el daño hecho por el segundo ejército al primero. Ahora:

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

Cuando termina el ciclo while, Ky Jtienen su valor final. Si ambos están vacíos, es un empate; de lo contrario, el ejército no vacío gana. Eso lo maneja el último código:

?K1?J2Z

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

¡Eso es!

Haskell , 199 193 179 176 171 bytes

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)

Pruébalo en línea!

Pequeño truco: divide todas las estadísticas del ejército por 5.

C #, 446 bytes

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

Versión formateada:

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

Salidas 1 si gana ejército1, 2 para ejército2 y 0 para empate

Javascript (ES6) - 316 269 ​​Bytes

Estoy seguro de que esto se puede jugar como el infierno, pero esto es lo que se me ocurrió :) ¡Sin embargo, logré reducir 47 bytes!

Salidas 0 para empate, 1 para el equipo 1 y 2 para el equipo 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}

Legible :

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
}

Demo :

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"));