Trova il risultato di un gioco di guerra

Quando ero alle elementari, c'era un gioco "rock-paper-scissors" che giocavamo durante le assemblee, in attesa del nostro insegnante, durante la ricreazione, ecc. L'abbiamo chiamato "guerra". Tuttavia, dopo alcune ricerche, si scopre che questa è una variante molto più semplice del "Gioco del fucile" (secondo WikiHow) . Lo chiamerò "Guerra" poiché le regole sono leggermente diverse:

2 persone siedono l'una di fronte all'altra. L'obiettivo del gioco è "uccidere" l'altro giocatore. Ad ogni turno, puoi giocare una delle 3 mosse:

• Ricarica : hai una pistola che regge un singolo colpo. Deve essere ricaricato prima di poter essere sparato ogni volta. Ricaricare quando hai già munizioni è legale, ma non fa nulla. Una ricarica è stata simboleggiata toccando le tempie con entrambe le mani. Ogni giocatore inizia con 0 munizioni.

• Guardia : l'unica mossa sicura. Se ti sparano mentre fai la guardia, non muori. La guardia veniva simbolizzata incrociando le braccia sul petto.

• Fuoco : spara la tua pistola. Per sparare con successo, devi aver ricaricato dall'ultimo colpo. Se il tuo avversario sta ricaricando, vinci. Se sparano anche loro ed entrambi avete delle munizioni, è un pareggio. Se stanno facendo la guardia, hai sprecato le munizioni. Mentre sparare senza munizioni è una mossa legale, non fa nulla e ti rende vulnerabile come ricaricare. Il fuoco è stato simbolizzato indicando l'altro giocatore.

È stato giocato in modo simile a RPS, in quanto ogni giocatore contemporaneamente abbassa la propria scelta (abbiamo toccato due volte le gambe tra i turni per tenere il ritmo l'uno con l'altro, ma questo non è importante per la sfida).

La sfida:

Il tuo compito è trovare il risultato di un gioco di guerra. Può essere una funzione o un programma completo.

Ingresso

• L'opzione che ogni giocatore ha scelto per ogni turno sarà rappresentata da un personaggio / stringa:

  • r : ricaricare

  • g : guardia

  • f : fuoco

• L'input sarà un elenco di coppie, una stringa delimitata / non delimitata o qualsiasi altra cosa lungo queste linee.

Un input di esempio in Python potrebbe essere [("r", "g"), ("f", "r")], ovvero nel primo turno il primo giocatore ricaricato e il secondo giocatore sorvegliato. Al secondo turno, il primo giocatore spara, mentre il secondo giocatore ricarica. Il giocatore uno vince questo gioco. Lo stesso ingresso potrebbe eventualmente essere rappresentato come "r g f r", "rgfr", "rg fr" "rg-fr"...

Puoi assumere quanto segue:

• L'input corrisponderà al formato scelto e conterrà solo caratteri validi.

• Qualcuno morirà entro 100 turni.

Non puoi tuttavia supporre che i giri finiscano quando qualcuno muore.

Produzione

Un valore che indica chi ha vinto (o chi ha vinto per primo *). Puoi scegliere cosa produrre per ogni scenario, ma devi tenere conto di quanto segue:

• Il giocatore 1 vince

• Il giocatore 2 vince

• Si uccidono a vicenda (pareggio)

Ogni risultato deve avere un valore distrettuale e deve essere sempre lo stesso per ogni scenario.

Ad esempio: potresti ottenere 1quando vince il giocatore 1, 2quando vince il giocatore 2 e 0in caso di pareggio. Quindi devi sempre produrre 1quando vince il giocatore 1, 2quando vince il giocatore 2 e 0in caso di pareggio.

Può essere restituito o stampato sullo stdout. Lo spazio bianco finale va bene.

Proprio così è chiaro, l'unico scenario che porta a un pareggio è se entrambi i giocatori sparano ed entrambi hanno munizioni.

*Dato che in questa sfida, i turni possono continuare dopo la morte di qualcuno, è possibile che alla fine vinca più di 1 giocatore. Devi trovare chi ha vinto per primo in base all'input.

Casi di prova (supponendo 1quando vince P1, 2quando vince P2 e 0per un pareggio):

