Finde das Ergebnis eines Kriegsspiels

Als ich in der Grundschule war, gab es ein "Rock-Paper-Scissors" -Spiel, das wir während der Versammlungen spielten, wenn wir auf unseren Lehrer warteten, in der Pause usw. Wir nannten es "Krieg". Nach einigem Suchen stellt sich jedoch heraus, dass dies eine viel einfachere Variante des "Shotgun Game" ist (laut WikiHow) . Ich werde es "Krieg" nennen, da die Regeln etwas anders sind:

2 Personen sitzen sich gegenüber. Das Ziel des Spiels ist es, den anderen Spieler zu "töten". In jeder Runde kannst du einen von 3 Zügen spielen:

• Nachladen : Sie haben eine Waffe, die einen einzigen Schuss hält. Es muss neu geladen werden, bevor es jedes Mal abgefeuert werden kann. Nachladen, wenn Sie bereits Munition haben, ist legal, tut aber nichts. Ein Nachladen wurde symbolisiert, indem man mit beiden Händen auf die Schläfen tippte. Jeder Spieler beginnt mit 0 Munition.

• Wache : Der einzige sichere Zug. Wenn Sie während der Bewachung erschossen werden, sterben Sie nicht. Die Bewachung wurde durch das Kreuzen der Arme über der Brust symbolisiert.

• Feuer : Feuer deine Waffe. Um erfolgreich zu feuern, müssen Sie seit dem letzten Schuss neu geladen haben. Wenn dein Gegner nachlädt, gewinnst du. Wenn sie auch schießen und Sie beide Munition haben, ist es ein Unentschieden. Wenn sie Wache halten, haben Sie die Munition verschwendet. Ohne Munition zu schießen ist zwar ein legaler Schritt, aber es macht nichts und macht Sie angreifbar wie das Nachladen. Das Feuern wurde symbolisiert, indem auf den anderen Spieler gezeigt wurde.

Es wurde ähnlich wie RPS gespielt, da jeder Spieler gleichzeitig seine Wahl fallen lässt (wir haben zwischen den Zügen zweimal mit den Beinen getippt, um im Rhythmus miteinander zu bleiben, aber das ist für die Herausforderung nicht wichtig).

Die Herausforderung:

Ihre Aufgabe ist es, das Ergebnis eines Kriegsspiels zu finden. Dies kann eine Funktion oder ein vollständiges Programm sein.

Eingang

• Die Option, die jeder Spieler in jeder Runde gewählt hat, wird durch ein Zeichen / eine Zeichenkette dargestellt:

  • r : neu laden

  • g : Wache

  • f : Feuer

• Die Eingabe ist eine Liste von Paaren, eine begrenzte / nicht begrenzte Zeichenfolge oder irgendetwas anderes in dieser Richtung.

Ein Beispiel für eine Eingabe in Python ist [("r", "g"), ("f", "r")], dass in der ersten Runde der erste Spieler neu geladen und der zweite Spieler bewacht wird. In der zweiten Runde schießt der erste Spieler, während der zweite Spieler nachlädt. Spieler eins gewinnt dieses Spiel. Das gleiche Eingangsgegebenenfalls wie dargestellt werden könnte "r g f r", "rgfr", "rg fr" "rg-fr"...

Sie können folgendes annehmen:

• Die Eingabe entspricht dem von Ihnen gewählten Format und enthält nur gültige Zeichen.

• Jemand wird innerhalb von 100 Runden sterben.

Sie können jedoch nicht davon ausgehen, dass die Züge enden, wenn jemand stirbt.

Ausgabe

Ein Wert, der angibt, wer gewonnen hat (oder wer zuerst gewonnen hat *). Sie können für jedes Szenario auswählen, was ausgegeben werden soll, müssen jedoch Folgendes berücksichtigen:

• Spieler 1 gewinnt

• Spieler 2 gewinnt

• Sie töten sich gegenseitig (Unentschieden)

Jedes Ergebnis muss einen Distriktwert haben und für jedes Szenario immer gleich sein.

