Blackjack , auch bekannt als einundzwanzig, ist ein Kartenspiel zwischen Ihnen und einem Dealer, bei dem jeder Spieler seinerseits gegen den Dealer antritt, die Spieler jedoch nicht gegeneinander spielen.

Das Spiel läuft wie folgt ab, der Dealer gibt Ihnen eine Karte. Der Dealer gibt sich dann verdeckt eine Karte aus. Der Dealer gibt Ihnen dann eine weitere Karte. Dann gibt sich der Dealer selbst eine offene Karte.

Herausforderung

Ihre Herausforderung besteht darin, ein Programm (oder eine Funktion) zu schreiben, das beim Ausführen (oder Aufrufen) die Wahrscheinlichkeit ausgibt (oder zurückgibt), dass die nächste Karte, die der Dealer Ihnen gibt, Sie pleite macht, was die kumulierte Punktzahl der Karten in Ihrer Hand danach bedeutet Der Dealer gibt Ihnen eine andere Karte ist über 21.

Eingang

Die drei sichtbaren Karten im Spiel. Dies sind die zwei Karten, die Sie auf der Hand haben, und die eine Bildkarte, die Sie in der Hand des Händlers sehen können. Dies kann in jedem Format erfolgen, das Sie für Ihre Anwendung für geeignet halten.

Es gibt 52 Karten in einem Deck (4 von jeder der Karten unten). Der Wert der Karten ist wie folgt:

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 

Beim Blackjack kann ein Ass als 1 oder 11 zählen. In unserer Herausforderung zählen Sie es nur als 1

Ausgabe

Die Wahrscheinlichkeit, dass die nächste Karte, die wir ziehen, in einem Verhältnis- oder Prozentformat dazu führt, dass wir pleite gehen.

Sie können den Prozentsatz, den Bruch oder nur den Zähler des Bruchs ausgeben.

Beispiele

In diesem Beispiel sind die ersten beiden Karten in unserer Hand, die dritte Karte ist die sichtbare Karte des Händlers

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

Regeln

Standardlücken sind nicht erlaubt.

Dies ist Code-Golf , also gewinnt der kürzeste Code in Bytes für jede Sprache!

Gelee ,  26  24 Bytes

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

A monadischen Link eine Liste von Zeichen (unter Verwendung entweder die Kleine Option oder die Großbuchstabe Option Akzeptieren 1für A) , die den Zähler zurückkehrt (die Anzahl des 49 - ^ten n) in [0,49].

Probieren Sie es online aus! Oder sehen Sie sich die Testsuite an

Wie?

Beachten Sie, dass bei Verwendung von Kleinbuchstaben das Minimum von 10 und die Ordnungszahlen modulo von 48 die Kartenwerte ergeben. Das gleiche gilt für Großbuchstaben T, J, Q, Kund 1für ein Ass, wie auf der rechten Seite (aber ein Ober Fall Anicht funktioniert):

     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 Byte

Nimmt die Eingabe als Array von 3 Zeichen mit 1für Asse auf. Gibt die Ganzzahl X zurück, die die Wahrscheinlichkeit darstellt, dass X / 49 gesprengt wird.

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

Probieren Sie es online aus!

Vollständiger Test

Die Golfformel ist nicht sehr intuitiv. Der einfachste Weg, um seine Konsistenz zu beweisen, besteht wahrscheinlich darin, alle möglichen Ergebnisse mit denen zu vergleichen, die von einer einfachen Implementierung ohne Wolf bereitgestellt werden:

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

Probieren Sie es online aus!

Pyth, 35 Bytes

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

Nimmt die Eingabe als Liste von Zeichen (oder als Zeichenfolge) auf.
Probieren Sie es hier aus

Erläuterung

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 Bytes

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

Probieren Sie es online aus!

Python 2 , 97 96 Bytes

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)

Probieren Sie es online aus!

Nimmt eine 3-stellige Zeichenfolge als Eingabe, wobei '1' als Ass verwendet wird. Gibt den Zähler zurück.

Java 8, 109 Bytes

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 der JavaScript (ES6) -Antwort von @Arnauld .
Eingabe als Zeichenarray mit drei Werten, Asse als '1'; Ausgabe ist die Wahrscheinlichkeit pin p/49.

Probieren Sie es online aus.

Erläuterung:

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 Bytes

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

Probieren Sie es online aus!

Dies kann besser gemacht werden, wenn man daran arbeitet.

05AB1E , 23 22 21 Bytes

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

Probieren Sie es online aus!

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