Blackjack , còn được gọi là hai mươi mốt, là một trò chơi so sánh giữa bạn và người chia bài, trong đó mỗi người chơi lần lượt cạnh tranh với người chia bài, nhưng người chơi không chơi với nhau.

Chơi như sau, các đại lý giao dịch cho bạn một thẻ. Các đại lý sau đó giao dịch với họ - tự một thẻ, úp mặt. Các đại lý sau đó giao dịch cho bạn một thẻ khác. Cuối cùng, các đại lý giao dịch với họ - tự mình làm thẻ, ngửa mặt.

Thử thách

Thử thách của bạn là viết một chương trình (hoặc chức năng) mà khi chạy (hoặc được gọi), xuất ra (hoặc trả về) xác suất mà thẻ tiếp theo mà đại lý cung cấp cho bạn sẽ khiến bạn bị phá sản, có nghĩa là số điểm tích lũy của thẻ trong tay bạn sau các đại lý cung cấp cho bạn một thẻ khác là hơn 21.

Đầu vào

Ba thẻ nhìn thấy trong chơi. Chúng là hai thẻ bạn có trong tay và thẻ một mặt bạn có thể nhìn thấy trong tay đại lý. Điều này có thể ở bất kỳ định dạng nào bạn thấy phù hợp với ứng dụng của bạn.

Có 52 thẻ trong một cỗ bài (4 trong số mỗi thẻ bên dưới). Giá trị của các thẻ như sau:

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 

Trong Blackjack, một con át chủ bài có thể được tính là 1 hoặc 11. Trong thử thách của chúng tôi, chỉ tính nó là 1

Đầu ra

Xác suất, theo định dạng tỷ lệ hoặc tỷ lệ phần trăm, rằng thẻ tiếp theo chúng tôi rút ra sẽ khiến chúng tôi phá sản.

Bạn có thể xuất tỷ lệ phần trăm, phân số hoặc chỉ tử số của phân số.

Ví dụ

Trong ví dụ này, hai thẻ đầu tiên nằm trong tay chúng ta, thẻ thứ ba là thẻ hiển thị của đại lý

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

Quy tắc

Sơ hở tiêu chuẩn không được phép.

Đây là môn đánh gôn , vì vậy mã ngắn nhất tính theo byte cho mỗi ngôn ngữ sẽ thắng!

Thạch ,  26  24 byte

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

Một liên kết monadic chấp nhận một danh sách các nhân vật (sử dụng một trong hai tùy chọn thấp hơn trường hợp HOẶC tùy chọn chữ hoa với 1cho A) mà trả về tử số (số lượng 49 ^thứ s) trong [0,49].

Hãy thử trực tuyến! Hoặc xem bộ thử nghiệm

Làm sao?

Lưu ý rằng bằng cách sử dụng chữ thường, mức tối thiểu là 10 và số thứ tự modulo bằng 48 sẽ cho các giá trị thẻ. Điều này cũng giữ cho chữ hoa T, J, Q, Kvà 1cho một ace, như hiển thị bên phải (mà là một hợp cụ thể trên Akhông làm việc):

     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

Đưa đầu vào dưới dạng một mảng gồm 3 ký tự 1cho aces. Trả về số nguyên X đại diện cho xác suất X / 49 được trả lại.

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

Hãy thử trực tuyến!

Kiểm tra toàn diện

Công thức chơi golf không trực quan lắm. Vì vậy, cách dễ nhất để chứng minh tính nhất quán của nó có lẽ là chỉ so sánh tất cả các kết quả đầu ra có thể với các kết quả được cung cấp bởi một triển khai vô căn bản cơ bản:

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

Hãy thử trực tuyến!

Bình thường, 35 byte

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

Đưa đầu vào dưới dạng danh sách các ký tự (hoặc dưới dạng chuỗi).
Hãy thử nó ở đây

Giải trình

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 byte

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

Hãy thử trực tuyến!

Python 2 , 97 96 byte

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)

Hãy thử trực tuyến!

Lấy chuỗi 3 ký tự làm đầu vào, với '1' được sử dụng làm Ace. Trả về tử số.

Java 8, 109 byte

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

Cảng @Arnauld JavaScript (ES6) câu trả lời 's .
Nhập dưới dạng mảng ký tự với ba giá trị, Aces as '1'; đầu ra là xác suất ptrong p/49.

Hãy thử trực tuyến.

Giải trình:

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 byte

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

Hãy thử trực tuyến!

Điều này có thể được thực hiện tốt hơn, làm việc trên nó.

05AB1E , 23 22 21 byte

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

Hãy thử trực tuyến!

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