Als Beispiel: Sie können ausgeben, 1wann Spieler 1 gewinnt, 2wann Spieler 2 gewinnt und 0im Falle eines Unentschieden. Sie müssen dann immer dann ausgeben, 1wenn Spieler 1 gewinnt, 2wenn Spieler 2 gewinnt und 0im Falle eines Unentschieden.

Es kann zurückgegeben oder auf die Standardausgabe gedruckt werden. Nachgestellte Leerzeichen sind in Ordnung.

Nur damit klar ist, ist das einzige Szenario, das zu einem Unentschieden führt, wenn beide Spieler schießen und beide Munition haben.

*Da in dieser Herausforderung Züge fortgesetzt werden können, nachdem jemand gestorben ist, kann es sein, dass mehr als ein Spieler gewinnt. Sie müssen anhand der Eingabe herausfinden, wer zuerst gewonnen hat.

Testfälle (vorausgesetzt, 1P1 gewinnt, 2P2 gewinnt und 0unentschieden):

"rg fr" => 1 (P1 shot P2 while they were reloading)

"rg ff" => 1 (They both shot, but only P1 had ammo)

"rr ff" => 0 (Both had ammo and shot each other)

"rr ff rr fg" => 0 (Both had ammo and shot each other. Everything after the first win is ignored)

"rr fg rf" => 2 (P2 shot P1 while they were reloading)

"rf gg rr fg rr fr" => 1
    (P2 tried to shoot but didn't have any ammo, then they both guarded, then they both reloaded, then P2 blocked a shot, then they both reloaded again [but P2 still only has 1 ammo!], then P1 shoots P2 while they're reloading.

"rr gf fr rf gg rg ff" => 1
       ^ Player 1 wins here. The rest to the right has no effect on the output

Das ist Codegolf, also gewinnt die kleinste Anzahl von Bytes!

Beachten Sie, wie die Testfälle zeigen, dass Sie mit "dummen" Bewegungen umgehen müssen. Es ist durchaus zulässig, dass ein Spieler versucht, zu schießen, wenn er keine Munition hat, oder 2 Runden hintereinander nachlädt (und nur eine einzige Munition ansammelt).

Netzhaut , 36 Bytes

s`(?<=r..([^f]..)*)f
!
A`g
G1`!
\w
_

Das Eingabeformat sollte zeilenweise getrennt sein, z

rr
fr

Das Ergebnis ist, dass !_Spieler 1 gewinnt, _!wenn Spieler 2 gewinnt und !!es ein Unentschieden gibt.

Probieren Sie es online! (Eine Testsuite, die der Einfachheit halber eine Trennung nach Leerzeichen verwendet.)

Ich muss diese Herausforderung völlig übersehen haben. Ich bin sicher, ich hätte das früher in Retina versucht, sonst. :)

Erläuterung

s`(?<=r..([^f]..)*)f
!

Wir beginnen damit, "gültige" Schüsse zu markieren, indem wir den ersten fnach jedem rin drehen !. Wir tun dies, indem wir jeweils feinen rSpieler finden, ohne einen anderen zu überkreuzen f. Die Suche auf rs auf demselben Player zu beschränken, ist einfach, indem immer drei Zeichen gleichzeitig verwendet werden.

A`g

Jetzt legen wir alle Runden ab, in denen sich jemand selbst bewacht hat, weil die letzte Runde keine von diesen sein kann.

G1`!

Jetzt behalten wir nur den ersten Zug bei, der ein enthält !. Wenn ein gültiger Schuss fällt (und wir wissen, dass niemand bewacht wurde), endet das Spiel.

\w
_

Schließlich müssen wir den String konsolidieren, um konsistente Ausgaben zu erhalten, und wir tun dies einfach, indem wir die Nicht- !Zeichen (entweder roder f) in umwandeln _.

Python, 139 Bytes

c=d=0
for i in input():
 b=(c&(i=='fr'))-(d&(i=='rf'));p,q=i
 if b|(i=='ff')&c&d:print b;break
 c,d=(p=='r',i!='fg')[c],(q=='r',i!='gf')[d]

Übernimmt die Eingabe von stdin in Form einer Liste von Zeichenfolgen mit zwei Zeichen (z. B. ['rf', 'rr', 'rg', 'ff']). Gibt 1 aus, wenn Spieler 1 gewinnt, -1, wenn Spieler 2 gewinnt, und 0 für ein Unentschieden.

Erläuterung: Überprüft zuerst, ob jemand eine Kugel abgefeuert hat, wenn dies der Fall ist, endet das Spiel. Dann stellen wir fest, ob die Spieler entweder ihre Waffen nachgeladen oder ihre Munition verschwendet haben.

Dies ist mein erster Codegolf-Beitrag :)

