Le Blackjack , également connu sous le nom de vingt et un ans, est un jeu de cartes comparatif entre vous et un croupier, où chaque joueur à son tour rivalise avec le croupier, mais les joueurs ne jouent pas les uns contre les autres.

Le jeu se déroule comme suit, le croupier vous offre une carte. Le croupier se donne ensuite une carte, face cachée. Le croupier vous offre alors une autre carte. Enfin, le croupier se donne une carte face visible.

Défi

Votre défi consiste à écrire un programme (ou une fonction) qui, lorsqu'il est exécuté (ou appelé), génère (ou renvoie) la probabilité que la prochaine carte que le croupier vous donne vous fera exploser, ce qui signifie le score cumulé des cartes dans votre main après le croupier vous donne une autre carte a plus de 21 ans.

Contribution

Les trois cartes visibles en jeu. Ce sont les deux cartes que vous avez en main et la carte à un visage que vous pouvez voir dans la main du croupier. Cela peut être dans le format que vous jugez approprié pour votre application.

Il y a 52 cartes dans un jeu (4 de chacune des cartes ci-dessous). La valeur des cartes est la suivante:

Symbol(Case Insensitive)  Name     Value
2                         Two      2
3                         Three    3
4                         Four     4
5                         Five     5
6                         Six      6
7                         Seven    7
8                         Eight    8
9                         Nine     9
T                         Ten      10
J                         Jack     10
Q                         Queen    10
K                         King     10
A or 1                    Ace      1 

Au Blackjack, un as peut compter comme 1 ou 11. Dans notre défi, ne le compte que comme 1

Production

La probabilité, sous forme de rapport ou de pourcentage, que la prochaine carte que nous piocherons nous fera exploser.

Vous pouvez afficher le pourcentage, la fraction ou simplement le numérateur de la fraction.

Exemples

Dans cet exemple, les deux premières cartes sont dans notre main, la troisième carte est la carte visible du croupier

 Input          ->       Output

 A 2 Q          ->       0.00%  or  0/49 or 0
 A 2 3          ->       0.00%  or  0/49 or 0
 T T T          ->       91.84% or 45/49 or 91.84 
 T J K          ->       91.84% or 45/49 or 45
 9 7 3          ->       61.22% or 30/49 ...
 9 7 Q          ->       59.18% or 29/49 ...

Règles

Les échappatoires standard ne sont pas autorisées.

Il s'agit de code-golf , donc le code le plus court en octets pour chaque langue gagne!

Gelée ,  26  24 octets

O%48«⁵µ13R«⁵ẋ4œ-+ṖS$>21S

Un lien monadique acceptant une liste de caractères (en utilisant soit l'option minuscule OU l'option majuscule avec 1pour A) qui renvoie le numérateur (le nombre de 49 ^ème ) en [0,49].

Essayez-le en ligne! Ou consultez la suite de tests

Comment?

Notez qu'en utilisant des minuscules, le minimum de 10 et les ordinaux modulo par 48 donnent les valeurs de la carte. De même pour les majuscules T, J, Q, Ket 1pour un as, comme indiqué sur le droit (mais une majuscule Ane fonctionne pas):

     card:   a   2   3   4   5   6   7   8   9   t   j   q   k   |   1   T   J   Q   K
  ordinal:  97  50  51  52  53  54  55  56  57 116 106 113 107   |  49  84  74  81  75
   mod 48:   1   2   3   4   5   6   7   8   9  20  10  17  11   |   1  36  26  33  27
min(_,10):   1   2   3   4   5   6   7   8   9  10  10  10  10   |   1  10  10  10  10

O%48«⁵µ13R«⁵ẋ4œ-+ṖS$>21S - Link: list of characters   e.g. "q3a"
O                        - ordinals (of the input list)    [113, 51, 97]
 %48                     - modulo by 48                    [17,3,1]
     ⁵                   - ten
    «                    - minimum                         [10,3,1]
      µ                  - start a new monadic chain
       13R               - range of 13                     [1,2,3,4,5,6,7,8,9,10,11,12,13]
           ⁵             - ten                             10
          «              - minimum                         [1,2,3,4,5,6,7,8,9,10,10,10,10]
            ẋ4           - repeat four times               [1,2,3,4,5,6,7,8,9,10,10,10,10,1,2,3,4,5,6,7,8,9,10,10,10,10,1,2,3,4,5,6,7,8,9,10,10,10,10,1,2,3,4,5,6,7,8,9,10,10,10,10]
              œ-         - multi-set difference            [1,2,3,4,5,6,7,8,9,10,10,10,10,1,2,3,4,5,6,7,8,9,10,10,10,10,1,2,3,4,5,6,7,8,9,10,10,10,10  ,2  ,4,5,6,7,8,9   ,10,10,10]
                   $     - last two links as a monad:
                 Ṗ       -   pop                           [10,3]
                  S      -   sum                           13
                +        - add (vectorises)                [14,15,16,17,18,19,20,21,22,23,23,23,23,14,15,16,17,18,19,20,21,22,23,23,23,23,14,15,16,17,18,19,20,21,22,23,23,23,23,15,17,18,19,20,21,22,23,23,23]
                    >21  - greater than 21?                [0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1]
                       S - sum                             19

