Historischer Hintergrund

Die Schildmauer ist eine taktische Kriegsformation, die mindestens 2500 v. Chr. Zurückreicht. Es bestand aus Kriegern, die ihre Schilde mit denen ihrer Gefährten überlappten, um eine "Mauer" zu bilden. Der Reiz der Taktik beruht auf der Tatsache, dass selbst der unerfahrenste Krieger in einer Mauer kämpfen kann, solange er einen Schild und eine Waffe hat. Aufgrund der Nähe der Mauern gab es nur wenig Raum, um sich zu bewegen, und die Schlacht wurde in der Regel zu einem Schubser, der mit scharfen Waffen ausgetragen wurde.

Die Herausforderung

Ihre Aufgabe ist es, ein Programm oder eine Funktion zu erstellen, die bei zwei Feldern / Listen / Vektoren von Kriegern als Eingabe über den Ausgang des Kampfes entscheidet. Die Listen stellen eine einzeilige Wand aus Schilden dar und folgen einer bestimmten Notation:

Wikinger:

Die nordischen Krieger hatten einen heftigen Kampfdrang. Während des späten 8. bis mittleren 11. Jahrhunderts drangen dänische Wikinger in die Königreiche Großbritanniens ein und suchten nach Reichtum und Ackerland. Für diese Herausforderung sind dies die Krieger der Wikinger:

• Der JArl: Normalerweise führte er seine Männer von der Mitte der Mauer aus, die Krüge waren die Anführer der Wikingerhorden. Erleidet 15 Schaden und fügt 2 Schaden pro Runde zu.
• Der BWutausbruch: Obwohl die Fantasie das Image der Wutausbrüche stark verändert hat, war bekannt, dass diese Krieger in tranceähnlicher Wut kämpfen, ohne jeglichen Schutz außer ihren Schilden. Erleidet 6 Schaden und fügt 3 Schaden pro Runde zu.
• Der CHäuptling: Häuptlinge waren reiche Männer, denen freie Männer zur Verfügung standen. Normalerweise hätten sie sich im Kampf großen Ruhm und Reichtum verdient. Erleidet 10 Schaden und fügt 2 Schaden pro Runde zu.
• The Free Mde: Warriors, die einem Häuptling gedient haben. Sie wurden geschworen, bis zum Tod für ihre Herren zu kämpfen. Erleidet 8 Schaden und fügt 1 Schaden pro Runde zu.
• The Skald: Skalds, normalerweise übersetzt als Barden, waren freie Männer, die angestellt wurden, um Gedichte, Geschichten oder Lieder über die großen Taten der nordischen Krieger zu schreiben. Erleidet 8 Schaden und fügt jedem angrenzenden Krieger 1 Schadensbonus zu. Skalds verursachen keinen Schaden. Krieger können auf diese Weise nicht mehr als 1 Bonusschaden erhalten.

Sachsen:

Nach dem Untergang des Römischen Reiches im 5. Jahrhundert ließen sich die Sachsen von Kontinentaleuropa aus in Großbritannien nieder. Für die Zwecke dieser Herausforderung gibt es die Sachsen-Krieger:

