Wer wird die Wahl gewinnen?


32

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)

1
@EriktheOutgolfer ANNY ist dasselbe wie nur A NN. Aus NX und NY wird NN.
Genosse SparklePony

5
Es kann sinnvoll sein, nonedas Gegenteil von anzugeben none, wenn das Verhalten NYin den Kommentaren korrekt ist.
Kamil Drakari

1
IMHO sollte es Testfälle , beginnend mit XA, XB, YAund YB.
Neil

1
Darf die Eingabe nur 1 Buchstaben enthalten? zB "A", "X", "Y", "N".
Dienstag,

2
Muss die Ausgabe zwei unterschiedliche Werte haben, oder können wir zum Beispiel eine positive Ganzzahl ausgeben, wenn 1 gewinnt, und eine negative Ganzzahl, wenn 2 gewinnt?
Kevin Cruijssen

Antworten:


9

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


Nach meinem letzten Verständnis werden sie nicht mehr gezählt
Nahuel Fouilleul

Dies funktioniert nicht richtig Xund Yam Anfang der Zeichenfolge. Versuchen Sie XBAund YAB.
Grimmy

@ Grimy, aktualisiert
Nahuel Fouilleul

9

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)

i=0;for(int n:a)i+=n<2?1:n<3?-1:0;return i>0;spart ein paar Bytes Bytes.
Olivier Grégoire

1
Eigentlich i=0;for(int n:a)i+=n>2?0:3-n*2;return i>0;ist es noch kürzer.
Olivier Grégoire

@ OlivierGrégoire Danke! Als ich Ihren ersten Kommentar sah, wollte ich etwas kürzeres finden, aber Sie haben mich mit Ihrem zweiten Kommentar geschlagen. ;)
Kevin Cruijssen

1
131 Bytes durch Zusammenführen der zweiten Schleife in der ersten. Es fühlt sich jedoch nicht richtig an und es müssen möglicherweise einige Testfälle hinzugefügt werden ...
Olivier Grégoire,

@ OlivierGrégoire Danke! Es war möglich, 4 weitere Bytes zu golfen, indem es mit der Variablen "temp" zusammengeführt wurde. Und was fühlt sich falsch an? Wenn Sie eine System.out.println(java.util.Arrays.toString(a));nach der Schleife hinzufügen , können Sie sehen, dass sie sich erwartungsgemäß geändert hat (imo). Welche Art von Testfall führt Ihrer Meinung nach zu einem falschen Ergebnis und aufgrund welchen Teils des Codes?
Kevin Cruijssen

8

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.



1
@ Grimy: danke für den Hinweis. Fest.
nimi

6

JavaScript (ES6),  78 75  73 Bytes

01248

feinlsetrue

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!


4

05AB1E , 34 33 32 30 Bytes

gFÐNè©2@iNx1.S-è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

3

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.


3

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

2
Ihr TIO scheint auszugeben 0, 1und 3anstelle von 1und 2?
Kevin Cruijssen

1
@ KevinCruijssen Aber OP erlaubt Wahrheit gegen Falsch als Ausgabe, wenn ich richtig verstehe. Falsch bedeutet, dass 1 das Spiel gewonnen hat, und wahrheitsgemäß bedeutet, dass 2 gewonnen hat.
Dienstag,

Ah ok, vergessen 3ist auch in JS wahr. Ich denke immer an 0/ 1als falsch / wahr. Und da wir keine eindeutigen Ausgaben mehr benötigen, sind 0= 1 Siege und >= 1= 2 Siege ebenfalls in Ordnung. Also +1 von mir.
Kevin Cruijssen

Es sieht so aus, als könnten Sie ein Byte mit bitweisem ODER anstelle von logischem ODER speichern.
Shaggy

@ Shaggy So seltsam. Es klappt.
Dienstag,

2

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)


Hallo und willkommen bei PPCG. Ich würde empfehlen, TIO zu verwenden , da es Ihren Code schön formatiert. Außerdem verstehe ich Ihr Eingabeformat nicht ganz. Möglicherweise müssen Sie das OP nach seiner Gültigkeit fragen.
Jonathan Frech

Als Golftipp (i, i-1)[i>0]sollte man gleichwertig sein i-(i>0).
Jonathan Frech

Außerdem ifkönnte Ihr s wahrscheinlich werden x[i]+=(v>3)*n+abs(n-1)*(v<0). Sie können dann Einrückungen einsparen, indem Sie die jetzt nicht zusammengesetzte Anweisung (mit ;) in dieselbe Zeile wie die verschieben for.
Jonathan Frech

@ JonathanFrech Vielen Dank; Ich hoffe, ich habe die Eingabe besser erklärt
user24343

1

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.


es nutzt viele Ideen meiner Antwort, ich war nicht sicher , können wir nicht druckbare Zeichen als Eingabe und Ausgabe verwenden, außer ich nicht die Vergünstigung der Verwendung von umgekehrten Schrägstrich Klassen ahnten
Nahuel FOUILLEUL

1

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


1

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


74 Bytes durch Entfernen von Leerzeichen und Ändern der Funktion in eine Lambda-Funktion
Stephen
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.