_{Quando ero bambino, giocavo molto a questo gioco.}

Regole

Ci sono due giocatori (chiamiamoli A e B) e ogni giocatore usa le sue mani come pistole. Esistono tre mosse possibili:

1. Mani in alto per caricare munizioni sulla tua pistola.

   Ogni arma inizia vuota. Il caricamento aumenta le munizioni di uno.

2. Mani che puntano all'altro giocatore per sparare.

   Questo riduce le munizioni di uno. Per sparare devi avere almeno un'unità di munizioni.

3. Braccia incrociate per proteggersi da un colpo.

Entrambi i giocatori si muovono contemporaneamente. Se entrambi i giocatori sparano contemporaneamente, i proiettili si colpiscono l'un l'altro e il gioco continua. Il gioco termina quando un giocatore spara mentre l'altro sta caricando munizioni.

Sparare e svuotare la pistola è considerato un imbroglio . Se un giocatore imbroglia mentre l'altro esegue un'azione legale, l'imbroglione perde immediatamente. Se entrambi i giocatori imbrogliano contemporaneamente, il gioco continua.

I tentativi di barare non riducono le munizioni, quindi non possono mai essere negative.

Sfida

Date le mosse fatte dai giocatori A e B, indica quale giocatore ha vinto la partita: 1per il giocatore A, -1per il giocatore B e 0per un pareggio. È possibile utilizzare qualsiasi altro triplo di valori restituiti, ma è necessario indicare nella risposta quali utilizzare.

Il gioco può:

• terminare senza dover elaborare tutte le mosse;
• non termina con le mosse indicate, e quindi è considerato un pareggio.

L'input può essere preso:

• come stringhe
• come matrici / liste di numeri interi
• in qualsiasi altro modo che non pre-elabori l'input

Programma completo o funzioni consentite. Dal momento che questo è code-golf , vince la risposta più breve in byte!

Casi test

A: "123331123"
B: "131122332"
    -----^                Player B shoots player A and wins.

Output: -1

A: "111322213312"
B: "131332221133"
    -------^              Player B cheats and loses.

Output: 1

A: "1333211232221"
B: "1213211322221"
    ----------^^          Both players cheat at the same time. The game continues.

Output: 0

A: "12333213112222212"
B: "13122213312232211"
         |       || ^---- Player A shoots player B and wins.
         ^-------^^------ Both players cheat at the same time. The game continues.

Output: 1

Gelatina, 33 32 24 byte

Zæ%1.»0$+¥\>-‘żZḅ3Ff5,7Ḣ

Stampa 5 invece di -1 e 7 invece di 1 . Provalo online! o verifica tutti i casi di test .

Come funziona

Zæ%1.»0$+¥\>-‘żZḅ3Ff5,7Ḣ  Main link. Argument: A (digit list array)

Z                         Zip; group corresponding digits.
 æ%1.                     Map the digits in (-1.5, 1.5].
                          This replaces [1, 2, 3] with [1, -1, 0].
          \               Cumulatively reduce the pairs by doing the following.
     »0$                    Take the maximum of the left value and 0, i.e., replace
                            a -1 with a 0.
        +¥                  Add the modified left value to the right value.
                          This computes the available ammo after each action. An
                          ammo of -1 indicates a cheating attempt.
           >-             Compare the results with -1.
             ‘            Increment. And unilateral cheating attempt is now [1, 2]
                          or [2, 1], where 1 signals the cheater and 2 the winner.
              żZ          Pair each result with the corr., original digits.
                ḅ3        Convert each pair from base 3 to integer.
                          This maps [1, 2] and [2, 1] to 5 and 7.
                  F       Flatten the resulting, nested list.
                   f5,7   Discard all but 5's and 7's.
                       Ḣ  Grab the first element (5 or 7).
                          If the list is empty, this returns 0.

Pyth, 48 46 49 47 byte

.xhfT|M.e,-FmgF.b/<dhkY2S2Q?}b_BS2-FbZ.b,NYCQ)0

Provalo qui!

Grazie a @isaacg per aver salvato 2 4 byte!

Prende l'input come 2-tupla con l'elenco delle mosse del giocatore A per primo e le mosse del giocatore B per secondo. L'output è lo stesso della sfida.

Spiegazione

Breve panoramica

• Innanzitutto raggruppiamo le mosse di entrambi i giocatori, quindi otteniamo un elenco di 2 tuple.
• Quindi mappiamo ciascuna di quelle tuple su un'altra 2 tupla nel modulo [cheating win, fair win]con i possibili valori -1, 0, 1per ciascuna di esse, per indicare se un giocatore ha vinto a questo punto ( -1, 1) o se il gioco continua (0 )
• Ora dobbiamo solo ottenere la prima tupla che non lo è [0,0]e prendere il primo elemento diverso da zero che indica il vincitore