• Die Earl: Ealdormen , im Volksmund Earls genannt, gehörten dem höheren Adel an. Sie besaßen normalerweise große Landstriche und hatten Hunderte oder sogar Tausende von vereidigten Männern. Erleidet 20 Schaden und verursacht 1 Schaden pro Runde.
• Die KNacht: Mangels eines besseren Ausdrucks waren die Ritter minderjährige Adlige, die etwas Land besaßen. In den meisten Fällen waren Ritter Diener eines Grafen. Erleidet 10 Schaden und fügt 2 Schaden pro Runde zu.
• Der WArrior: Gewöhnliche Männer, normalerweise kleine Adlige ohne Land oder Bauern, die einem Ritter gedient haben. Krieger, die sich neben einem Ritter oder Grafen befinden, erhalten einen Schadensbonus von +1. Erleidet 8 Schaden und fügt 2 Schaden pro Runde zu.
• Der FDritte: Der Fyrd war eine milizähnliche Gruppe freier Männer, normalerweise arme Bauern, die Waffen (oder waffenähnliche landwirtschaftliche Geräte) mitbrachten, die sie in der Mauer bekämpfen mussten. Erleidet 5 Schaden und fügt 1 Schaden pro Runde zu.
• Das PHöchste: Priester wurden in der frühsächsischen Kultur als Verkünder der Worte Gottes hoch geschätzt. Priester erleiden 15 Schaden und verhindern bis zu 1 Schaden, den jeder benachbarte Krieger erleiden würde. Priester verursachen keinen Schaden. Priester können einem Krieger nicht mehr als 1 Schaden ersparen.

Die Wand

Wände treffen sich in ihren Zentren. In jeder Runde fügt jeder Krieger dem direkt davor stehenden Krieger Schaden zu oder, falls sich kein lebender Krieger davor befindet, dem diagonal angrenzenden lebenden Krieger mit der geringsten verbleibenden Gesundheit. Wenn es ein Unentschieden gibt, wählen Sie den Krieger näher am Rand der Wand.

Beispiel:

Vikings
[M,M,M,B,B,C,J,C,B,B,M,M,M]
[F,F,F,W,W,K,E,K,W,W,F,F,F]
Saxons

To make matters easier, let's convert these walls into numbers:
Round 0:
 M M M B B C  J  C  B B M M M
[8,8,8,6,6,10,15,10,6,6,8,8,8]
[5,5,5,8,8,10,20,10,8,8,5,5,5]
 F F F W W K  E  K  W W F F F

Round 1: Notice that 2 of the Saxons' warriors are adjacent to Knights, so they have a +1 damage bonus.
 M M M B B C J  C B B M M M
[7,7,7,4,3,8,14,8,3,4,7,7,7]
 | | | | | | || | | | | | |
[4,4,4,5,5,8,18,8,5,5,4,4,4]
 F F F W W K E  K W W F F F

Round 2: 
 M M M B B C J  C B B M M M
[6,6,6,2,0,6,13,6,0,2,6,6,6]
 | | | | | | || | | | | | |
[3,3,3,2,2,6,16,6,2,2,3,3,3]
 F F F W W K E  K W W F F F

Round 3: Remember to collapse the arrays to account for dead warriors. Also, notice that the 2 outermost Fyrd are now attacking the diagonally adjacent viking. 
   M M M B C J  C B M M M
  [4,5,4,0,4,12,4,0,4,5,4]
  /| | | | | || | | | | |\
[2,2,2,1,0,4,14,4,0,1,2,2,2]
 F F F W W K E  K W W F F F

Round 4: Notice once again the saxon Warriors next to the Knights dealing 3 damage:
   M M M C J  C M M M
  [2,4,1,2,11,2,1,4,2]
  /| | | | || | | | |\
[2,1,1,0,2,12,2,0,1,1,2]
 F F F W K E  K W F F F
Round 5:
 M M M C J  C M M M
[1,3,0,0,10,0,0,3,1]
 | | | | || | | | |
[1,0,0,0,10,0,0,0,1]
 F F F K E  K F F F

Round 6: 
    M M J M M
   [1,2,9,2,1]
     \| | |/   
     [0,8,0]
      F E F
Rounds 7 and 8:
      M M J M M         M M J M M
     [1,2,8,2,1]       [1,2,8,2,1]
         \|/               \|/ 
         [4]               [0]
          E                 E  

Output: Viking victory.

Regeln:

• Es gelten Standardlücken .
• Sie können jede bequeme E / A-Methode verwenden .
• Dies ist Code-Golf , also gewinnt der kürzeste Code (in Bytes pro Sprache).
• Sie können davon ausgehen, dass die Listen nicht die gleiche Länge haben, sie sind jedoch immer in ihrer Mitte ausrichtbar (es gibt immer eine ungerade Anzahl von Kriegern in jeder Liste, wenn die Listen unterschiedlich groß sind).
• Sie können jeden Wahrheits- / Falschwert ausgeben. Bitte geben Sie in Ihrer Antwort die Entsprechungen von "Viking / Saxon victory" an.
• Der Verlierer wird bestimmt, wenn alle Krieger einer Mauer tot sind.

• Wenn Sie jemals Wände haben, die während der Codeausführung nicht ausgerichtet werden können, richten Sie sie so zentral wie möglich aus, sodass ein zusätzlicher Krieger an der längeren Wand auf der rechten Seite verbleibt. Z.B:

    [M,M,M,J,M,M,M]
      [K,E,K,W];
  
        [B,B,B,J]    
  [K,K,W,W,K,E,K,W,W,K,K]
  

• Sie können Ihren Code auch mit einer beliebigen Konfiguration von Wänden testen, nicht nur mit denen in den Testfällen.

Testfälle:

V: [M,M,B,C,B,C,J,C,B,C,B,M,M]
S: [F,F,W,K,W,K,E,K,W,K,W,F,F]
O: Viking victory.
------------------------------
V: [M,M,M,M,M,M,M,M,M,M]
S: [W,W,W,W,W,W,W,W,W,W]
O: Saxon victory.
------------------------------
V: [B,C,M,B,C,M,M,C,B,M,C,B,M]
S:   [W,F,W,F,E,E,E,F,W,F,W]
O: Viking victory.
------------------------------
V:         [B,B,B,J,B,B,B]
S: [W,W,W,W,K,K,K,E,K,K,K,W,W,W,W]
O: Saxon victory.
------------------------------
V: [J]
S: [E]
O: Viking victory.
------------------------------
V: [C,C,C,C,B,B,M,M,M,M,J,J,J,M,M,M,M,B,B,C,C,C,C]
S: [K,K,K,K,K,K,K,K,K,K,W,E,W,K,K,K,K,K,K,K,K,K,K]
O: Saxon victory.
------------------------------
V: [M,M,S,C,B,J,B,C,S,M,M]
S: [F,K,P,W,K,E,K,W,P,K,F]
O: Saxon victory.
------------------------------
V: [S,S,S,...,S]
S: [P,P,P,...,P]
O: UNDEFINED (since both priests and skalds deal no damage, you can output anything here.)
------------------------------

Es gibt einige historische Ungenauigkeiten. Fühlen Sie sich frei, sie darauf hinzuweisen, und ich werde mein Bestes tun, um sie zu beheben.

Python 2 , 576 573 565 554 540 549 Bytes

O=[(0,0)]
g=lambda D,W,i:D[i-1]*(W[i-1]<1)+D[i]+D[i+1]*(W[i+1]<1)
h=lambda*V:[v for v in zip(*V)if v[1]>0]
def f(v,s):
 l,L=len(v),len(s);m=max(l,L);a,b=(L-l)/2,(l-L)/2;V,U=zip(*O+O*a+v+O*a+O+O);S,T=zip(*O+O*b+s+O*b+O+O);z=[0]*(m+2);w=z[:];r=range(1,m+1);U=list(U);T=list(T)
 for i in r:w[i]=[0,2,3,2,1,0][V[i]]+(5in V[i-1:i+2:2])*(V[i]<5);z[i]=[0,1,2,2+({1,2}&set(S[i-1:i+2:2])>set()),1,0][S[i]]
 for i in r:U[i]-=g(z,V,i);d=g(w,S,i);T[i]-=d-(d>0)*(5in S[i-1:i+2:2])
 V=h(V,U);S=h(S,T)
 if([],[])<(V,S)!=(v,s):return(f(V,S)if S else'V')if V else'S'

Probieren Sie es online!

