Als Kind habe ich oft das Kartenspiel " Golf " gespielt . Ihre Herausforderung besteht darin, die Punktzahl einer Golfhand zu berechnen, falls Sie diese akzeptieren möchten. Da es über 9000 Variationen zu diesem Kartenspiel ^{1 gibt} , werden wir die Regeln einhalten, an die ich mich erinnere.

Spielregeln)

• Sie beenden eine Runde mit 6 Karten und möchten so wenig Punkte wie möglich.

• Joker werden nicht verwendet.

• Asse und 2er sind jeweils -1 und -2 Punkte wert.

• Buben und Könige sind beide 0 Punkte wert.

• Karten von 3 bis 10 sind den Nennwert wert. Diese werden jedoch abgebrochen, wenn Sie sie abkoppeln. Zum Beispiel ist eine 5 5 Punkte wert, aber zwei 5 sind Null wert. Drei 5s sind 5 Punkte wert (da die ersten 2 abgeglichen sind, die dritte nicht) und vier 5s sind 0 wert (da es 2 Paare ergibt).

• Königinnen sind 15 Punkte wert. Königinnen können nicht storniert werden, zB sind 2 Königinnen 30 Punkte wert.

Regeln (der Herausforderung)

Die Eingabe besteht aus einem Array von Ganzzahlen oder 6 einzelnen Ganzzahlen. Welches Sie bevorzugen. 1 stellt ein Ass dar, 2-10 stellt 2-10 dar und Jack, Queen und King stellen 11, 12 und 13 dar. Die Ausgabe ist die Punktzahl der Hand gemäß den obigen Regeln. Sie können davon ausgehen, dass alle Eingaben gültig sind, z. B. dass keine Zahl mehr als viermal vorkommt und alle Zahlen im Bereich liegen [1, 13]. Eingabe und Ausgabe können in jedem vernünftigen Format erfolgen.

Test IO:

[11, 10, 3, 1, 2, 2]    --> 8
[4, 5, 5, 3, 8, 7]      --> 22
[2, 2, 2, 2, 1, 1]      --> -10 (The lowest score possible)
[12, 12, 12, 12, 10, 9] --> 79 (The highest score possible)
[9, 9, 9, 9, 11, 1]     --> -1
[8, 8, 8, 8, 11, 13]    --> 0
[10, 9, 3, 7, 12, 2]    --> 42
[1, 2, 3, 4, 5, 6]      --> 15
[10, 9, 2, 3, 4, 1]     --> 23
[10, 3, 12, 3, 7, 12]   --> 47

Kürzeste Antwort in Bytes gewinnt!

¹ nicht wirklich, aber es gibt viele Variationen.

Pyth, 28 27 25 Bytes

s+*L%/Qd2}3Tm?<d3_d*15q12

Probieren Sie es online aus. Testsuite.

Erläuterung

• Erstens hängt Pyth einige Variablen automatisch an. Der Code ist jetzt s+*L%/Qd2}3Tm?<d3_d*15q12dQ.
• }3Tgeneriert die Liste [3, 4, 5, 6, 7, 8, 9, 10].
• Multiplizieren Sie jede Zahl in dieser Liste ( *L) mit der Anzahl dieser Zahl in der Eingabe ( /Qd), Modulo 2 ( %… 2). Das Ergebnis ist 0 für gepaarte Nummern und die Nummer selbst für nicht gepaarte Nummern.
• Karte über die Eingabenummern ( m… Q):
  • Wenn die Zahl kleiner als 3 ( ?<d3) ist, negieren Sie sie ( _d).
  • Überprüfen Sie andernfalls, ob es 12 ( q12d) ist, und multiplizieren Sie den Booleschen Wert mit 15 ( *15). Das Ergebnis ist 15 für Königinnen und 0 für alles andere.
• Verketten Sie die Listen ( +). Die resultierende Liste enthält nun die Punktzahlen für die nicht gepaarten Zahlen (der erste Teil) und die Spezialkarten A, 2, Q (der zweite Teil) mit einigen zusätzlichen Nullen.
• Schließlich nehmen Sie die Summe des Ergebnisses ( s).

Alternative 25-Byte-Lösung

-+s*L%/Qd2}3T*15/Q12s<#3Q

Dies funktioniert ähnlich wie das erste, zählt jedoch die Damen separat und negiert die Asse und Zweien mit einem Filter.

Python 2, 72-70 Bytes

f=lambda x,*T:[x*(-1)**T.count(x),~x%2*15,-x][(x-3)/8]+(T>()and f(*T))