"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

Questo è il codice golf, quindi vince il minor numero di byte!

Nota, come mostrano i casi di test, è necessario gestire mosse "stupide". È perfettamente valido per un giocatore provare a sparare quando non ha munizioni o ricaricare 2 turni di fila (e accumulare solo una singola munizione).

Retina , 36 byte

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

Il formato di input deve essere coppie separate di avanzamento riga, ad es

rr
fr

L'output è il !_giocatore 1 vince, _!se il giocatore 2 vince e !!se c'è un pareggio.

Provalo online! (Una suite di test che utilizza la separazione degli spazi per comodità.)

Devo aver completamente ignorato questa sfida. Sono sicuro che altrimenti avrei provato questo a Retina prima. :)

Spiegazione

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

Iniziamo contrassegnando colpi "validi" trasformando il primo fdopo ciascuno rin !. Lo facciamo abbinando ognuno fdei quali può trovare uno rsullo stesso giocatore senza incrociare un altro f. Limitare la ricerca a rs sullo stesso giocatore è facile andando sempre tre caratteri alla volta.

A`g

Ora scartiamo tutti i turni in cui qualcuno si è custodito, perché il turno finale non può essere uno di quelli.

G1`!

Ora manteniamo solo il primo turno che contiene un !. Se si verifica un tiro valido (e sappiamo che nessuno è sorvegliato) il gioco termina.

\w
_

Infine, dobbiamo consolidare la stringa per fornire output coerenti, e lo facciamo semplicemente trasformando i non !caratteri (o ro f) in _.

Python, 139 byte

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]

Prende input su stdin sotto forma di un elenco di stringhe di 2 caratteri (ad es. ['Rf', 'rr', 'rg', 'ff']). Emette 1 se il giocatore 1 vince, -1 se il giocatore 2 vince e 0 per un pareggio.

Spiegazione: Prima controlla se qualcuno ha sparato un proiettile, in tal caso il gioco finisce. Quindi determiniamo se i giocatori hanno ricaricato le loro armi o hanno perso le munizioni.

Questo è il mio primo post in codegolf :)

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

Salvato 4 byte con l'aiuto di Tito

Prende input come una serie di stringhe di 2 caratteri che descrivono le mosse giocate da ciascun giocatore.

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

Ritorna:

• 1 se il giocatore 1 vince
• 2 se il giocatore 2 vince
• 3 per un pareggio

Come funziona

Manteniamo una maschera di bit bche descrive chi ha un proiettile caricato:

• bit # 0: il giocatore 1 ha un proiettile
• bit n. 1: il giocatore 2 ha un proiettile

Usiamo la sequenza 'ffrfgrrggf' di De Bruijn per identificare tutte e 9 le possibili combinazioni di mosse. Utilizziamo maschere di bit OR e AND per l'aggiornamento in bbase alla combinazione di spostamenti. Usiamo un terzo set di maschere di bit che sono AND con cui bdeterminare il vincitore w. (Le uniche tre combinazioni vincenti sono ff, fre rf.)

Vale la pena notare che le maschere OR ed AND possono essere memorizzate con lo stesso modello, spostate di due posizioni.

 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

Casi test

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 byte

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

Soluzione basata su Regex.

Accetta l'input come stringa nel modulo "rg fr".
Le tre uscite possibili sono i valori enum More(lettore 1 won), Less(lettore 2 won), Same(disegnare) - che si trasformano in quelle parole quando vengono stampate, o in 1, -1, 0quando costretto a numeri.

Provalo online!

Come funziona

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

  Esegue due corrispondenze regex sull'input. Dopo l'interpolazione, le due regex sono:

  • r[..[r|g]]*.[r|f]f - Corrisponde al primo tiro riuscito del giocatore 2.
  • r[..[r|g]]*..f[r|f] - Corrisponde al primo tiro riuscito del giocatore 1.

  In ogni caso, restituisce la posizione finale della partita (.to ) o l'infinito se non è stata trovata alcuna corrispondenza.

• &[<=>](|   )

  Applica l' <=>operatore alle due posizioni finali della partita. Esso restituisce un valore dalla Orderenum ( More, Lesso Same), a seconda che il primo argomento è maggiore, minore o uguale alla seconda.