APL (Dyalog Classic) , 128 Byte

{t l d b p←(-⌊2÷⍨+/0=⊃⍵)∘⌽¨⍵⋄l+←e+3+/0,0,⍨(0=t)×e←(×≢¨p∩¨h)-⊖d+×≢¨b∩¨h←3,/0,t,0⋄⍵≡a←↑¨(⊂↓l>0)/¨¨↓¨t l d b p:0⋄0∊s←+/l>0:×-/s⋄∇a}

Probieren Sie es online!

Es gibt zwei Funktionen in der TIO-Verknüpfung: gIst die oben genannte Golffunktion und fist eine Funktion ohne Golf, die ein Saitenpaar akzeptiert, diese in eine geeignete Darstellung umwandelt und die Golffunktion aufruft.

Die Eingabe besteht aus fünf Matrizen: tKriegertypen als Ints; lLeben; dBeschädigung; bWelche Kriegertypen geben einen Bonus, wenn sie nebeneinander stehen? pGleiches gilt für den Schutz. Die Matrizen bestehen aus zwei Reihen - Wikinger und Sachsen. Wenn ihre Krieger nicht die gleiche Anzahl haben, müssen die Matrizen mit 0 aufgefüllt werden, müssen aber nicht unbedingt zentriert sein. Das Ergebnis ist 1/ ¯1für Viking / Saxon Sieg oder 0für ein Unentschieden.

{
  t l d b p←(-⌊2÷⍨+/0=⊃⍵)∘⌽¨⍵ ⍝ centre the matrices
  ⍝ (-⌊2÷⍨+/0=⊃⍵) is a pair of numbers - by how much we should rotate (⌽) the rows
  ⍝       +/0=⊃⍵  how many dead? (⊃⍵ is the types, dead warriors have type 0)
  ⍝  -⌊2÷⍨        negated floor of half

  l+←e+3+/0,0,⍨(0=t)×e←(×≢¨p∩¨h)-⊖d+×≢¨b∩¨h←3,/0,t,0 ⍝ compute and apply effective damage
  ⍝ h←3,/0,t,0  are triples of types - self and the two neighbours
  ⍝ b∩¨h        for each warrior intersect (∩) h with his bonus-giving set b
  ⍝ ×≢¨         non-empty? 0 or 1
  ⍝ d+          add to the damage normally inflicted
  ⍝ ⊖           reverse vertically (harm the enemy, not self)
  ⍝ (×≢¨p∩¨h)   same technique for protections (neighbouring priests)
  ⍝ e←          remember as "e" for "effective damage"; we still need to do the diagonal attacks
  ⍝ (0=t)×      zero out the attacks on living warriors
  ⍝ 3+/0,0,⍨    sum triples - each warrior suffers the damage intended for his dead neigbours
  ⍝ e+          add that to the effective damage
  ⍝ l+←         decrease life ("e" is actually negative)

  ⍵≡a←↑¨(⊂↓l>0)/¨¨↓¨t l d b p:0 ⍝ remove dead; if no data changed, it's a draw
  ⍝ ↓¨          split each matrix into two row-vectors
  ⍝ (⊂↓l>0)     boolean mask of warrios with any life left, split in two and enclosed
  ⍝ /¨¨         keep only the survivors
  ⍝ ↑¨          mix the pairs of rows into matrices again, implicitly padding with 0-s
  ⍝ a←          call that "a" - our new arguments
  ⍝ ⍵≡a ... :0  is "a" the same as our original arguments? - nothing's changed, it's a draw

  0∊s←+/l>0:×-/s ⍝ if one team has no members left, they lost
  ⍝ l>0         bitmask of survivors
  ⍝ s←+/l>0     how many in each camp
  ⍝ 0∊          has any of the two armies been annihilated?
  ⍝ :×-/s       if yes, which one? return sign of the difference: ¯1 or 1, or maybe 0

  ∇a ⍝ repeat
}