Il s'agit d'un défi dans lequel deux personnes, 1 et 2, se présentent aux élections. Les gens votent de manière déterministe de certaines façons dans le monde de 1 et 2, ce qui peut permettre aux candidats de déterminer les résultats avant l'élection.

REMARQUE: ceci n'est pas destiné à faire référence à des élections extérieures ou à d'autres événements politiques.

Deux personnes se présentent aux élections. Nous appellerons ces personnes 1 et 2. Parce qu'ils veulent tous les deux savoir s'ils gagneront l'élection, ils décident d'utiliser leur connaissance des gens et un code pour déterminer le résultat. En raison de la volonté de minimiser les dépenses publiques, le code doit être aussi court que possible.

Votre tâche: compte tenu d'une chaîne de personnes en fonction de la façon dont ils votent, affichez qui remporte l'élection.

Il existe cinq types de personnes dans le monde amusant et excitant de 1 et 2:

• A: les gens qui voteront certainement pour 1.
• B: des gens qui voteront définitivement pour 2.
• X: les personnes qui voteront pour la personne à leur gauche voteront pour. S'il n'y a personne à leur gauche, alors ils votent pour celui pour qui la personne à leur droite votera. S'il n'est pas clair pour qui la personne à leur droite vote, alors ils ne votent pas.
• Y: les gens voteront l'opposé de la personne à leur gauche. S'il n'y a personne à leur gauche, alors ils votent en face de celui qui est à leur droite. S'il n'est pas clair pour qui la personne à leur droite vote, alors ils ne votent pas.
• N: les gens qui ne votent pas.

Ceci est évalué de gauche à droite.

Exemple:

Celui qui est "évalué" est en minuscules, pour plus de clarté.

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

Sondage final:

• 2 personnes ont voté pour 1

• 1 personnes ont voté pour 2

• 3 personnes n'ont pas voté

1 a le plus de votes, donc 1 gagne!

Cas de test:

