Ihre Aufgabe ist einfach: Sagen Sie mir, wer den Kampf der Buchstaben gewinnt.

Die Truppen

Es gibt drei verschiedene "Truppen" in dieser Schlacht, die in dieser Tabelle zusammengefasst sind.

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

Sie können drei eindeutige Zeichen verwenden, um die Truppen darzustellen, müssen jedoch angeben, ob es sich nicht um diese Buchstaben handelt.

Der Kampf

Angenommen, wir haben eine Beispielschlacht:

ABC # army 1
CBA # army 2

Jede Armee schießt wiederholt auf die am weitesten links stehende Einheit, bis sie tot ist. dann bewegen sie sich zur Truppe rechts und wiederholen. Also greift Armee 2 Ain Armee 1 an, bis sie Atot ist, und bewegt sich Bdann zu C. Armee 1 greift Cdann zuerst an B, dann A. Angenommen, die Armeen greifen gleichzeitig an, und daher feuern die Truppen immer, wenn sie vor der Runde am Leben waren und sich gleichzeitig gegenseitig töten können. Sie feuern in der Reihenfolge von links nach rechts.

Die Schlacht würde so ablaufen:

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

Daher gewinnt Armee 1 die Schlacht!

Eingang

Zwei Saiten, die erste repräsentiert Armee 1 und die zweite Armee 2. Sie sind nicht unbedingt gleich groß (denn wer hat gesagt, dass es ein fairer Kampf wäre?)

Ausgabe

Drei eindeutige, konstante Werte, die den Gewinn von Armee 1, den Gewinn von Armee 2 oder das unwahrscheinliche Ereignis eines Unentschieden darstellen. Ja, es ist möglich, dass sich die letzten Truppen gegenseitig töten und mit einem Unentschieden enden.

Kämpfe

ABC
CBA
Army 1

CCCCC
CCCCC
Tie

CABCAB
ABBABBA
Army 2

Es gelten Standardlücken . Sie müssen ein vollständiges Programm einreichen.

Dies ist Code-Golf , kürzeste Lösung gewinnt.

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

Ein bisschen weniger naiv als zuvor.

Probieren Sie es online aus!

Erklärungen:

Lassen Sie uns das Programm in mehrere Teile schneiden.

=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

Das Wörterbuch Ylautet : {'A': [25, 25], 'C': [10, 50], 'B': [100, 5]}. Dann:

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

An dieser Stelle Kbefindet sich eine Liste von Paaren, die die erste Armee darstellt. Jedes Paar dieser Liste ist ein Brief der Armee und ist (health, damage)für diesen Brief. Jist genau das gleiche, aber für die zweite Armee. gist eine Funktion, die zwei Armeen nimmt und der ersten den von der zweiten Armee verursachten Schaden zufügt. Jetzt:

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

Wenn die while - Schleife zu Ende ist, Kund Jderen Endwert haben. Wenn beide leer sind, ist es ein Unentschieden; sonst gewinnt die nicht leere Armee. Das erledigt der letzte Code:

?K1?J2Z

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

Das ist 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)

Probieren Sie es online aus!

Kleiner Trick: Teilen Sie alle Armeestatistiken durch 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;};

Formatierte Version:

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

Gibt 1 aus, wenn Armee1 gewinnt, 2 für Armee2 und 0 für Unentschieden

Javascript (ES6) - 316 269 ​​Bytes

Ich bin mir sicher, dass dies höllisch gespielt werden kann, aber das habe ich mir ausgedacht :) Ich habe es geschafft, 47 Bytes zu sparen!

Ausgabe 0 für Unentschieden, 1 für Team 1 und 2 für Team 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}

Lesbar :

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