Dies ist eine Herausforderung, bei der zwei Personen, 1 und 2, um ein Amt kandidieren. Die Menschen in der Welt von 1 und 2 stimmen deterministisch auf bestimmte Weise ab, so dass die Kandidaten die Ergebnisse vor der Wahl herausfinden können.

HINWEIS: Dies bezieht sich nicht auf externe Wahlen oder andere politische Ereignisse.

Zwei Leute kandidieren. Wir werden diese Leute 1 und 2 nennen. Da beide wissen wollen, ob sie die Wahl gewinnen werden, entscheiden sie sich, ihr Wissen über Leute und einen Code zu nutzen, um herauszufinden, was das Ergebnis sein wird. Um die Staatsausgaben so gering wie möglich zu halten, muss der Kodex so kurz wie möglich sein.

Ihre Aufgabe: Geben Sie anhand einer bestimmten Anzahl von Personen aus, wer die Wahl gewinnt.

In der lustigen und aufregenden Welt von 1 und 2 gibt es fünf Arten von Menschen:

• A: Leute, die definitiv für 1 stimmen werden.
• B: Leute, die definitiv für 2 stimmen werden.
• X: Menschen, die für die Person zu ihrer Linken stimmen, stimmen für. Befindet sich keine Person zu ihrer Linken, stimmen sie für denjenigen, für den die Person zu ihrer Rechten stimmen wird. Wenn nicht klar ist, für wen die Person zu ihrem Recht stimmt, stimmen sie nicht ab.
• Y: Die Leute wählen das Gegenteil der Person zu ihrer Linken. Befindet sich keine Person zu ihrer Linken, stimmen sie entgegengesetzt zu der Person, die sich zu ihrer Rechten befindet. Wenn nicht klar ist, für wen die Person zu ihrem Recht stimmt, stimmen sie nicht ab.
• N: Leute, die nicht wählen.

Dies wird von links nach rechts ausgewertet.

Beispiel:

Wer "evaluiert" wird, wird aus Gründen der Übersichtlichkeit in Kleinbuchstaben angegeben.

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

Abschließende Umfrage:

• 2 Personen haben für 1 gestimmt

• 1 Personen haben für 2 gestimmt

• 3 Personen haben nicht abgestimmt

1 hat die meisten Stimmen, also gewinnt 1!

Testfälle:

Sie können andere Zeichen oder Werte als Eingabe und Ausgabe verwenden, sofern sie unterschiedlich sind. (Zum Beispiel: Zahlen anstelle von Buchstaben, verschiedene Buchstaben, Kleinbuchstaben, wahr / falsch oder positiv / negativ (für die Ausgabe) usw.)

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, um den Fall X oder Y an erster Stelle und A oder B an zweiter Stelle zu behandeln. Ausgabe ist, 1wenn 1 leer gewinnt (falscher Wert in Perl), ansonsten.

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

Die Verwendung von Pund Sanstelle von Xund das YErmöglichen der Verwendung von xor für Zeichen würde weitere Bytes einsparen

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

verwendet eine Verzweigungsrücksetzgruppe (?|.. |.. ), so dass $1 $2auf die entsprechende Gruppe in der Verzweigung verwiesen wird. Verwenden von \0und \3anstelle von XundY

$_=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;}

Verwendet ein Integer-Array als Eingabe für A=1, B=2, N=3, X=4, Y=5und gibt eine positive Ganzzahl ( >= 1) aus, wenn A gewinnt, eine negative Ganzzahl ( <= -1), wenn B gewinnt oder 0wenn es ein Unentschieden ist.

-18 Bytes dank @ OlivierGrégoire .

Probieren Sie es online aus.

Erläuterung:

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

Verwendet 1für A, -1für B, 0für N, 2für Xund 4für Y. Gibt zurück, Truewenn Agewinnt, sonst False.

Probieren Sie es online!

Auf dem rekursiven Weg in der Eingabeliste fügen wir 1für jede Stimme für A, -1für jede Stimme für Bund 0für "keine Stimme" hinzu. list die letzte Abstimmung, vdie nächste. Wenn v=1, -1oder 0(oder v<2), addieren wir es einfach zur Summe. Wenn v"gleich stimmen" ist ( Xin der Herausforderung, 2für meine Lösung), behalten wir und fügen hinzu l( (3-2)*l= l). Wenn v"Gegenstimmen" ( Yin der Herausforderung 4für meine Lösung) ist, negieren wir zuerst l( (3-4)*l= -l) und fügen es dann hinzu. Basisfall ist die leere Liste, mit der die Summe beginnt 0. Die Rekursion beginnt mit lset to rem s 2wheresist das zweite Element der Eingabeliste ( x!!1). rem s 2Karten 1und -1sich selbst, alle anderen Werte an 0. Fixe Stimmen ignorieren lsowieso [*] und Xoder Ybekommen den richtigen Nachbarn, wenn es sich um eine fixe Stimme handelt. Wenn die Gesamtsumme positiv ist, Agewinnt.