JavaScript (ES6), 108 107 93 91 89 85 Byte

4 Bytes mit Hilfe von Titus gespeichert

Nimmt Eingaben als Array von 2-Zeichen-Zeichenfolgen auf, die die von jedem Spieler gespielten Züge beschreiben.

b=>b.map(c=>w=w||b&'312'[b=(s='0210231')[m='ffrfgrrggf'.search(c)]|s[m-2]&b,m],w=0)|w

Kehrt zurück:

• 1 wenn Spieler 1 gewinnt
• 2 wenn Spieler 2 gewinnt
• 3 für ein Unentschieden

Wie es funktioniert

Wir pflegen eine Bitmaske b, die beschreibt, wer eine geladene Kugel hat:

• Bit # 0: Spieler 1 hat eine Kugel
• Bit 1: Spieler 2 hat eine Kugel

Wir verwenden die De Bruijn-Sequenz 'ffrfgrrggf' , um alle 9 möglichen Kombinationen von Zügen zu identifizieren. Wir verwenden ODER- und UND-Bitmasken, um bentsprechend der Verschiebungskombination zu aktualisieren . Wir verwenden einen dritten Satz von Bitmasken, die mit UND verknüpft sind b, um den Gewinner zu bestimmen w. (Die einzigen drei Gewinnkombinationen zu sein ff, frund rf.)

Es ist erwähnenswert, dass die ODER- und UND-Masken mit demselben Muster gespeichert werden können, das um zwei Positionen verschoben ist.

 Index in | Combination | Bullet   | Bullet  | Winner
 sequence |             | AND mask | OR mask | mask
----------+-------------+----------+---------+--------
    0     |     ff      |    0     |    0    |   3
    1     |     fr      |    0     |    2    |   1
    2     |     rf      |    0     |    1    |   2
    3     |     fg      |    2     |    0    |   0
    4     |     gr      |    1     |    2    |   0
    5     |     rr      |    0     |    3    |   0
    6     |     rg      |    2     |    1    |   0
    7     |     gg      |    3     |    0    |   0
    8     |     gf      |    1     |    0    |   0

Testfälle

let f =

b=>b.map(c=>w=w||b&'312'[b=(s='0210231')[m='ffrfgrrggf'.search(c)]|s[m-2]&b,m],w=0)|w

console.log(f(["rg","fr"]));                            // 1
console.log(f(["rg","ff"]));                            // 1
console.log(f(["rr","ff"]));                            // 3
console.log(f(["rr","ff","rr","fg"]));                  // 3
console.log(f(["rr","fg","rf"]));                       // 2
console.log(f(["rf","gg","rr","fg","rr","fr"]));        // 1
console.log(f(["rr","gf","fr","rf","gg","rg","ff"]));   // 1

Perl 6 , 71 62 Bytes

