Questa è una sfida in cui due persone, 1 e 2, sono in corsa per l'ufficio. Le persone votano deterministicamente in alcuni modi nel mondo di 1 e 2, il che può consentire ai candidati di capire i risultati prima delle elezioni.

NOTA: ciò non significa riferirsi a elezioni esterne o altri eventi politici.

Due persone sono in corsa per l'ufficio. Chiameremo queste persone 1 e 2. Poiché entrambi vogliono sapere se vinceranno le elezioni, decidono di usare la loro conoscenza delle persone e del codice per capire quale sarà il risultato. A causa della volontà di minimizzare la spesa pubblica, il codice deve essere il più breve possibile.

Il tuo compito: data una serie di persone in base al modo in cui votano, uscita chi vince le elezioni.

Esistono cinque tipi di persone nel mondo divertente ed eccitante di 1 e 2:

• A: persone che voteranno sicuramente per 1.
• B: persone che voteranno sicuramente per 2.
• X: le persone che voteranno per chiunque voterà per la persona alla loro sinistra. Se non c'è nessuna persona alla sua sinistra, allora voterà per chi voterà per la persona alla sua destra. Se non è chiaro per chi sta votando la persona alla loro destra, allora non votano.
• Y: le persone voteranno il contrario della persona alla loro sinistra. Se non c'è nessuno alla loro sinistra, allora votano al contrario di chiunque sia alla loro destra. Se non è chiaro per chi sta votando la persona alla loro destra, allora non votano.
• N: persone che non votano.

Questo viene valutato da sinistra a destra.

Esempio:

Chiunque venga "valutato" è in minuscolo, per chiarezza.

Input: `XXAYAN`
        xX      Votes for whoever their friend is voting for. Their friend has not decided yet, so it is unclear, so they do not vote.
        Xx      Person to left is voting "none" so votes "none."
          a     Votes for 1
          Ay    Since person on left is voting for 1, votes for 2.
            a   Votes for 1
             n  Does not vote

Sondaggio finale:

• 2 persone hanno votato per 1

• 1 persone hanno votato per 2

• 3 persone non hanno votato

1 ha il maggior numero di voti, quindi 1 vince!

Casi test:

È possibile utilizzare altri caratteri o valori come input e output, purché siano distinti. (Ad esempio: numeri anziché lettere, lettere diverse, lettere minuscole, verità / falsa o positivo / negativo (per output), ecc.)

Input -> Output

"AAAA" -> 1
"BBBB" -> 2
"BBAXY" -> 2
"BAXYBNXBAYXBN" -> 2
"XXAYAN" -> 1
"AAAABXXXX" -> 2
"AXNXXXXAYB" -> 1
"NANNY" -> 1
"XA" -> 1
"YAB" -> 2
"XY" -> anything (do not need to handle test cases with no victor)
"AB" -> anything (do not need to handle test cases with no victor)

Perl 5, 56 80 72 65 53 byte

+26 byte per gestire il caso X o Y in prima posizione e A o B in seconda. l'output è 1se 1 vince vuoto (valore falso in perl) altrimenti.

s/^X(.)/$1$1/,s/A\KX|B\KY|^Y(?=B)/A/|s/B\KX|A\KY|^Y(?=A)/B/&&redo;$_=y/A//>y/B//

TIO

usando Pe Sinvece di Xe Ypermettendo di usare l'operazione xor sui caratteri, si risparmierebbe qualche altro byte

s/(?|^(P|S)(?=(A|B))|(A|B)\K(P|S))/P^$1^$2/e&&redo;$_=y/A//>y/B//

utilizza un gruppo di reimpostazione ramo (?|... |.. ), in modo che si $1 $2riferisca al gruppo corrispondente nel ramo. Utilizzando \0e \3invece di XeY

$_=s/^\W(?=(\w))|(\w)\K\W/$1.$2^$&/e?redo:y/A//>y/B//

72 byte

65 byte

53 byte

Java 8, 153 141 135 131 129 byte

a->{int l=a.length,t,r=0,i=-1;for(;++i<l;r+=(t=a[i]=a[i]>4?t<3?t^3:3:a[i]>3?t:a[i])>2?0:3-t*2)t=a[i>0?i-1:i<l-1?i+1:i];return r;}

Utilizza una matrice di numeri interi come input con A=1, B=2, N=3, X=4, Y=5e genera un numero intero positivo ( >= 1) se A vince, un numero intero negativo ( <= -1) se B vince o 0se è un pareggio.

-18 byte grazie a @ OlivierGrégoire .

Provalo online.

Spiegazione:

