Blackjack , znany również jako dwadzieścia jeden, to gra karciana polegająca na porównywaniu siebie z krupierem, w której każdy gracz z kolei rywalizuje z krupierem, ale gracze nie grają przeciwko sobie.

Gra przebiega w następujący sposób, krupier rozdaje ci kartę. Następnie krupier rozdaje kartę zakrytą kartą. Następnie rozdaje ci kolejną kartę. W końcu krupier rozdaje kartę odkrytą.

Wyzwanie

Twoim wyzwaniem jest napisanie programu (lub funkcji), który po uruchomieniu (lub wywołaniu) generuje (lub zwraca) prawdopodobieństwo, że następna karta, którą da ci dealer, sprawi, że odpadniesz, co oznacza łączny wynik kart w twojej ręce po krupier daje ci kolejną kartę powyżej 21 lat.

Wejście

Trzy widoczne karty w grze. Są to dwie karty, które masz w ręce, i jedna karta, którą możesz zobaczyć w ręce rozdającego. Może być w dowolnym formacie odpowiednim dla twojej aplikacji.

W talii znajduje się 52 karty (4 z każdej z poniższych kart). Wartości kart są następujące:

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 

W blackjacku as może liczyć się jako 1 lub 11. W naszym wyzwaniu liczymy go tylko jako 1

Wynik

Prawdopodobieństwo, w formacie proporcji lub procentu, że następna karta, którą wyciągniemy, nas rozbije.

Możesz podać procent, ułamek lub tylko licznik ułamka.

Przykłady

W tym przykładzie pierwsze dwie karty są w naszej ręce, trzecia karta jest widoczną kartą rozdającego

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

Zasady

Standardowe luki są niedozwolone.

To jest golf golfowy , więc wygrywa najkrótszy kod w bajtach dla każdego języka!

Galaretka ,  26  24 bajtów

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

Monadycznego związek przyjmowania listę znaków (stosując albo małą lub opcji górna skrzynka Z 1na A), które zwraca licznik (liczba 49 ^p y) w [0,49].

Wypróbuj online! Lub zobacz pakiet testowy

W jaki sposób?

Zauważ, że używając małej litery minimum 10, a liczba rzędnych modulo 48 daje wartości karty. To samo dotyczy wielkich liter T, J, Q, Ki 1dla asa, jak pokazano po prawej stronie (ale wielkimi literami Anie działa):

     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 bajtów

Pobiera dane jako tablicę 3 znaków z 1asami. Zwraca liczbę całkowitą X reprezentującą prawdopodobieństwo odpadnięcia X / 49 .

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

Wypróbuj online!

Wyczerpujący test

Gra w golfa nie jest zbyt intuicyjna. Zatem najłatwiejszym sposobem udowodnienia jego spójności jest prawdopodobnie porównanie wszystkich możliwych wyników z wynikami dostarczonymi przez podstawową niestosowną implementację:

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

Wypróbuj online!

Pyth, 35 bajtów

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

Pobiera dane wejściowe jako listę znaków (lub ciąg znaków).
Wypróbuj tutaj

Wyjaśnienie

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 bajtów

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

Wypróbuj online!

Python 2 , 97 96 bajtów

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)

Wypróbuj online!

Pobiera 3-znakowy ciąg znaków jako wejście, a „1” jest używane jako as. Zwraca licznik.

Java 8, 109 bajtów

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 odpowiedzi JavaScript (ES6) @Arnauld .
Wprowadź jako tablicę znaków z trzema wartościami, Aces as '1'; wyjście jest prawdopodobieństwem pw p/49.

Wypróbuj online.

Wyjaśnienie:

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 bajtów

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

Wypróbuj online!

Można to zrobić lepiej, pracując nad tym.

05AB1E , 23 22 21 bajtów

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

Wypróbuj online!

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