{&[<=>](|map {m/r[..[r|g]]*.$^f/.to//∞},/[r|f]f/,/.f[r|f]/)}

Regex-basierte Lösung.

Übernimmt die Eingabe als Zeichenfolge im Formular "rg fr".
Die drei möglichen Ausgänge sind die ENUM - Werte More(Spieler 1 gewonnen), Less(Spieler 2 hat), Same(ziehen) , - die in diesen Worten drehen , wenn gedruckt wird , oder in 1, -1, 0wenn Zahlen zu gezwungen.

Probieren Sie es online!

Wie es funktioniert

• map { m/r[..[r|g]]*.$^f/.to // ∞ }, /[r|f]f/, /.f[r|f]/

  Führt zwei Regex-Übereinstimmungen für die Eingabe durch. Nach der Interpolation sind die beiden regulären Ausdrücke:

  • r[..[r|g]]*.[r|f]f - Stimmt mit dem ersten erfolgreichen Schuss von Spieler 2 überein.
  • r[..[r|g]]*..f[r|f] - Stimmt mit dem ersten erfolgreichen Schuss von Spieler 1 überein.

  In jedem Fall wird die Endposition der Übereinstimmung ( .to) oder unendlich zurückgegeben, wenn keine Übereinstimmung vorhanden war.

• &[<=>](|   )

  Wendet den <=>Operator auf die beiden Übereinstimmungsendpositionen an. Es wird ein Wert aus der OrderAufzählung ( More, Lessoder Same) zurückgegeben, je nachdem, ob das erste Argument größer, kleiner oder gleich dem zweiten ist.

Haskell , 101 91 87 Bytes

n!(c:r)|'g'>c=n:1!r|'g'<c=1:0!r|1<3=2:n!r
_!r=[]
a#b=[x|x@(y,z)<-zip(1!a)$1!b,2>y+z]!!0

Probieren Sie es online! Die Infix-Funktion #nimmt zwei Zeichenfolgen, die die Aktionen der beiden Spieler darstellen, und kehrt zurück, (0,1)wenn Spieler 1 gewinnt, (1,0)für Spieler 2 und (0,0)für ein Unentschieden.

Anwendungsbeispiel:

Prelude> "rgrfrf" # "fgrgrr"
(0,1)

Erläuterung:

Die Infix Funktion !übersetzt eine Folge von Aktionen 'r'(neu laden), 'f'(Feuer) und 'g'(Wache) zu einer Sequenz beobachtbarer Aktionen 0(tatsächliches Feuer), 1(keine Aktion) und 2(Wache), wo ein Feuer Aktion nur als gezählt tatsächliches Feuer Aktion wenn eine Kugel geladen ist, und da sonst keine Aktion . Um dies zu erreichen, nlautet das erste Argument, 0ob eine Kugel geladen ist und 1ob die Waffe nicht geladen ist. Auf diese Weise 'f'kann jeder einfach durch den Strom ersetzt werden n. ( n=0-> geladen -> tatsächliches Feuer -> 0, n=1-> entladen -> keine Aktion -> 1)

n ! (c:r)                -- n is 0 or 1, c is 'f', 'g' or 'r' and r the rest of the string
    |'g'>c = n : (1 ! r) -- c is smaller 'g', so it must be 'f'. append n to the list
                         --  and set load status to 1 (unloaded)
    |'g'<c = 1 : (0 ! r) -- c is larger 'g', so it must be 'r'. append 1 (no action)
                         --  and set load status to 0 (loaded)
    |1<3   = 2 : (n ! r) -- c must be equal to 'g'. append 2 (guard)
                         --  and leave the load status unchanged
_ ! r = []               -- base case for recursion

Die neun resultierenden Möglichkeiten sind dann

• (0,0): Beide Spieler schießen und sterben, das Spiel endet.
• (0,1)oder (1,0): Ein Spieler schießt auf den anderen, das Spiel endet.
• (0,2)oder (2,0): Ein Spieler schießt, der andere Wächter schießt, das Spiel geht weiter.
• (1,1), (1,2), (2,1)Oder (2,2): Keine Spieler schießt, Spiel geht weiter.

Die Summe der Optionen zum Beenden des Spiels ist konstruktionsbedingt kleiner als 2 und die Summe der Möglichkeiten zum Fortsetzen des Spiels ist größer oder gleich 2. Das Ergebnis des Spiels ist dann das erste Tupel mit einer Summe von weniger als 2.

a#b=[x|         -- build the list of all x
    x@(y,z) <-  -- where x is an alias for the tuple (y,z) which is drawn from the list
    zip (1!a)   -- of tuples where the first component is from 1!a = eg. [1,2,1,0,1,0] 
        (1!b)   -- and the second from 1!b = eg. [1,2,1,2,1,1]
    , 2 > y+z]  -- and y+z are smaller 2.
    !!0         -- return the first element of this list

Batch, 249 Bytes

@echo off
set g=goto gg
set/ax=y=0
:gg
shift&goto %1
:fg
set x=0
%g%
:gf
set y=0
%g%
:rr
set/ax=y=1
%g%
:fr
if %x%==1 exit/b1
:gr
set y=1
%g%
:rf
if %y%==1 exit/b2
:rg
set x=1
%g%
:ff
set/az=3-x-x-y
if %z%==3 %g%
exit/b%z%

Die Eingabe erfolgt in Form von Zeichenpaaren für jede Runde und erfolgt nach Fehlerstufe (0 = Unentschieden, 1 = Spieler 1, 2 = Spieler 2). xund yverfolge, ob der Spieler Munition hat. Wenn also beide feuern, ist das Ergebnis 3-x-x-y, außer wenn dies 3 ist. In diesem Fall machen wir weiter. In Zeile 5 missbrauche ich Batchs Parser - %1(das ist der aktuelle Zug) wird ersetzt, bevor die shiftAnweisung ausgeführt und entfernt wird, sodass wir immer noch zum richtigen Label gehen.

Clojure, 168 Bytes

#(reduce(fn[[l L r R][a A]](if(and l L)(let[M(fn[r a A](if(and(= a \f)r)[nil(= A \g)][(or(= a \r)r)1]))[r L](M r a A)[R l](M R A a)][l L r R])[l L r R]))[1 1 nil nil]%)

Weniger Golf (wenn beide Personen am Leben sind M, aktualisieren wir ihre Munition und den Lebensstatus des Feindes, ansonsten geben wir den aktuellen Status zurück):

(def f (fn[A] (reduce
                (fn [[l1 l2 r1 r2] [a1 a2]]
                  (if (and l1 l2)
                    (let[M (fn [r1 a1 a2]
                             (if (and(= a1 \f)r1)
                               [false (= a2 \g)]        ; we lost the ammo, a2 lives if he was guarding
                               [(or(= a1 \r)r1) true])) ; we might gain or keep ammo, a2 lives no matter what
                         [r1 l2] (M r1 a1 a2)
                         [r2 l1] (M r2 a2 a1)]
                      [l1 l2 r1 r2])
                    [l1 l2 r1 r2]))
                [true true false false] A)))

Anwendungsbeispiel (erstes Element zeigt an, ob Spieler 1 am Ende des Spiels am Leben ist, zweites Element zeigt an, ob Spieler 2 am Leben ist, 3. und 4. zeigen den Munitionsstatus an, der bei der Ermittlung des Gewinners nicht relevant ist):

(-> (for[[a b s] (partition 3 "rr fg rf fr ")][a b]) f (subvec 0 2))

Update: Na schau dir das an, das loophat identische Länge! Ich finde, dass die reduceVersion einfacher zu entwickeln ist, da Sie Zwischenzustände leicht untersuchen können, wenn Sie sie verwenden reductions.

#(loop[l 1 L 1 r nil R nil[[a A]& I]%](if(and l L)(let[M(fn[r a A](if(and(= a \f)r)[nil(= A \g)][(or(= a \r)r)1]))[r L](M r a A)[R l](M R A a)](recur l L r R I))[l L]))

PHP, 107 101 90 Bytes

Verwenden einer Bitmaske $ d für den Ladestatus und einer DeBruijn-Sequenz für die Schussbewegungen.

for(;!$x=$d&strpos(_frff,$m=$argv[++$i]);)$d=$d&g<$m|h<$m|2*($d/2&f<$m[1]|g<$m[1]);echo$x;

Nimmt Eingaben als 2-stellige Befehlszeilenargumente an und führt sie mit aus -nr.

1 = Spieler 1 gewinnt
2 = Spieler 2 gewinnt
3 = Unentschieden

Nervenzusammenbruch

for(;!$x=$d&strpos(_frff,       // 1. $x=someone dies, loop while not
    $m=$argv[++$i]          // loop throug moves
);)
    $d=
        $d&g<$m|h<$m            // 2. unload/reload Player 1 = bit 0
    |2*(
        $d/2&f<$m[1]|g<$m[1]    // 3. unload/reload Player 2 = bit 1
    );
echo$x;

• DeBruijn-Sequenz:: frPosition = 1 = P1-Feuer; rf= Position 2 = P2 feuert, ff= Position 3 = beide feuern
• g<$m<=> f<$m[0]( f<$mist immer wahr, da es ein zweites Zeichen gibt).

Python, 200 Bytes

def war_game(turns):
    turn=0
    player1=True
    player2=True
    ammo1=False
    ammo2=False
    while turn<len(turns):
        if turns[turn][0]=='f' and ammo1==True and turns[turn][1]!='g':
            player2=False
        elif turns[turn][0]=='f' and turns[turn][1]=='g':
            ammo1=False
        elif turns[turn][0]=='r':
            ammo1=True
        if turns[turn][1]=='f' and ammo1==True and turns[turn][0]!='g':
            player1=False
        elif turns[turn][1]=='f' and turns[turn][0]=='g':
            ammo2=False            
        elif turns[turn][1]=='r':
            ammo2=True
        if player2==False or player1==False:
            break
        turn+=1
    if player1==True and player2==False:
        print('Player 1 wins')
        return 1
    elif player1==False and player2==True:
        print('Player 2 wins')
        return 2
    print('Draw')
    return 0

Clojure, 180 173 Bytes

(fn[t](loop[z nil x nil[[c v]& r]t](let[k #(and %3(= %\f)(not= %2\g))h #(and(not= %\f)(or %2(= %\r)))q(k v c x)w(k c v z)](cond(and q w)0 q 2 w 1 1(recur(h c z)(h v x)r)))))

-7 Bytes, indem Sie die Funktion in eine vollständige Funktion ändern, anstatt ein Makro zu verwenden. Das ließ mich die inneren Funktionen zu Makros machen, was ein bisschen spart.

Dies ist eine sehr wörtliche Lösung. Ich bin ein bisschen verrückt, da ich gerade eine Vollversion des Spiels geschrieben habe, und dies ist im Grunde eine stark reduzierte Version des von mir verwendeten Algorithmus. Es gibt wahrscheinlich viele Optimierungen, die ich tun könnte, aber ich bin ziemlich zufrieden damit. Erklärungen finden Sie im Code vor dem Golf.

(defn outcome [turns] ; Take input as ["rr" "ff"]
  (loop [p1-ammo? false ; Keep track of if each player has ammo
         p2-ammo? false
         [[p1-move p2-move] & rest-turns] turns] ; Deconstruct the turns out

    (let [killed? (fn [m m2 a] (and a (= m \f) (not= m2 \g))) ; Function that checks if one player killed the other
          has-ammo? (fn [m a] (and (not= m \f) (or a (= m \r)))) ; Function that decides if a player has ammo in the
                                                                 ;  next turn
          p1-killed? (killed? p2-move p1-move p2-ammo?) ; Check if each player was killed.
          p2-killed? (killed? p1-move p2-move p1-ammo?)]

      (cond ; Check who (if any) died. If no one died, recur to next turn.
        (and p1-killed? p2-killed?) 0
        p1-killed? 2
        p2-killed? 1
        :else (recur (has-ammo? p1-move p1-ammo?)
                     (has-ammo? p2-move p2-ammo?)
                     rest-turns)))))