Este es un desafío en el que dos personas, 1 y 2, se postulan para un cargo. La gente vota de manera determinista de ciertas maneras en el mundo de 1 y 2, lo que puede permitir que los candidatos descubran los resultados antes de las elecciones.

NOTA: esto no pretende referirse a elecciones externas u otros eventos políticos.

Dos personas se postulan para un cargo. Llamaremos a estas personas 1 y 2. Como ambos quieren saber si ganarán las elecciones, deciden usar su conocimiento de las personas y algún código para determinar cuál será el resultado. Debido al deseo de minimizar el gasto del gobierno, el código debe ser lo más breve posible.

Su tarea: dada una serie de personas en función de cómo están votando, salida que gana las elecciones.

Hay cinco tipos de personas en el divertido y emocionante mundo de 1 y 2:

• A: personas que definitivamente votarán por 1.
• B: personas que definitivamente votarán por 2.
• X: las personas que votarán por quien votará la persona a su izquierda. Si no hay una persona a su izquierda, entonces votan por quien votará la persona a su derecha. Si no está claro por quién vota la persona a su derecha, entonces no votan.
• Y: la gente votará lo contrario de la persona a su izquierda. Si no hay una persona a su izquierda, entonces votan lo contrario de quien está a su derecha. Si no está claro por quién vota la persona a su derecha, entonces no votan.
• N: personas que no votan.

Esto se evalúa de izquierda a derecha.

Ejemplo:

Quien está siendo "evaluado" está en minúsculas, para mayor claridad.

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

Encuesta final:

• 2 personas votaron por 1

• 1 personas votaron por 2

• 3 personas no votaron

¡1 tiene la mayoría de los votos, entonces 1 gana!

Casos de prueba:

Puede usar otros caracteres o valores como entrada y salida, siempre que sean distintos. (Por ejemplo: números en lugar de letras, letras diferentes, letras minúsculas, verdadero / falso o positivo / negativo (para salida), etc.)

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 bytes

+26 bytes para manejar el caso X o Y en la primera posición y A o B en la segunda. la salida es 1si 1 gana vacío (valor falso en perl) de lo contrario.

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

utilizando P y en Slugar de Xy Ypermitiendo usar la operación xor en caracteres, ahorraría algunos bytes más

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

utiliza un grupo de reposición rama (?|.. |.. ), de modo que $1 $2refiriéndose al grupo correspondiente en la rama. Utilizando\0 y en \3lugar de XyY

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

72 bytes

65 bytes

53 bytes

Java 8, 153 141 135 131 129 bytes

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

Utiliza una matriz de enteros como entrada A=1, B=2, N=3, X=4, Y=5y genera un entero positivo ( >= 1) si A gana, un entero negativo ( <= -1) si B gana o 0si es un empate.

-18 bytes gracias a @ OlivierGrégoire .

Pruébalo en línea.

Explicación:

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 bytes

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

Usos 1para A, -1para B, 0para N, 2para Xy 4para Y. Devuelve Truesi Agana, de lo contrario False.

Pruébalo en línea!

En el camino recursivo hacia abajo de la lista de entrada, agregamos 1por cada voto a favor A, -1por cada voto a favor By 0para "no votar". lEs la última votación, vla siguiente. Si v=1, -1o 0(o v<2) simplemente lo agregamos a la suma. Si ves "votar igual" ( Xen el desafío, 2para mi solución) guardamos y agregamos l( (3-2)*l= l). Si ves "voto opuesto" ( Yen el desafío, 4para mi solución) primero negamos l( (3-4)*l= -l) y luego lo agregamos. El caso base es la lista vacía con la que comienza la suma,0 . La recursión se inicia con lset to rem s 2whereses el segundo elemento de la lista de entrada ( x!!1). rem s 2mapas 1y -1a sí mismo, todos los demás valores a 0. Ignorar los votos fijos de ltodos modos [*] y / Xo Yobtener el vecino correcto si es un voto fijo. Si la suma total es positiva, Agana.

[*] esto hace listas singleton con votos fijos como [1]trabajo, porque debido a la pereza de Haskell, el acceso al segundo elemento nunca se evalúa. Las entradas como [2]falla con error, pero no tienen que ser consideradas.

JavaScript (ES6),  78 75  73 bytes

$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

Pruébalo en línea!

05AB1E , 34 33 32 30 bytes

gFÐNè©[email protected]èDÄ2‹*D(‚®èNǝ]O

Utiliza una matriz de enteros como entrada A=-1, B=1, N=0, X=2, Y=3y genera un entero negativo ( <= -1) si A gana, un entero positivo ( >= 1) si B gana o 0si es un empate.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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 bytes

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

.+|(?<=B)

Pruébalo en línea! El enlace incluye casos de prueba. Salidas 0para un empate. Explicación:

AY
AB
BY
BA

Manejar a los Yvotantes a la derecha de las personas con votos decididos

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

Maneje a los Xvotantes a la derecha de las personas con votos decididos, y luego regrese hasta que sea posible Yy Xse puedan decidir los votos.

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

Maneje un Xvotante inicial junto a un voto decidido, y también un Yvotante inicial junto a un voto decidido. Como este votante votará en oposición al voto decidido, simplemente podemos eliminar ambos votos en este caso.

+`N|X|Y|AB|BA

Elimine cualquier voto restante sin voto o indeciso, y cancele todos los pares de votos decididos opuestos. Repita hasta que se cancelen todos los votos posibles. En caso de empate, no quedará nada; de lo contrario, todos los votos restantes serán del mismo tipo.

.+|(?<=B)

Salida 1si hay votos, pero 2si son Bvotos.

JavaScript (Node.js) , 42 bytes

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

Pruébalo en línea!

Ahorre 1 bytes, gracias a Shaggy.

• Ingrese como matriz entera donde N = 0, A = -1, B = 1, X = 2, Y = -2;
• Salida 1 = Falsy, 2 = Verdad

Pitón 3 2, 125 121 117 bytes

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

Usar sangría de pestañas

Entrada: lista de ints donde 'A' = 1, 'B' = 0, 'X' = 4, 'N' = 3, 'Y' = - 1, entonces "AAAA" es [1, 1, 1, 1]y "XXAYAN" es [4, 4, 1, -1, 1, 3].

[{'A': 1, 'B': 0, 'X': 4, 'N': 3, 'Y': -1}[c] for c in s] convertirá las cadenas al formato de entrada necesario.

¡Puedes probarlo en línea! (Gracias a Jonathan Frech por la sugerencia)

Perl 5, 54 bytes

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

Pruébalo en línea!

Utiliza Apara A, Bpara B, Npara N, \0para Xy \3para Y (los dos últimos son caracteres de control literal). El truco es que Abitwise-xor \3es igual B, y viceversa.

Javascript (ES6) - 133 bytes

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)

Toma una cadena con el formato dado en el OP y devuelve 1 si el candidato 1 ganó y 2 de lo contrario (lo admito, soy parcial).

Python 2 , 95 73 bytes

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

Pruébalo en línea!

• Ingrese como matriz entera donde N = 0, A = -2, B = 2, X = 1, Y = -1;
• Salida negativa = A, 0 = dibujar, positiva = B
• Si la primera entrada es X o Y, entonces 2 * int (v [1] / 2) se asigna en segundo lugar a sí mismo o 0

Se requirió la corrección de errores que agregaba bytes adicionales, pero la conversión a lambda gracias a @Stephen lo redujo nuevamente a 95