Contexte historique

Le mur de bouclier est une formation de guerre tactique qui remonte à au moins 2500 avant JC. Il se composait de guerriers chevauchant leurs boucliers avec ceux de leurs compagnons pour former un «mur». L'attrait de la tactique vient du fait que même le guerrier le moins qualifié peut se battre dans un mur tant qu'il a un bouclier et une arme. En raison de la proximité des murs, il y avait peu d'espace pour se déplacer, et la bataille devenait généralement une allumette de combat menée avec des armes tranchantes.

Le défi

Votre tâche consiste à créer un programme ou une fonction qui, étant donné deux tableaux / listes / vecteurs de guerriers en entrée, décide du résultat de la bataille. Les listes représenteront un mur de boucliers sur une seule ligne, et elles suivront une notation spécifique:

Vikings:

Les guerriers nordiques avaient une féroce volonté de bataille. De la fin du VIIIe au milieu du XIe siècle, les vikings danois ont envahi les royaumes de Grande-Bretagne à la recherche de richesses et de terres cultivables. Aux fins de ce défi, ce sont les guerriers vikings:

• L' Jarl: Habituellement trouvés conduisant ses hommes du centre du mur, les jarls étaient les chefs des hordes vikings. Prend 15 dégâts pour mourir et inflige 2 dégâts par round.
• L' Berserker: Bien que la fantaisie ait considérablement tordu l'image des berserkers, ces guerriers étaient connus pour se battre dans une fureur de transe sans aucune autre protection que leurs boucliers. Prend 6 dégâts pour mourir et inflige 3 dégâts par round.
• Le Cchef: Les chefs étaient des hommes riches qui avaient des hommes libres à leur service. Ils avaient généralement gagné une grande gloire et des richesses au combat. Prend 10 dégâts pour mourir et inflige 2 dégâts par round.
• The Free Men: Warriors qui a servi un chef. Ils ont juré de se battre pour leurs seigneurs jusqu'à la mort. Prend 8 dégâts pour mourir et inflige 1 dégât par round.
• Le Skald: Les skalds, généralement traduits par des bardes, étaient des hommes libres qui étaient embauchés pour écrire des poèmes, des histoires ou des chansons sur les grandes actions des guerriers nordiques. Prend 8 dégâts pour mourir et donne à chaque guerrier adjacent 1 bonus supplémentaire. Les Skalds n'infligent aucun dégât. Les guerriers ne peuvent pas gagner plus d'un bonus de dégâts de cette façon.

Saxons:

Les Saxons sont venus s'installer en Grande-Bretagne à partir de l'Europe continentale après la disparition de l'Empire romain au Ve siècle. Aux fins de ce défi, il y a les guerriers des saxons:

• L' Earl: les Ealdormen , communément appelés comtes, faisaient partie de la noblesse supérieure. Ils détenaient généralement de grandes étendues de terre et avaient des centaines voire des milliers d'hommes assermentés. Prend 20 dégâts pour mourir et inflige 1 dégât par round.
• La Knuit: Faute d'un meilleur terme, les chevaliers étaient des nobles mineurs qui possédaient des terres. Dans la plupart des cas, les chevaliers étaient des serviteurs jurés d'un comte. Prend 10 dégâts pour mourir et inflige 2 dégâts par round.
• L' Warrior: des hommes ordinaires, généralement des nobles mineurs sans terre ou des paysans qui ont servi un chevalier. Lorsqu'ils sont adjacents à un chevalier ou un comte, les guerriers bénéficient d'un bonus de dégâts de +1. Prend 8 dégâts pour mourir et inflige 2 dégâts par round.
• Le Fyrd: Le Fyrd était un groupe d'hommes libres semblable à des milices, généralement des fermiers pauvres, qui apportaient n'importe quelle arme (ou instrument agricole semblable à une arme) qu'ils devaient combattre dans le mur. Prend 5 dégâts pour mourir et inflige 1 dégât par round.
• Le Pplus: les prêtres étaient très appréciés dans la première culture saxonne, étant des hérauts des paroles de Dieu. Les prêtres subissent 15 dégâts pour mourir et préviennent jusqu'à 1 dégât chaque guerrier adjacent serait infligé. Les prêtres n'infligent aucun dégât. Les prêtres ne peuvent pas empêcher plus d'un dégât infligé à un guerrier.

Le mur

Les murs se rencontrent dans leurs centres. Chaque tour, chaque guerrier attribue des dégâts au guerrier directement devant lui ou, s'il n'y a pas de guerrier vivant devant lui, le guerrier vivant adjacent en diagonale avec le moins de points de vie restants. S'il y a une cravate, choisissez le guerrier plus près du bord du mur.

Exemple:

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.

Règles:

• Les échappatoires par défaut s'appliquent.
• Vous pouvez utiliser n'importe quelle méthode IO pratique .
• C'est le code-golf , donc le code le plus court (en octets, par langue) gagne.
• Vous ne pouvez pas supposer que les listes auront la même longueur, mais elles seront toujours alignables en leur centre (il y aura toujours un nombre impair de guerriers dans chaque liste si les listes sont de tailles différentes).
• Vous pouvez afficher n'importe quelle valeur de vérité / falsey. Veuillez préciser dans votre réponse les équivalents de "victoire viking / saxonne".
• Le perdant est déterminé lorsque tous les guerriers d'un mur sont morts.

• Si vous vous retrouvez avec des murs qui ne sont pas alignables pendant l'exécution du code, alignez-les le plus central possible, en laissant un guerrier supplémentaire sur le mur le plus long du côté droit. Par exemple:

    [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]
  

• N'hésitez pas à essayer et tester votre code avec n'importe quelle configuration de murs, pas seulement ceux des cas de test.

Cas de test:

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.)
------------------------------

Il y a quelques inexactitudes historiques. N'hésitez pas à les signaler et je ferai de mon mieux pour les corriger.

Python 2 , 576 573 565 554 540 549 octets

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'

Essayez-le en ligne!

APL (Dyalog Classic) , 128 octets

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

Essayez-le en ligne!

Il existe deux fonctions dans le lien TIO: gla fonction fgolfée ci-dessus est une fonction non golfée qui accepte une paire de chaînes, les convertit en une représentation appropriée et appelle la fonction golfée.

L'entrée est constituée de cinq matrices: les ttypes de guerriers sous forme d'entiers; lla vie; ddommage; bquels types de guerriers donnent un bonus lorsqu'ils sont adjacents; pidem pour la protection. Les matrices se composent de deux rangées - Vikings et Saxons. Si leurs guerriers ne sont pas du même nombre, les matrices doivent être remplies de 0, mais pas nécessairement centrées. Le résultat est 1/ ¯1pour la victoire Viking / Saxon ou 0pour un match nul.

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