Im Spiel Stratego ist die Hauptspielmechanik, wenn Sie die Figur eines Gegners mit Ihrer angreifen. Bei dieser Herausforderung besteht Ihre Aufgabe darin, eine dieser Schlachten zu simulieren und zu sagen, wer überlebt.

Technische Daten

Sie erhalten als Eingabe ein Zeichenfolgenpaar, das Strategostücke darstellt. Die Stücke sind eines von "S 1 2 3 4 5 6 7 8 9 10 B"( Sist der Spion und Bsind Bomben). Der erste des Paares ist der Angreifer und der zweite der Angreifer.

Hier sind die Regeln zur Bestimmung der Ergebnisse eines Kampfes:

• Die höhere Zahl schlägt die niedrigere Zahl : ["4", "6"] -> ["6"].
• Wenn beide gleich sind, sterben beide : ["7", "7"] -> [].
• Spione sind unten, darunter sogar 1: ["S", "2"] -> ["2"].
• Wenn jedoch ein Spion den angreift 10, gewinnt der Spion : ["S", "10"] -> ["S"].
• Es gelten jedoch weiterhin die normalen Regeln, wenn 10derjenige angreift : ["10", "S"] -> ["10"].
• Wenn etwas eine Bombe angreift, gewinnt die Bombe : ["5", "B"] -> ["B"].
• Ein Bergmann (a 3) kann jedoch eine Bombe entschärfen : ["3", "B"] -> ["3"].
• Eine Bombe wird niemals der Angreifer sein.
• Ein Spotter (a 1) kann mit dem normalen Mechanismus angreifen, aber er kann auch versuchen, den Rang des anderen Spielers zu "erraten", was mit jeder vernünftigen Notation angegeben werden kann.
• Wenn sie richtig raten, stirbt das andere Stück : ["1(5)", "5"] -> ["1"].
• Wenn sie falsch raten, passiert nichts : ["1(3)", "5"] -> ["1", "5"].
• Spotter können Bomben erkennen : ["1(B)", "B"] -> ["1"].

Dies ist Code-Golf , also gewinnt der kürzeste Code in Bytes !

(Sie können die Beispiele dort oben als Testfälle verwenden, da ich zu faul bin, um sie alle in einer Liste zusammenzufassen.)

Haskell, 131 Bytes

Diese Lösung hat die Form einer Infix-Funktion #mit TypString -> String -> String

Die Eingabe wird über die beiden Zeichenfolgenargumente akzeptiert. Das Format für die Spotter-Eingabe ist, 1 xwo xdie Vermutung ist. Die Ausgabe wird als Zeichenfolge angegeben. Wenn beide Einheiten überleben, enthält die zurückgegebene Zeichenfolge beide durch ein Leerzeichen getrennt.

Meine ursprüngliche Lösung war leider fehlerhaft und der Fix hat mich ein paar Bytes gekostet.

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

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]

Die Funktion verwendet den Angreifer, den Verteidiger und optional die Vermutung des Spotters (wenn der Angreifer der Spotter ist) als Argumente. Es gibt ein Array zurück, das die verbleibenden Live-Teile enthält.

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]

Demo

https://repl.it/C6Oz/2

Javascript ES6, 98 86 Bytes

(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

Akzeptiert 3 Argumente (Angreifer, Verteidiger, Spotter-Vermutung).

Beispielläufe:

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 Bytes

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

Diese Funktion benötigt 3 Argumente - das erste ist Angreifer, das zweite wird für Spotter verwendet (ihre Vermutung) und das dritte ist Verteidiger.

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>

_{^{Das Schwertsymbol stammt von cliparts.co}}

TSQL, 162 124 Bytes

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

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

Geige