Vous pouvez utiliser d'autres caractères ou valeurs en entrée et en sortie, tant qu'ils sont distincts. (Par exemple: des chiffres au lieu de lettres, des lettres différentes, des lettres minuscules, véridiques / fausses ou positives / négatives (pour la sortie), 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 octets

+26 octets pour gérer le cas X ou Y en première position et A ou B en seconde. la sortie est 1si 1 gagne vide (fausse valeur en perl) sinon.

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

utiliser Pet Sau lieu de Xet Ypermettre d'utiliser l'opération xor sur les caractères, permettrait d'économiser encore plus d'octets

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

utilise un groupe de réinitialisation de branche (?|.. |.. ), de sorte que la $1 $2référence au groupe correspondant dans la branche. Utilisation de \0et \3au lieu de XetY

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

72 octets

65 octets

53 octets

Java 8, 153 141 135 131 129 octets

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

Utilise un tableau d'entiers comme entrée avec A=1, B=2, N=3, X=4, Y=5et génère un entier positif (>= 1 ) si A gagne, un entier négatif ( <= -1) si B gagne, ou 0s'il s'agit d'un tirage.

-18 octets grâce à @ OlivierGrégoire .

Essayez-le en ligne.

Explication:

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 octets

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

Utilise 1pour A, -1pour B, 0pour N, 2pour Xet 4pour Y. Renvoie Truesi Agagne, sinon False.

Essayez-le en ligne!

Sur le chemin récursif vers le bas de la liste de saisie, nous ajoutons 1pour chaque vote pour A, -1pour chaque vote pour Bet 0pour "aucun vote". lest le dernier vote, vle prochain. Si v=1, -1ou 0(ou v<2) nous l'ajoutons simplement à la somme. Si vc'est "voter la même chose" ( Xdans le défi, 2pour ma solution) nous gardons et ajoutons l( (3-2)*l= l). Si vc'est "voter en face" ( Ydans le défi, 4pour ma solution) nous nions d'abord l( (3-4)*l= -l) puis nous l'ajoutons. Le cas de base est la liste vide qui commence la somme avec0 . La récursion est démarrée avec lla valeur rem s 2oùsest le deuxième élément de la liste d'entrée ( x!!1). rem s 2cartes 1et obtiennent le bon voisin s'il s'agit d'un vote fixe. Si la somme globale est positive, gagne.-1à lui-même, toutes les autres valeurs à 0. Corriger les votes ignorer lquand même [*] et XouYA

[*] cela fait des listes singleton avec des votes fixes comme du [1]travail, car en raison de la paresse de Haskell, l'accès au deuxième élément n'est jamais évalué. Les entrées comme [2]échouent avec erreur, mais ne doivent pas être prises en compte.

JavaScript (ES6),  78 75  73 octets

$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

Essayez-le en ligne!

05AB1E , 34 33 32 30 octets

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

Utilise un tableau entier comme entrée avec A=-1, B=1, N=0, X=2, Y=3 et produit un entier négatif ( <= -1) si A gagne, un entier positif ( >= 1) si B gagne, ou 0s'il s'agit d'un tirage.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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 octets

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

.+|(?<=B)

Essayez-le en ligne! Le lien inclut des cas de test. Sorties 0pour une égalité. Explication:

AY
AB
BY
BA

Gérez les Yélecteurs à la droite des personnes avec des votes décisifs.

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

Gérez les Xélecteurs à la droite des personnes avec des votes décisifs, puis faites une boucle jusqu'à ce que tous les votes Yet Xdécisions soient possibles.

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

Gérez un Xélecteur initial à côté d'un vote décidé, ainsi qu'un Yélecteur initial à côté d'un vote décidé. Comme cet électeur votera à l'opposé du vote décidé, nous pouvons simplement supprimer les deux votes dans ce cas.

+`N|X|Y|AB|BA

Supprimez tous les votes restants ou indécis et annulez toutes les paires de votes opposés. Répétez jusqu'à ce que tous les votes possibles soient annulés. En cas d'égalité, rien ne restera, sinon les votes restants seront tous du même type.

.+|(?<=B)

Sortie 1s'il y a des votes, mais 2si ce sont des Bvotes.

JavaScript (Node.js) , 42 octets

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

Essayez-le en ligne!

Économisez 1 octet grâce à Shaggy.

• Entrée sous forme de tableau entier où N = 0, A = -1, B = 1, X = 2, Y = -2;
• Sortie 1 = Falsy, 2 = Truthy

Python 3 2 125 121 117 octets

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

Utilisation de la mise en retrait des tabulations

Entrée: liste de ints où 'A' = 1, 'B' = 0, 'X' = 4, 'N' = 3, 'Y' = - 1, donc "AAAA" est [1, 1, 1, 1]et "XXAYAN" est [4, 4, 1, -1, 1, 3].

[{'A': 1, 'B': 0, 'X': 4, 'N': 3, 'Y': -1}[c] for c in s] convertira les chaînes au format d'entrée requis.

Vous pouvez l' essayer en ligne! (Merci à Jonathan Frech pour la suggestion)

Perl 5, 54 octets

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

Essayez-le en ligne!

Utilise Apour A, Bpour B, Npour N, \0pour Xet \3pour Y (les deux derniers étant des caractères de contrôle littéraux). L'astuce est que Abit-xor \3est égal à B, et vice-versa.

Javascript (ES6) - 133 octets

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)

Prend une chaîne avec le format donné dans l'OP et renvoie 1 si le candidat 1 a gagné et 2 sinon (je l'admets, je suis même biaisé).

Python 2 , 95 73 octets

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

Essayez-le en ligne!

• Entrée sous forme de tableau entier où N = 0, A = -2, B = 2, X = 1, Y = -1;
• Sortie négative = A, 0 = tirage, positive = B
• Si la première entrée est X ou Y, alors 2 * int (v [1] / 2) mappe la seconde à lui-même ou 0

Une correction de bogue a été nécessaire pour ajouter des octets supplémentaires, mais la conversion en lambda grâce à @Stephen l'a réduite à 95