a->{                      // Method with int-array parameter and boolean return-type
  int l=a.length,         //  Length of the input-array
      t,                  //  Temp integer, uninitialized
      r=0,                //  Result-integer, starting at 0
  i=-1;for(;++i<l         //  Loop `i` in the range [0, l):
           ;              //    After every iteration:
            r+=           //     Increase the result by:
             (t=a[i]=     //       Change `i`'th item in the array to:
                 a[i]>4?  //        If the `i`'th item is a 5:
                  t<3?    //         If `t` is 1 or 2:
                   t^3    //          Use `t` Bitwise-XOR 3 to invert it
                          //          (1 becomes 2; 2 becomes 1)
                  :       //         Else (`t` is 3, 4, or 5 instead):
                   3      //          Set it to 3
                 :a[i]>3? //        Else-if the `i`'th item is a 4:
                  t       //         Set it to `t`
                 :        //        Else (the `i`'th item is a 1, 2 or 3):
                  a[i])   //         Leave it unchanged
             )>2?         //      And if this new `i`'th value is 3, 4, or 5:
              0           //       Leave the result the same by increasing it with 0
             :            //      Else (it's 1 or 2 instead):
              3-t*2;      //       Increase it by 3 minus two times the `i`'th value
                          //       (which is 1 for 1; and -1 for 2)
         t=               //   Set `t` to:
           a[i>0?         //    If `i` is not the first item:
              i-1         //     Set `t` to the previous (`i-1`'th) value
             :i<l-1?      //    Else-if `i` is not the last item:
              i+1         //     Set `t` to the next (`i+1`'th) value
             :            //    Else (`i` is the first or last item):
              i];         //     Set `t` to the current item itself
  return r;}              //  Return the result
                          //  (positive if A wins; negative if B wins; 0 if it's draw)

Haskell, 60 50 48 59 byte

l#(v:o)|v<2=v+v#o|n<-(3-v)*l=n+n#o
_#_=0
f x=rem(x!!1)2#x>0

Utilizza 1per A, -1per B, 0per N, 2per Xe 4per Y. Restituisce Truese Avince, altrimenti False.

Provalo online!

Sulla via ricorsiva in basso nella lista di input aggiungiamo 1per ogni voto per A, -1per ogni voto per Be 0per "nessun voto". lè l'ultimo voto, vil prossimo. Se v=1, -1o 0(o v<2) lo aggiungiamo semplicemente alla somma. Se vè "voto uguale" ( Xnella sfida, 2per la mia soluzione) manteniamo e aggiungiamo l( (3-2)*l= l). Se vè "voto opposto" ( Ynella sfida, 4per la mia soluzione) prima neghiamo l( (3-4)*l= -l) e poi lo aggiungiamo. Il caso base è l'elenco vuoto con cui inizia la somma 0. La ricorsione è iniziata con lset to rem s 2wheresè il secondo elemento dell'elenco di input ( x!!1). rem s 2mappe 1e -1a se stesso, tutti gli altri valori a 0. Fix voti ignorano lcomunque [*] e Xo Yottenere il vicino di destra se si tratta di un voto correzione. Se la somma complessiva è positiva, Avince.

[*] questo rende le liste singleton con voti fissi come il [1]lavoro, perché a causa della pigrizia di Haskell l'accesso al secondo elemento non viene mai valutato. Gli input come [2]fail con errore, ma non devono essere considerati.

JavaScript (ES6),  78 75  73 byte

$0$$1$$2$$4$$8$

$false$$true$

a=>a.reduce((v,x,i)=>v+~~[,1,-1][p=x?x&3||~-x%7^(p&3||a[i+1]&3):0],p=0)<0

Provalo online!

05AB1E , 34 33 32 30 byte

gFÐNè©2@iNx1.S-èDÄ2‹*D(‚®èNǝ]O

Utilizza un array di numeri interi come input con A=-1, B=1, N=0, X=2, Y=3e genera un numero intero negativo ( <= -1) se A vince, un numero intero positivo ( >= 1) se B vince o 0se è un pareggio.

Provalo online o verifica tutti i casi di test .

Spiegazione:

g             # Take the length of the (implicit) input-list
              #  i.e. [3,1,3,3,2,0,1] → 7
 F            # Loop `N` in the range [0, length):
  Ð           #  Triplicate the list at the top of the stack
              #  (which is the implicit input-list in the first iteration)
   Nè         #  Get the `N`'th item of the list
              #   i.e. [3,1,3,3,2,0,1] and `N`=0 → 3
              #   i.e. [-1,1,-1,3,2,0,1] and `N`=3 → 3
     ©        #  Store it in the register (without popping)
   2@i        #  If it's larger than or equal to 2 (so either 2 or 3):
      Nx      #   Push `N` and `N` doubled both to the stack
              #    i.e. `N`=0 → 0 and 0
              #    i.e. `N`=3 → 3 and 6
        1.S   #   Compare the double integer with 1 (-1 if N*2<1; 0 if N*2==1; 1 if N*2>1)
              #   (So this will be -1 in the first iteration, otherwise it will be 1)
              #    i.e. 0 → -1
              #    i.e. 6 → 1
           -è #   Subtract that from the index, and index it into the list
              #    i.e. `N`=0 and -1 → 1 (first item, so get the next index)
              #     → [3,1,3,3,2,0,1] and 1 → 1
              #    i.e. `N`=3 and 1 → 2 (fourth item, so get the previous index)
              #     → [-1,1,-1,3,2,0,1] and 2 → -1
      D       #   Duplicate that value
       Ä2‹    #   Check if that value is -1, 0, or 1 (abs(i) < 2) (truthy=1; falsey=0)
          *   #   And multiply that with the value
              #   (remains the same if truthy; or becomes 0 if falsey)
      D(‚     #   Pair it with its negative (-1 becomes [-1,1]; 1 becomes [1,-1])
         ®è   #   And index the `N`'th value (from the register) into it (with wraparound)
              #   (if it was a 2, it uses the unchanged (first) value of the pair;
              #    if it was a 3, it uses the negative (second) value of the pair)
              #     i.e. [1,-1] and 3 → -1
              #     i.e. [-1,1] and 3 → 1
      Nǝ      #   And replace the `N`'th value with this
              #    i.e. [3,1,3,3,2,0,1], `N`=0 and -1 → [-1,1,3,3,2,0,1]
              #    i.e. [-1,1,-1,3,2,0,1], `N`=3 and 1 → [-1,1,-1,1,2,0,1]
 ]            # Close both the if-statement and loop
  O           # Sum the modified list (which now only contains -1, 0, or 1)
              #  i.e. [-1,1,-1,1,1,0,1] → 2