Haskell , 101 91 87 byte

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

Provalo online! La funzione infix #prende due stringhe che rappresentano le azioni di ciascuno dei due giocatori e ritorna (0,1)se il giocatore 1 vince, (1,0)per il giocatore 2 e (0,0)per un pareggio.

Esempio di utilizzo:

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

Spiegazione:

La funzione infix !traduce una sequenza di azioni 'r'(ricarica), 'f'(fuoco) e 'g'(guardia) in una sequenza di azioni osservabili 0(fuoco effettivo), 1(nessuna azione) e 2(guardia), dove un'azione di fuoco viene conteggiata solo come azione di fuoco effettiva se viene caricato un proiettile, e altrimenti nessuna azione . Per raggiungere questo obiettivo il primo argomento nè 0se un proiettile è caricato e 1se la pistola non è caricata. In questo modo ognuno 'f'può essere semplicemente sostituito con la corrente n. ( n=0-> caricato -> fuoco effettivo -> 0, n=1-> scaricato -> nessuna azione -> 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

Le nove possibilità risultanti sono quindi

• (0,0): Entrambi i giocatori sparano e muoiono, il gioco finisce.
• (0,1)oppure (1,0): un giocatore spara all'altro, il gioco termina.
• (0,2)oppure (2,0): un giocatore spara ma le altre guardie, il gioco continua.
• (1,1), (1,2), (2,1)O (2,2): Nessun giocatore spara, gioco continua.

In base alla progettazione, la somma delle opzioni di fine del gioco è inferiore a 2 e la somma di ogni possibilità continuativa del gioco è maggiore o uguale a 2. Il risultato del gioco è quindi la prima tupla con somma inferiore a 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

Lotto, 249 byte

@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%

L'ingresso è in forma di coppie di caratteri per ogni turno e le uscite per livello di errore (0 = pareggio, 1 = giocatore 1, 2 = giocatore 2). xe ytenere traccia del fatto che il giocatore abbia munizioni, quindi quando entrambi sparano, il risultato è 3-x-x-y, a meno che non sia 3, nel qual caso continuiamo ad andare avanti. Nella riga 5 uso l'abuso del parser di Batch - %1(che è la mossa corrente) viene sostituito prima che l' shiftistruzione venga eseguita e rimossa, quindi andiamo ancora all'etichetta corretta.

Clojure, 168 byte

#(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]%)

Meno golf (se entrambe le persone sono in vita usiamo Mper aggiornare le loro munizioni e lo stato di vita del nemico, altrimenti restituiamo lo stato attuale):

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

Esempio di utilizzo (il primo elemento indica se il Giocatore 1 è vivo alla fine del gioco, il secondo elemento indica se il Giocatore 2 è vivo, il 3o e il 4o dicono lo stato delle munizioni che non è rilevante quando si determina il vincitore):

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

Aggiornamento: Bene, guarda che loopha lunghezza identica! Trovo la reduceversione più semplice da sviluppare in quanto puoi facilmente controllare gli stati intermedi se lo usi 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 byte

usando una maschera di bit $ d per lo stato di caricamento e una sequenza DeBruijn per le mosse di fuoco.

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;

accetta input come argomenti della riga di comando a 2 caratteri, eseguito con -nr.

1 = Il giocatore 1 vince
2 = Il giocatore 2 vince
3 = pareggio

abbattersi

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;

• Sequenza DeBruijn fr:: position = 1 = P1 spara; rf= posizione 2 = P2 spara, ff= posizione 3 = entrambi i fuochi
• g<$m<=> f<$m[0]( f<$mè sempre vero, perché c'è un secondo carattere).

Python, 200 byte

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 byte

(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 byte modificando la funzione in una funzione completa invece di utilizzare una macro. Ciò mi consente di creare macro di funzioni interne, il che consente di risparmiare un po '.

Questa è una soluzione molto letterale. Sono un po 'bloccato dalla mente da quando ho appena scritto una versione completa del gioco, e questa è fondamentalmente una versione notevolmente ridotta dell'algoritmo che ho usato. Probabilmente ci sono molte ottimizzazioni che potrei fare, ma ne sono abbastanza soddisfatto. Vedi il codice pregolfed per la spiegazione.

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