Golf un buteur de golf

25

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 1 , 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!


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

DJMcMayhem
la source

Réponses:

3

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 ( mQ):
    • 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.

PurkkaKoodari
la source
11

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))
Sp3000
la source
5

> <> , 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

Sok
la source
J'ai vu que vous avez utilisé 0=?ou similaire plusieurs fois - pouvez-vous utiliser à la ?!place?
Sp3000
@ Sp3000 Ack, bien sûr, vous avez raison. Merci, je vais ajouter ça dans
Sok
5

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
Luis Mendo
la source
4

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 .

Maltysen
la source
2
"Cela semble beaucoup trop grand, mais FGITW." Alors jouez au golf en premier?
chat
Je n'ai pas vu cela avant d'avoir fini le mien, mais ils sont presque identiques sauf en utilisant Jet Ksemblent totalement inutiles, et vous pouvez également +_-+*15/Q12-sm*d%/Qd2{>#2<#11Qs@S2
jouer
1
@FryAmTheEggman 24:+*15/Q12-s*R%/Qd2}3Ts@S2
Jakube
3

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
Neil
la source
0

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
}
wastl
la source