JavaScript (ES6), 73 62 octets

Prend l'entrée sous forme de tableau de 3 caractères avec 1pour les as. Renvoie l'entier X représentant la probabilité que X / 49 soit cassé.

a=>([b,c]=a.map(v=>v*4||40)).map(n=>b-=n+b>52,b+=c-32)|b>12&&b

Essayez-le en ligne!

Test exhaustif

La formule golfée n'est pas très intuitive. Ainsi, le moyen le plus simple de prouver sa cohérence est probablement de simplement comparer toutes les sorties possibles avec celles fournies par une implémentation de base non golfée:

g = a => {
  deck = [...'123456789TJQK'.repeat(4)];
  a.forEach(card => deck.splice(deck.indexOf(card), 1));

  return deck.filter(card =>
    (+a[0] || 10) +
    (+a[1] || 10) +
    (+card || 10) > 21
  ).length;
}

Essayez-le en ligne!

Pyth, 35 octets

Jm?}dGTsdQclf>T-21sPJ.-*4+ST*3]TJ49

Prend la saisie sous forme de liste de caractères (ou sous forme de chaîne).
Essayez-le ici

Explication

Jm?}dGTsdQclf>T-21sPJ.-*4+ST*3]TJ49
Jm?}dGTsdQ                            Convert each input to the appropriate number.
                     .-*4+ST*3]TJ     Remove each from the deck.
           lf>T-21sPJ                 Count how many remaining cards bust.
          c                      49   Get the probability.

Perl 5 , 115 octets

map{//;$k{$_}=4-grep$' eq$_,@F}1..9,T,J,Q,K;map{s/\D/10/}@F;$_=grep{$F[0]+$F[1]+$_>21}map{(s/\D/10/r)x$k{$_}}keys%k

Essayez-le en ligne!

Python 2 , 97 96 octets

def f(s):C=[min(int(c,36),10)for c in s];D=C[0]+C[1];return(4*D-35+sum(v+D<22for v in C))*(D>11)

Essayez-le en ligne!

Prend une chaîne de 3 caractères en entrée, «1» étant utilisé comme as. Renvoie le numérateur.

Java 8, 109 octets

a->{int r=3;for(;r-->0;a[r]=a[r]<59?a[r]*4-192:40);r=a[0]+a[1]-32;for(int v:a)r-=v+r>52?1:0;return r>12?r:0;}

Port de la réponse JavaScript (ES6) de @Arnauld .
Entrez comme tableau de caractères avec trois valeurs, As comme '1'; sortie est la probabilité pen p/49.

Essayez-le en ligne.

Explication:

a->{                   // Method with integer-array as parameter and integer return-type
  int r=3;for(;r-->0;  //  Loop over the array
    a[r]=a[r]<59?      //   If the current item is a digit:
          a[r]*4-192   //    Multiply it by 4
         :             //   Else:
          40);         //    Change it to 40
  r=a[0]+a[1]-32;      //  Set `r` to the first value, plus the second value, minus 32
  for(int v:a)         //  Loop over the now modified array again
    r-=v+r>52?         //   If the current value plus `r` is larger than 52
        1              //    Decrease the result-integer by 1
       :0;             //   Else: Leave the result-integer the same
  return r>12?         //  If the result-integer is larger than 12
          r            //   Return the result-integer
         :             //  Else:
          0;}          //   Return 0

05AB1E , 46 octets

Y9ŸJ.•§®т•«Á4שsð.;#S|UεX‚˜ε®sk>T‚W}O21›}DOsg/

Essayez-le en ligne!

Cela peut être mieux fait en travaillant dessus.

05AB1E , 23 22 21 octets

AST:4-D¨OÐ4@*4*Š+T@O-

Essayez-le en ligne!

AST:                   # replace all letters in the input with 10
    4-                 # subtract 4 from each card value
      D                # duplicate
       ¨               # drop the last element
        O              # sum (hand value of the player - 8)
         Ð             # triplicate that
          4@*          # set to 0 if it's less than 4
             4*        # multiply by 4
               Š       # 3-way swap
                +      # add the player's hand value to each card value
                 T@O   # count how many are >= 10
                    -  # subtract