Enfant, je jouais le jeu de cartes « golf » beaucoup. Votre défi, si vous l'acceptez, est de calculer le score d'une main de golf. Puisqu'il y a plus de 9000 variations sur ce jeu de cartes ¹ , nous suivrons les règles dont je me souviens avoir joué.

Règles du jeu)

• Vous terminez un tour avec 6 cartes et vous voulez le moins de points possible.

• Les jokers ne sont pas utilisés.

• Les as et les 2 valent respectivement -1 et -2 points.

• Jacks et Kings valent tous les deux 0 points.

• Les cartes de 3 à 10 valent leur valeur nominale. Cependant, ceux-ci sont annulés lorsque vous les associez. Par exemple, un 5 vaut 5 points, mais deux 5 valent zéro. Trois 5 valent 5 points (puisque les 2 premiers sont appariés, mais pas le 3e) et quatre 5 valent 0 (car cela fait 2 paires).

• Les reines valent 15 points. Les reines ne peuvent pas être annulées, par exemple 2 reines valent 30 points.

Règles (du défi)

L'entrée sera un tableau d'entiers, ou 6 entiers individuels. Celui que vous préférez. 1 représente un as, 2-10 représente 2-10, et Jack, Queen et King représentent 11, 12 et 13. La sortie est le score de la main selon les règles ci-dessus. Vous pouvez supposer en toute sécurité que toutes les entrées sont valides, par exemple aucun numéro n'apparaît plus de 4 fois, et tous les nombres sont dans la plage [1, 13]. L'entrée et la sortie peuvent être dans n'importe quel format raisonnable.

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

La réponse la plus courte en octets gagne!

¹ pas vraiment, mais il y a beaucoup de variations.

Pyth, 28 27 25 octets

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

Essayez-le en ligne. Suite de tests.

Explication

• Tout d'abord, Pyth ajoute automatiquement certaines variables. Le code est maintenant s+*L%/Qd2}3Tm?<d3_d*15q12dQ.
• }3Tgénère la liste [3, 4, 5, 6, 7, 8, 9, 10].
• Multipliez chaque nombre de cette liste ( *L) par le nombre de ce nombre dans l'entrée ( /Qd), modulo 2 ( %… 2). Le résultat est 0 pour les numéros appariés et le numéro lui-même pour les numéros non appariés.
• Carte sur les numéros d'entrée ( m… Q):
  • Si le nombre est inférieur à 3 ( ?<d3), annulez-le ( _d).
  • Sinon, vérifiez si c'est 12 ( q12d) et multipliez le booléen par 15 ( *15). Le résultat est 15 pour les reines et 0 pour tout le reste.
• Concatène les listes ( +). La liste résultante contient maintenant les scores des numéros non appariés (la première partie) et des cartes spéciales A, 2, Q (la deuxième partie), avec quelques zéros supplémentaires.
• Enfin, prenez la somme du résultat ( s).

Solution alternative de 25 octets

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

Cela fonctionne de manière similaire à la première, mais compte les reines séparément et annule les as et les deux avec un filtre.

Python 2, 72 70 octets

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

À un moment donné, j'ai souhaité que Python soit traité 0**0 == 0pour une fois afin que je puisse le faire (-condition)**num. Appelez comme f(11, 10, 3, 1, 2, 2).

Version précédente de 72 octets:

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 octets

Les numéros d'entrée devraient être sur la pile au démarrage du programme, donc +2 octets pour l' -vindicateur. Essayez-le en ligne!

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

Comme toutes les valeurs inutilisées dans le champ de code sont initialisées à 0, il peut être utilisé pour déterminer combien de chaque valeur est présente sur la pile en obtenant la valeur à [value,6], en l'incrémentant et en la replaçant dans le champ de code. Le total est alors calculé comme:

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

Edit: golfé de 6 octets en restructurant l'entrée et en inversant les étapes de calcul. La version précédente:

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

Edit 2: sauvé 1 octet, grâce au Sp3000

MATL , 27 26 octets

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

L'entrée est un tableau de colonnes, c'est-à-dire que les valeurs sont séparées par des points-virgules.

Essayez-le en ligne! ou vérifiez tous les cas de test (cela ajoute une boucle pour prendre toutes les entrées et remplace Gpar 1$0Gpour pousser la dernière entrée).

Explication

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

Cela semble beaucoup trop grand, mais FGITW.

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

Suite de tests .

JavaScript (ES6), 63 octets

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

Ou si vous préférez,

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 octets

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

Essayez-le en ligne!

Perl 5.10.0 + -n, 115 64 60 56 octets

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

Essayez-le en ligne!

Explication:

Ajout de la -nboucle autour d'elle:

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