Irgendwann wünschte ich mir, Python würde 0**0 == 0einmal behandelt, damit ich es tun könnte (-condition)**num. Rufen Sie gerne an f(11, 10, 3, 1, 2, 2).

Vorherige 72-Byte-Version:

f=lambda x,*T:[~x%2*15,x*(-1)**(x<3or T.count(x))][x<11]+(T>()and f(*T))

> <> , 63 57 56 + 2 = 65 59 58 Bytes

Es wird erwartet, dass sich die Eingabenummern beim Programmstart auf dem Stack befinden, also +2 Bytes für das -vFlag. Probieren Sie es online!

</!?lp6$+1g6:
3\0
?\::6g2%*{+}1+:b=
;\~16g-26g2*-c6gf*+n

Da alle nicht verwendeten Werte im Codefeld mit initialisiert werden, 0können Sie ermitteln, wie viele Werte auf dem Stapel vorhanden sind, indem Sie den Wert auf [value,6]abrufen, inkrementieren und wieder in das Codefeld einfügen. Die Summe wird dann berechnet als:

T = 0 + {for x in 3 to 10, x*([x,6]%2)} - [1,6] - 2*[2,6] + 15*[12,6]

Bearbeiten: 6 Bytes auslassen, indem die Eingabe umstrukturiert und die Berechnungsschritte umgeschaltet werden. Vorherige Version:

:6g1+$6pl0=?\
/-*2g62-g610/
c ;n$\
6:b=?/>::6g2%*{+}1+!
\gf*+3/

Edit 2: 1 Byte gespeichert, dank Sp3000

MATL , 27 26 Bytes

3:10=s2\7M*G12=15*Gt3<*_vs

Die Eingabe ist ein Spaltenarray, dh Werte werden durch Semikolon getrennt.

Probieren Sie es online! oder überprüfen Sie alle Testfälle (dies fügt eine Schleife hinzu, um alle Eingaben zu übernehmen, und ersetzt Gdurch 1$0G, um die neuesten Eingaben zu übertragen).

Erläuterung

3:10=    % Take input implicitly. Compare with range [3 4 ... 10], with broadcast
s        % Sum of each column: how may threes, fours, ... tens there are
2\       % Modulo 2
7M       % Push [3 4 ... 10] again
*        % Element-wise multiply (the sum of this array is the score of 3...10)
G        % Push input again
12=      % Compare with 12, element-wise
15*      % Multiply by 15 (this is the score of 12)
G        % Push input again
t3<      % Duplicate. True for entries 1 or 2
*_       % Multiply and negate (the sum of this array is the score of 1, 2)
v        % Concatenate all stack concents into a vertical array
s        % Sum of array. Implicitly display

Pyth - 37 36 35

Das scheint viel zu groß, aber FGITW.

J<#h;K-QS2++*15/K12sm*d%/Jd2{J_s@S2

Test Suite .

JavaScript (ES6), 63 Byte

a=>a.map(e=>r+=e<3?-e:e>10?e-12?0:15:(m[e]^=1)?e:-e,r=0,m=[])|r

Oder wenn Sie es vorziehen,

a=>a.map(e=>r-=e<3?e:e>10?e-12?0:-15:(m[e]^=1)?-e:e,r=0,m=[])|r

Perl 5 , 74 +1 ( -a) = 75 Bytes

map$s+=/12/?15:$_<3?-$_:$_<11?$k{$_}?-delete$k{$_}:($k{$_}=$_):0,@F;say $s

Probieren Sie es online!

Perl 5.10.0 + -n, 115 64 60 56 Bytes

$p+=$_-12?$_>2?$_<11?++$l[$_]%2?$_:-$_:0:-$_:15}{say$p

Probieren Sie es online!

Erläuterung:

Hinzufügen der -nSchleife:

# Used variables:
# $_: input (auto)
# $p: points
# $l[n]: number of occurences of n (for 3-10)
while (<>) { # for every input
    $p += $_ - 12 ? # if the input is not 12 (queen) ...
        $_ > 2 ? # then: if it's > 2 (not ace or 2) ...
            $_ < 11 ? # then: if < 11 (3-10) ...
                ++$l[$_] % 2 ? # then: if it's an odd occurence (1st, 3rd, 5th, ...)
                    $_ # add it
                    : -$_ # else subtract it
            : 0 # no points for other stuff (J, K)
        : -$_ # negative points for ace and 2
    : 15 # 15 points for queen
}
{ # after input:
    say $p # output points
}