Блэкджек , также известный как двадцать один, представляет собой сравнение карточной игры между вами и дилером, где каждый игрок в свою очередь конкурирует с дилером, но игроки не играют друг против друга.

Игра идет следующим образом, дилер сдает вам карту. Затем дилер сдает себе карту лицом вниз. Затем дилер сдает вам другую карту. Затем, наконец, дилер сдает себе карту лицом вверх.

Вызов

Ваша задача состоит в том, чтобы написать программу (или функцию), которая при запуске (или вызове) выдает (или возвращает) вероятность того, что следующая карта, которую вам даст дилер, вызовет у вас банкротство, что означает совокупный счет карт в вашей руке после Дилер дает вам еще одну карту старше 21 года.

вход

Три видимые карты в игре. Это две карты, которые у вас есть в руке, и карта с одним лицом, которую вы можете видеть в руке дилера. Это может быть в любом формате, который вы считаете подходящим для вашего приложения.

В колоде 52 карты (по 4 карты ниже). Ценность карт следующая:

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 

В Блэкджеке туз может считаться 1 или 11. В нашем вызове только 1

Выход

Вероятность того, что следующая карта, которую мы вытянем, в процентном или процентном формате заставит нас обанкротиться.

Вы можете вывести процент, дробь или просто числитель дроби.

Примеры

В этом примере первые две карты находятся в нашей руке, третья карта является видимой картой дилера.

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

правила

Стандартные лазейки не допускаются.

Это код-гольф , поэтому выигрывает самый короткий код в байтах для каждого языка!

Желе ,  26  24 байта

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

Монадическая ссылка принимает список символов ( с использованием либо опции нижнего регистра или варианта верхнего регистра с 1по A) , которая возвращает числитель (количество 49 - ^й ы) в [0,49].

Попробуйте онлайн! Или посмотрите набор тестов

Как?

Обратите внимание, что при использовании строчных букв минимум 10 и порядковые числа по модулю 48 дают значения карт. То же самое справедливо для верхнего регистра T, J, Q, Kи 1для асе, как показано справа (но символ верхнего регистра 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 байта

Принимает ввод в виде массива из 3 символов с 1для тузов. Возвращает целое число X, представляющее вероятность того, что X / 49 будет уничтожен.

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

Попробуйте онлайн!

Исчерпывающий тест

Формула гольфа не очень интуитивно понятна. Таким образом, самый простой способ доказать его непротиворечивость, вероятно, состоит в том, чтобы просто сравнить все возможные выходные данные с результатами, предоставляемыми базовой незакрашенной реализацией:

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

Попробуйте онлайн!

Pyth, 35 байтов

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

Вводит в виде списка символов (или в виде строки).
Попробуй здесь

объяснение

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 байт

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

Попробуйте онлайн!

Python 2 , 97 96 байт

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)

Попробуйте онлайн!

Принимает 3-символьную строку в качестве входных данных, причем «1» используется в качестве туза. Возвращает числитель.

Java 8, 109 байт

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

Порт ответа @Arnauld 's JavaScript (ES6) .
Ввод как массив символов с тремя значениями, Aces as '1'; Выход - это вероятность pв p/49.

Попробуйте онлайн.

Объяснение:

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 байтов

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

Попробуйте онлайн!

Это можно сделать лучше, работая над этим.

05AB1E , 23 22 21 байт

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

Попробуйте онлайн!

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