Analisi del codice

.xhfT | Me, -FmgF.b / <dhkY2S2Q?} b_BS2-FbZ.b, NYCQ) 0 # Q = elenco delle liste di traslochi

                                      .b, NYCQ # abbina gli elementi di entrambi gli elenchi di input
       .e # mappa sopra l'elenco delle coppie con 
                                                 # b essendo la coppia e k è indice
            m Q # mappa ogni elenco mosse d
               .b Mappa 2S2 # su [1,2], non posso usare m perché è
                                                 # La variabile lambda è in conflitto con quella di .e
                  <dhk # d [: k + 1]
                 / Y # conta le occorrenze di 1 o 2 in questo elenco
          -F # (conteggio di 1s) - (conteggio di 2s), indica la vincita imbroglione
                           ?} b_BS2 # se b è (1,2) o (2,1)
                                  -Fb # prende la differenza, indica una vittoria equa
                                     Z # else 0, nessun vincitore ancora
         , # abbina questi 2 valori
     | M # Per ogni coppia risultante, prendi la prima se
                                                 # non è zero, altrimenti il ​​secondo
   fT # filtra tutti i valori zero
.xh # prova a prendere il primo valore che indica il vincitore
                                             ) 0 # se ciò non è possibile perché l'elenco è vuoto
                                                 # output zero per indicare un pareggio

Python, 217 byte

def f(A,B):
 x=y=0;c=[-1,1,0]
 for i in range(len(A)):
  a=A[i];b=B[i]
  for s in[0,1]:
   if(a,b)==(2,1):return c[s]*c[x<1]
   if(a,b)==(2,3)and x<1:return-c[s]
   x-=c[a-1];x+=x<0;a,b,x,y=b,a,y,x
 return 0

Spiegazione : accetta A e B come elenchi di numeri interi. Passa semplicemente attraverso ogni coppia di mosse, aggiunge o sottrae 1 se necessario e ritorna quando qualcuno imbroglia o vince. Fa la stessa cosa due volte usando un altro per il ciclo, una volta per la mossa di A e una volta per la mossa di B. Aggiunge 1 se x scende da 0 a -1.

Java, 226 212 200 196 194 byte

-14 byte riordinando la logica

-12 byte grazie a Mr Public sottolineando come utilizzare un'operazione ternaria per la logica di tiro

-4 byte comprimendo la logica di carico in un cortocircuito se

-2 byte perché ==1=== <2quando l'ingresso può essere solo 1, 2,3

(a,b)->{for(int m=0,n=0,w,v,r=0,i=0,x;i<a.length;){w=a[i];v=b[i++];x=w==2?m<1?r--:m--:0;x=v==2?n<1?r++:n--:0;if(r!=0)return r;if(w<2&&++m>0&v==2)return -1;if(v<2&&++n>0&w==2)return 1;}return 0;}

Uso e versione rientrata:

static BiFunction<Integer[], Integer[], Integer> game = (a,b) -> {
    for(int m=0,n=0,w,v,r=0,i=0,x;i<a.length;) {
        w=a[i];v=b[i++];
        // shoot
        x=w==2?m<1?r--:m--:0;
        x=v==2?n<1?r++:n--:0;
        if(r!=0)return r;
        // load
        if(w<2&&++m>0&v==2)return -1;
        if(v<2&&++n>0&w==2)return 1;
    }
    return 0;
};

public static void main(String[] args) {
    System.out.println(game.apply(new Integer[] {1,2,3,3,3,1,1,2,3}, new Integer[] {1,3,1,1,2,2,3,3,2}));
    System.out.println(game.apply(new Integer[] {1,1,1,3,2,2,2,1,3,3,1,2}, new Integer[] {1,3,1,3,3,2,2,2,1,1,3,3}));
    System.out.println(game.apply(new Integer[] {1,3,3,3,2,1,1,2,3,2,2,2,1}, new Integer[] {1,2,1,3,2,1,1,3,2,2,2,2,1}));
}

Non è più così semplice l'implementazione delle regole del gioco, ma semplice. Ogni ciclo esegue queste operazioni:

• Il carico si sposta in variabili temporanee
• Se il giocatore ha sparato
  • senza munizioni: propensione ralla perdita
  • con munizioni: diminuzione delle munizioni
• Se cheate rnon lo è 0, restituisci il valore perché qualcuno ha tradito
• Se il giocatore viene ricaricato
  • munizioni incrementali
  • se un altro giocatore ha sparato, restituisci la perdita

x è una variabile fittizia usata per fare in modo che il compilatore mi permetta di usare un'espressione ternaria.

Aspetta, Java è più corto di Python?