Dans le jeu Stratego, le mécanisme de jeu principal consiste à attaquer la pièce d'un adversaire avec la vôtre. Dans ce défi, votre travail consiste à simuler l'une de ces batailles et à dire qui survit.

Spécifications

Vous obtiendrez en entrée une paire de cordes représentant des pièces Stratego. Les pièces sont l'une des "S 1 2 3 4 5 6 7 8 9 10 B"( Sest l'espion, et Bsont des bombes). Le premier de la paire sera l'attaquant et le second l'attaquant.

Voici les règles pour déterminer les résultats d'une bataille:

• Le plus grand nombre bat le nombre inférieur: ["4", "6"] -> ["6"].
• Si les deux sont identiques, meurent tous les deux: ["7", "7"] -> [].
• Spies sont en bas, au- dessous même 1: ["S", "2"] -> ["2"].
• Cependant, si un espion attaque le 10, l'espion gagne: ["S", "10"] -> ["S"].
• Mais les règles normales appliquent toujours si le 10est celui attaquant: ["10", "S"] -> ["10"].
• Si quelque chose attaque une bombe, la bombe gagne: ["5", "B"] -> ["B"].
• Toutefois, un mineur (a 3), peut désamorcer une bombe: ["3", "B"] -> ["3"].
• Une bombe ne sera jamais l'attaquant.
• Un observateur (a 1) peut attaquer en utilisant le mécanisme normal, mais il peut également essayer de "deviner" le rang de l'autre joueur, qui peut être indiqué par n'importe quelle notation saine.
• S'ils devinent correctement, l'autre pièce meurt: ["1(5)", "5"] -> ["1"].
• S'ils devinent mal, rien ne se passe: ["1(3)", "5"] -> ["1", "5"].
• Spotters peuvent repérer les bombes: ["1(B)", "B"] -> ["1"].

C'est le code-golf , donc le code le plus court en octets gagne!

(Vous pouvez utiliser les exemples là-haut comme cas de test, car je suis trop paresseux pour les rassembler dans une seule liste).

Haskell, 131 octets

Cette solution se présente sous la forme d'une fonction infixe #de typeString -> String -> String

L'entrée est acceptée via les deux arguments de chaîne. Le format de l'entrée du spotter est 1 xoù xest la supposition. La sortie est donnée sous forme de chaîne. Dans le cas où les deux unités survivent, la chaîne retournée contient les deux séparées par un espace.

Ma solution d'origine a malheureusement été buggée et le correctif m'a coûté quelques octets.

('1':' ':x)#y|x==y="1"|1>0="1 "++y
"S"#"10"="S"
"3"#"B"="3"
_#"B"="B"
x#y|x==y=[]
t@"10"#_=t
_#t@"10"=t
"S"#x=x
x#"S"=x
x#y=max x y

Python, 180 153 octets

def f(a,d,g=0):T=([[d]],[[a]]);return([[a]+[d]*(g!=d)]*(g!=0)+[[]]*(a==d)+T[d=="10"]*(a=="S")+T[1]*(d=="S")+T[a=="3"]*(d=="B")+T[int(a,36)>int(d,36)])[0]

La fonction prend l'attaquant, le défenseur et éventuellement la supposition du spotter (si l'attaquant est le spotter) comme arguments. Il renvoie un tableau contenant les morceaux vivants qui restent.

Non golfé

def f(a,d,g=0):
 if g: return [a] if g==d else [a,d]
 if a==d: return []
 if a=="S": return [a] if d=="10" else [d]
 if d=="S": return[a]
 if d=="B": return [a] if a=="3" else [d]
 return [a] if int(a)>int(d) else [d]

Démo

https://repl.it/C6Oz/2

Javascript ES6, 98 86 octets

(a,b,g)=>a==1?b==g?a:[a,b]:b=="B"?a==3?a:b:a=="S"?b==10?a:b:b=="S"?a:a==b?[]:+a>+b?a:b

