Blackjack , juga dikenal sebagai dua puluh satu, adalah permainan kartu perbandingan antara Anda dan dealer, di mana setiap pemain bersaing melawan dealer, tetapi pemain tidak bermain melawan satu sama lain.

Mainkan berjalan sebagai berikut, dealer memberi Anda kartu. Dealer kemudian memberi mereka kartu, menghadap ke bawah. Dealer kemudian memberi Anda kartu lain. Lalu akhirnya, dealer memberi mereka kartu, menghadap ke atas.

Tantangan

Tantangan Anda adalah menulis sebuah program (atau fungsi) yang ketika dijalankan (atau dipanggil), mengeluarkan (atau mengembalikan) probabilitas bahwa kartu berikutnya yang diberikan dealer akan membuat Anda bangkrut, yang berarti skor kumulatif kartu di tangan Anda setelah dealer memberi Anda kartu lain lebih dari 21.

Memasukkan

Tiga kartu yang terlihat sedang dimainkan. Mereka adalah dua kartu yang Anda miliki di tangan Anda, dan satu kartu wajah yang dapat Anda lihat di tangan dealer. Ini bisa dalam format apa pun yang Anda temukan cocok untuk aplikasi Anda.

Ada 52 kartu dalam satu tumpukan (masing-masing 4 kartu di bawah). Nilai kartu adalah sebagai berikut:

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 

Dalam Blackjack, kartu As dapat dihitung sebagai 1 atau 11. Dalam tantangan kami, hanya menghitung sebagai 1

Keluaran

Probabilitas, dalam format rasio atau persentase, bahwa kartu berikutnya yang kita gambar akan membuat kita bangkrut.

Anda dapat menampilkan persentase, fraksi, atau hanya pembilang fraksi.

Contohnya

Dalam contoh ini, dua kartu pertama ada di tangan kita, kartu ketiga adalah kartu terlihat dealer

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

Aturan

Tidak ada celah standar .

Ini adalah kode-golf , jadi kode terpendek dalam byte untuk setiap bahasa menang!

Jelly ,  26  24 byte

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

Sebuah link monadik menerima daftar karakter (baik menggunakan opsi-huruf kecil OR opsi-huruf dengan 1untuk A) yang mengembalikan pembilang (jumlah 49 ^th s) di [0,49].

Cobalah online! Atau lihat test-suite

Bagaimana?

Perhatikan bahwa dengan menggunakan huruf kecil, minimum 10 dan modulo dengan 48 memberikan nilai kartu. Hal yang sama berlaku untuk huruf besar T, J, Q, Kdan 1untuk ace, seperti yang ditunjukkan di sebelah kanan (tapi-huruf Atidak bekerja):

     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

Mengambil input sebagai array 3 karakter dengan 1untuk kartu As. Mengembalikan integer X yang menunjukkan probabilitas X / 49 untuk ditembus.

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

Cobalah online!

Tes yang melelahkan

Formula golf tidak sangat intuitif. Jadi, cara termudah untuk membuktikan konsistensinya mungkin adalah dengan hanya membandingkan semua output yang mungkin dengan yang disediakan oleh implementasi dasar yang tidak disatukan:

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

Cobalah online!

Pyth, 35 byte

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

Mengambil input sebagai daftar karakter (atau sebagai string).
Coba di sini

Penjelasan

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

Cobalah online!

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)

Cobalah online!

Mengambil string 3 karakter sebagai input, dengan '1' digunakan sebagai Ace. Mengembalikan pembilang.

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

Port dari jawaban JavaScript (ES6) @Arnauld .
Input sebagai karakter-array dengan tiga nilai, Aces sebagai '1'; output adalah probabilitas pdalam p/49.

Cobalah online.

Penjelasan:

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/

Cobalah online!

Ini bisa dilakukan dengan lebih baik, mengerjakannya.

05AB1E , 23 22 21 byte

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

Cobalah 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