Nel gioco Stratego, la meccanica di gioco principale è quando attacchi un pezzo dell'avversario con il tuo. In questa sfida, il tuo compito è simulare una di queste battaglie e dire chi sopravvive.

Specifiche

Otterrai come input una coppia di stringhe che rappresentano pezzi di Stratego. I pezzi sono uno dei "S 1 2 3 4 5 6 7 8 9 10 B"( Sè la spia e Bsono bombe). Il primo della coppia sarà l'attaccante, e il secondo sarà l'attaccante.

Ecco le regole per determinare i risultati di una battaglia:

• Il numero più alto batte il numero più basso: ["4", "6"] -> ["6"].
• Se entrambi sono gli stessi, allora entrambi dado: ["7", "7"] -> [].
• Le spie sono in fondo, al di sotto anche 1: ["S", "2"] -> ["2"].
• Tuttavia, se una spia attacca il 10, poi la spia vince: ["S", "10"] -> ["S"].
• Ma le normali regole si applicano ancora, se l' 10è quella di attaccare: ["10", "S"] -> ["10"].
• Semmai attacca una bomba, la bomba vince: ["5", "B"] -> ["B"].
• Tuttavia, un minatore (una 3), in grado di disinnescare una bomba: ["3", "B"] -> ["3"].
• Una bomba non sarà mai l'attaccante.
• Uno spotter (a 1), può attaccare usando il normale meccanismo, ma può anche provare a "indovinare" il rango dell'altro giocatore, che può essere indicato con qualsiasi notazione sana.
• Se si indovinano, l'altro pezzo muore: ["1(5)", "5"] -> ["1"].
• Se si sbaglia, non accade nulla: ["1(3)", "5"] -> ["1", "5"].
• Spotters può individuare bombe: ["1(B)", "B"] -> ["1"].

Questo è code-golf , quindi vince il codice più breve in byte !

(Puoi usare gli esempi lassù come casi di test, perché sono troppo pigro per metterli tutti insieme in un elenco).

Haskell, 131 byte

Questa soluzione ha la forma di una funzione infix #con typeString -> String -> String

L'input è accettato attraverso i due argomenti di stringa. Il formato per l'input dello spotter è 1 xdove xè l'ipotesi. L'output è dato come una stringa. Nel caso in cui entrambe le unità sopravvivano, la stringa restituita contiene entrambe separate da uno spazio.

Purtroppo la mia soluzione originale era stata risolta e la correzione mi costava pochi byte.

('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 byte

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 funzione prende l'attaccante, il difensore e facoltativamente l'ipotesi dello spotter (se l'attaccante è lo spotter) come argomenti. Restituisce un array contenente i pezzi live che rimangono.

Ungolfed

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]

dimostrazione

https://repl.it/C6Oz/2

Javascript ES6, 98 86 byte

(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

Accetta 3 argomenti (attaccante, difensore, ipotesi di spotter).

Esempi di esecuzione:

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 byte

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

Questa funzione accetta 3 argomenti: il primo è un attaccante, il secondo è usato per gli osservatori (la loro ipotesi) e il terzo è difensore.

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'icona della spada proviene da cliparts.co}}

TSQL, 162 124 byte

golfed:

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,@)))))

Ungolfed:

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,@)))))

Violino