[*] Dies macht Singleton-Listen mit festen Stimmen wie [1]Arbeit, weil aufgrund von Haskells Faulheit der Zugriff auf das zweite Element nie ausgewertet wird. Eingaben wie [2]Fehler, müssen aber nicht berücksichtigt werden.

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

Probieren Sie es online!

05AB1E , 34 33 32 30 Bytes

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

Verwendet ein Integer-Array als Eingabe für A=-1, B=1, N=0, X=2, Y=3und gibt eine negative Ganzzahl ( <= -1) aus, wenn A gewinnt, eine positive Ganzzahl ( >= 1), wenn B gewinnt oder 0wenn es ein Unentschieden ist.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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)

Probieren Sie es online! Link enthält Testfälle. Ausgänge0 für einen Gleichstand. Erläuterung:

AY
AB
BY
BA

Griff Y Wähler rechts von Personen mit bestimmten Stimmen.

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

Behandeln Sie die XWähler rechts von Personen mit bestimmten Stimmen und kehren Sie dann zurück, bis alles möglich Yund möglich istX Stimmen Stimmen festgelegt sind.

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

Behandeln Sie einen XErstwähler neben einer beschlossenen Abstimmung und auch eine InitialeY Erstwähler neben einer abgegebenen Stimme. Da dieser Wähler entgegen der beschlossenen Stimme abstimmt, können wir in diesem Fall einfach beide Stimmen streichen.

+`N|X|Y|AB|BA

Löschen Sie alle verbleibenden nicht stimmberechtigten oder unentschiedenen Stimmen und streichen Sie alle Paare entgegengesetzter entschiedener Stimmen aus. Wiederholen, bis alle möglichen Stimmen gelöscht sind. Bei Stimmengleichheit bleibt nichts übrig, ansonsten sind alle übrigen Stimmen gleich.

.+|(?<=B)

1Wird ausgegeben, wenn Stimmen vorhanden sind, aber 2wenn sie BStimmen sind.

JavaScript (Node.js) , 42 Byte

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

Probieren Sie es online!

Dank Shaggy 1 Byte sparen.

• Eingabe als Integer-Array mit N = 0, A = -1, B = 1, X = 2, Y = -2;
• Ausgang 1 = falsch, 2 = wahr

Python 3 2, 125 121 117 Bytes

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

Tabulator-Einrückung verwenden

Eingabe: Liste von ints mit 'A' = 1, 'B' = 0, 'X' = 4, 'N' = 3, 'Y' = - 1, also "AAAA" [1, 1, 1, 1]und "XXAYAN" [4, 4, 1, -1, 1, 3].

[{'A': 1, 'B': 0, 'X': 4, 'N': 3, 'Y': -1}[c] for c in s] konvertiert die Zeichenketten in das benötigte Eingabeformat.

Sie können es online ausprobieren! (Danke an Jonathan Frech für den Vorschlag)

Perl 5, 54 Bytes

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

Probieren Sie es online!

Verwendungen Afür die A, Bfür die B, Nfür die N, \0für Xund \3für Y (die letzten beiden Zeichen literal Steuer wird). Der Trick ist, dass Abitweises x oder \3gleich Bist und umgekehrt.

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)

Übernimmt eine Zeichenfolge mit dem im OP angegebenen Format und gibt 1 zurück, wenn Kandidat 1 gewonnen hat, und 2, wenn nicht (ich gebe es zu, ich bin sogar voreingenommen).

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

Probieren Sie es online!

• Eingabe als Integer-Array mit N = 0, A = -2, B = 2, X = 1, Y = -1;
• Ausgang negativ = A, 0 = Unentschieden, positiv = B
• Wenn die erste Eingabe X oder Y ist, wird 2 * int (v [1] / 2) auf sich selbst oder auf 0 abgebildet

Es war eine Fehlerbehebung erforderlich, die zusätzliche Bytes hinzufügte, aber durch die Konvertierung in Lambda dank @Stephen auf 95 reduziert wurde