Retina 0.8.2 , 70 byte

AY
AB
BY
BA
}`(A|B)X
$1$1
^X(A|B)|^Y[AB]
$1$1
+`N|X|Y|AB|BA

.+|(?<=B)

Provalo online! Il link include casi di test. Uscite 0per un pareggio. Spiegazione:

AY
AB
BY
BA

Gestisci gli Yelettori a destra delle persone con voti decisi.

}`(A|B)X
$1$1

Gestisci gli Xelettori a destra delle persone con voti decisi, quindi torna indietro fino a quando tutto il possibile Ye i Xvoti potranno essere decisi.

^X(A|B)|^Y[AB]
$1$1

Gestire un Xelettore iniziale accanto a un voto deciso e anche un Yelettore iniziale accanto a un voto deciso. Poiché questo elettore voterà in opposizione al voto deciso, in questo caso possiamo semplicemente eliminare entrambi i voti.

+`N|X|Y|AB|BA

Elimina eventuali voti rimanenti o voti indecisi e cancella tutte le coppie di voti contrari decisi. Ripeti fino a quando tutti i voti possibili non vengono cancellati. In caso di pareggio, non sarà lasciato nulla, altrimenti i voti rimanenti saranno tutti dello stesso tipo.

.+|(?<=B)

Output 1se ci sono voti, ma 2se sono Bvoti.

JavaScript (Node.js) , 42 byte

s=>s.map(c=>x+=l=c%2|l*c/2,l=s[x=1]%2)|x>1

Provalo online!

Risparmia 1 byte, grazie a Shaggy.

• Input come array intero dove N = 0, A = -1, B = 1, X = 2, Y = -2;
• Uscita 1 = Falsy, 2 = Verità

Pitone 3 2, 125 121 117 byte

(Grazie a Jonathan Frech)

def f(x):
    for i,v in enumerate(x):n=x[i-(i>0)];x[i]=(v>3)*n+abs(n-1)*(v<0)+x[i]*(0<v<4)
    print x.count(1)>x.count(0)

Utilizzo del rientro della scheda

Input: elenco di ints dove 'A' = 1, 'B' = 0, 'X' = 4, 'N' = 3, 'Y' = - 1, quindi "AAAA" è [1, 1, 1, 1]e "XXAYAN" è [4, 4, 1, -1, 1, 3].

[{'A': 1, 'B': 0, 'X': 4, 'N': 3, 'Y': -1}[c] for c in s] convertirà le stringhe nel formato di input necessario.

Puoi provarlo online! (Grazie a Jonathan Frech per il suggerimento)

Perl 5, 54 byte

s/^\W(?=(\w))|(\w)\K\W/$1^$2^$&/e&&redo;$_=y/A//>y/B//

Provalo online!

Utilizza Aper A, Bper B, Nper N, \0per Xe \3per Y (gli ultimi due sono caratteri di controllo letterali). Il trucco è che Abitwise-xor è \3uguale Be viceversa.

Javascript (ES6) - 133 byte

a=>(i=($=_=>'AB'.search(_)+1)(a[1],o=0),[...a].map(v=>(r=['NAB','NBA']['XY'.search(x)],p=r?r[i]:v,i=$(p),o+='NA'.search(p))),o>0?1:2)

Accetta una stringa con il formato indicato nel PO e restituisce 1 se il candidato 1 ha vinto e 2 altrimenti (lo ammetto, sono di parte).

Python 2 , 95 73 byte

lambda(v):sum([l for l in[2*int(v[1]/2)]for i in v for l in[i*l**(i%2)]])

Provalo online!

• Immettere come array intero in cui N = 0, A = -2, B = 2, X = 1, Y = -1;
• Uscita negativa = A, 0 = disegno, positivo = B
• Se il primo input è X o Y, 2 * int (v [1] / 2) esegue il mapping dei secondi su se stesso o su 0

È stata richiesta la correzione di errori che ha aggiunto byte extra, ma la conversione in lambda grazie a @Stephen lo ha ridotto a 95