Il Blackjack , noto anche come ventuno, è un gioco di carte a confronto tra te e un mazziere, in cui ogni giocatore a sua volta compete contro il mazziere, ma i giocatori non giocano l'uno contro l'altro.

Il gioco procede come segue, il banco ti offre una carta. Il mazziere quindi distribuisce a se stesso una carta, coperta. Il mazziere ti offre quindi un'altra carta. Infine, il mazziere distribuisce a se stesso una carta, scoperta.

Sfida

La tua sfida è quella di scrivere un programma (o una funzione) che quando viene eseguito (o chiamato), genera (o restituisce) la probabilità che la prossima carta che ti dà il mazziere ti faccia sballare, il che significa che il punteggio cumulativo delle carte nella tua mano dopo il banco ti dà un'altra carta ha più di 21 anni.

Ingresso

Le tre carte visibili in gioco. Sono le due carte che hai in mano e l'unica carta che puoi vedere nella mano del mazziere. Questo può essere in qualsiasi formato che ritieni adatto alla tua applicazione.

Ci sono 52 carte in un mazzo (4 di ciascuna delle carte sottostanti). Il valore delle carte è il seguente:

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 

Nel Blackjack, un asso può contare come 1 o 11. Nella nostra sfida, conta solo come 1

Produzione

La probabilità, in un formato proporzionale o percentuale, che la prossima carta che pesciamo ci farà sballare.

È possibile generare la percentuale, la frazione o solo il numeratore della frazione.

Esempi

In questo esempio, le prime due carte sono nella nostra mano, la terza è la carta visibile del banco

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

Regole

Non sono ammesse scappatoie standard .

Questo è code-golf , quindi vince il codice più breve in byte per ogni lingua!

Gelatina ,  26  24 byte

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

Un collegamento monadico che accetta un elenco di caratteri (utilizzando l'opzione minuscola O l'opzione maiuscola con 1for A) che restituisce il numeratore (il numero di 49 ^° s) in [0,49].

Provalo online! Oppure vedi la suite di test

Come?

Si noti che utilizzando minuscole il minimo di 10 e il modulo ordinale per 48 fornisce i valori della carta. Lo stesso vale per maiuscole T, J, Q, Ke 1per un asso, come mostrato a destra (ma un maiuscole Anon funziona):

     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

Accetta input come una matrice di 3 caratteri con 1for assi. Restituisce il numero intero X che rappresenta la probabilità X / 49 da eliminare.

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

Provalo online!

Test esaustivo

La formula del golf non è molto intuitiva. Quindi, il modo più semplice per dimostrare la sua coerenza è probabilmente quello di confrontare tutti i possibili risultati con quelli forniti da un'implementazione di base non controllata:

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

Provalo online!

Pyth, 35 byte

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

Accetta l'input come un elenco di caratteri (o come stringa).
Provalo qui

Spiegazione

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

Provalo 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)

Provalo online!

Accetta una stringa di 3 caratteri come input, con '1' utilizzato come asso. Restituisce il numeratore.

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

Porta della risposta JavaScript (ES6) di @Arnauld .
Input come array di caratteri con tre valori, Assi come '1'; l'output è la probabilità pin p/49.

Provalo online.

Spiegazione:

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/

Provalo online!

Questo può essere fatto meglio, lavorando su di esso.

05AB1E , 23 22 21 byte

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

Provalo 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