Accepte 3 arguments (attaquant, défenseur, devineur).

L'exemple s'exécute:

f("4","6")     -> "6"
f("7","7")     -> []
f("S","2")     -> "2"
f("S","10")    -> "S"
f("10","S")    -> "10"
f("5","B")     -> "B"
f("3","B")     -> "3"
f("1","5","5") -> "1"
f("1","5","3") -> ["1","5"]
f("1","B","B") -> "1"

Javascript, 179 166 160 octets

f=(a,c,b,n="")=>{if(c)if(c==b)return[a];else return[a,b];if(a==b)return[];a+b=="3B"&&(b=n);a=b=="B"?n:a;b=b=="S"?n:b;a+b=="S10"&&(a=n,b="S");return[+a>+b?a:b]}

Cette fonction prend 3 arguments - le premier est l'attaquant, le second est utilisé pour les spotters (leur supposition) et le troisième est le défenseur.

f = ( a, c, b, n = "" ) =>
{
	//Takes attacker (a), guess (c) and defender (b), n is only declaration
	//c should never be set unless a == 1 
	if ( c )
		if ( c == b ) return [ a ];
		else return[ a, b ]; //Spotters
	
	if( a == b ) return [ ]; //Kill each other if same

	a + b == "3B" && ( b = n ); //Miners destroy bombs
	a = b == "B" ? n : a; //Bomb kills almost everything
	b = b == "S" ? n : b; //Spy dies if anything attacks him
	a + b == "S10" && ( a = n, b = "S" ); //Spies kill 10s

	console.log( JSON.stringify( [a,b] ) );

	return [ +a > +b ? a : b ] //Higher number wins
}

function fight( )
{
	var input = [ [ attacker.value, guess.value], defender.value ];
	out.innerHTML += JSON.stringify( input ) + "   ->   " + JSON.stringify( f( input[0][0], input[0][1], input[1] ) ) + "<br>";
}

#sword
{
	width: 40px;
	height: auto;
	margin: 10px;
	cursor: pointer;
	
}

#guess
{
	width: 40px;
}

textarea
{
	height: 20px;
	margin-top: 0px;
}

.panel
{
	background-color: #DDDDDD;
	padding: 5px;
	border: 3px solid black;
}

#out
{
	border: 3px solid black;
	font-family: monospace;
	padding: 10px;
}

<table>
	<tr>
		<td class=panel>
			<textarea id=attacker placeholder="Attacker"></textarea>
			<textarea id=guess></textarea>
		</td>
		
		<td>
			<img onclick="fight()" id=sword src="http://cliparts.co/cliparts/8cx/Kjq/8cxKjqAKi.png"></img>
		</td>
		
		<td class=panel>
			<textarea id=defender placeholder="Defender"></textarea>
		</td>
	</tr>
		
	<tr>
		<td colspan=3>
			<div id=out></div>
		</td>
	</tr>
</table>

_{^{L'icône d'épée vient de cliparts.co}}

TSQL, 162 124 octets

Golfé:

DECLARE @1 varchar(2)='1',@ varchar(2)='3',@s varchar(2)='4'

PRINT IIF(@s>'',IIF(@=@s,@1,@1+','+@),IIF(@1=@,'',IIF(@1+@
IN('S10','3B')or'S'=@,@1,IIF(@='B'or'S'=@1,@,IIF(@1/1<@,@1,@)))))

Non golfé:

DECLARE 
  @1 varchar(2)='1', -- first piece
  @  varchar(2)='3',  -- second piece
  @s varchar(2)='4'  -- spotter(only fill this value for spotters)

PRINT
  IIF(@s>'',
    IIF(@=@s,@1,@1+','+@),
      IIF(@1=@,'',
        IIF(@1+@ IN('S10','3B')or'S'=@,@1,
          IIF(@='B'or'S'=@1,@,
            IIF(@1/1<@,@1,@)))))

Violon