Bringing Down the House

În timp ce Henry, Hetty și Harry dorm în casele lor din Anglia, Charles a plecat să facă în continuare curățenie – în cazinourile din Las Vegas. El va petrece $10$ zile în acel oraș, încercând să câștige cât mai mulți bani la masa de Blackjack. În cazinourile frecventate de Charles, jocul de Blackjack se desfășoară după următoarele reguli:

Desfășurarea jocului

În fiecare din cele $10$ seri, Charles pleacă de acasă cu o sumă de bani $money$ și se așează la o masă de joc la care se mai alfă doar dealerul (cel care împarte cărțile). Jocul se desfășoară în etape, numite mâini. O mână se desfășoară astfel:

1. Charles pariază o sumă de bani $bet$ pe mâna curentă. Natural, Charles nu are voie să parieze mai mulți bani decât deține în acel moment.
2. Dealerul pune pe masă o carte cu fața în sus – aceasta este prima carte a dealerului.
3. Charles primește două cărți.
4. Cât timp suma valorilor cărților lui Charles (vom nota această sumă cu $C$) nu depășește $21$, Charles are opțiunea să mai ceară o carte. Acest pas se repetă până Charles anunță că nu mai dorește cărți. Charles este obligat să anunțe că nu mai dorește cărți dacă $C$ a depășit $21$.
5. Dealerul trage cărți din pachet până când suma valorilor cărților lui (să o notăm cu $D$) depășește $16$.
6. Charles primește înapoi bani corespunzător rezultatului mâinii, astfel:
   • $2 \times bet$ – dacă $C > D$ și $C \leq 21$, sau dacă $C \leq 21$ și $D > 21$.
   • $bet$ – dacă $C = D$ și $C \leq 21$, sau dacă $C > 21$ și $D > 21$
   • $0$ – dacă $C < D$ și $D \leq 21$, sau dacă $C > 21$ și $D \leq 21$.

Cărțile

În jocul de Blackjack se folosesc cărțile aferente a $nPacks$ pachete standard de $52$ de cărți ($4$ cărți pentru fiecare număr de la $2$ la $10$, plus $4$ ași $(A)$, $4$ popi $(K)$, $4$ dame $(Q)$ și $4$ valeți $(J)$). Cărțile numererotate au valoarea egală cu numărul înscris pe ele, popii, damele și valeții au valoarea $10$, iar un as poate să ia fie valoarea $1$ fie valoarea $11$ (la decizia jucătorului).

Suma valorilor unui set de cărți se definește ca cea mai mare sumă ce se poate forma din valorile acelor cărți astfel încât aceasta să nu depășească $21$. În caz că acest lucru nu este posibil, suma valorilor setului de cărți se definește ca fiind cea mai mică sumă ce se poate forma din valorile acelor cărți. Exemple: suma valorilor setului $(A, J)$ este $21$, a setului $(A, A)$ este $12$ (unul din ași ia valoarea $1$, celălalt $11$), a setului $(A, 9, 8)$ este $18$, iar a setului $(A, 10, 9, 8)$ este $28$.

La începutul jocului, cărțile sunt amestecate și sunt puse într-un teanc cu fața în jos. Pe parcursul jocului, cărțile se împart din vârful teancului. Odată folosite pentru o mână, cărțile nu vor mai fi folosite pentru o alta până la o reamestecare a pachetului. După ce se termină o mână și în teanc se află mai puțin de $45$ de cărți, toate cărțile sunt reamestecate. Jocul din seara respectivă continuă până când cărțile sunt amestecate $T$-a oară.

Cerință

După $10$ nopți de joc intens, Charles s-a întors acasă cu un profit considerabil. Voi puteți atinge același succes ca Charles? Scrieți un program care ține locul lui Charles într-un joc de Blackjack jucat după regulile descrise mai sus, cu scopul de a câștiga cât mai mulți bani la finalul jocului.

Interacțiune

Pentru a rezolva această problemă va trebui ca în sursa voastră să existe următoarele $3$ funcții:

void startGame(int money, int nPacks);

Această funcție este apelată de exact $10$ ori, semnificând faptul că jucătorul începe un joc nou. Ea primește ca parametru suma $money$ de bani cu care începe să joace concurentul în acel joc și numărul $nPacks$ de pachete care se vor folosi pentru joc.

void playHand();

Această funcție va fi apelată de fiecare dată când se va juca o mână. Interacțiunea dintre programul comisiei și această funcție se realizează conform cu pașii de desfășurare a unei mâini descriși în enunț, și anume:

1. Concurentul apelează funcția

   int placeBet(int bet)
   

   pentru a paria o sumă de bani bet pe mâna curentă. Funcția returnează suma de bani pe care o mai are concurentul după ce a făcut pariul.
2. Concurentul apelează o singură dată funcția

   int getDealerCard()
   

   care returnează valoarea primei cărți a dealerului.
3. Concurentul apelează de două ori funcția

   int getCard()
   

   pentru a afla valorile primelor două cărți ale sale. Funcția returnează valoarea unei cărți primite de concurent.
4. Cât timp suma $C$ a valorilor cărților sale nu depășește $21$, concurentul poate apela din nou getcard pentru a cere o nouă carte. Funcția returnează valoarea cărții primite. Acest pas se repetă până concurentul apelează funcția

   void stand()
   

   prin care anunță că nu mai dorește cărți. Atenție! În cazul în care, după ce concurentul a primit o carte, suma $C$ a depășit $21$, concurentul este obligat să apeleze stand.
5. Pentru a afla cărțile pe care dealerul le trage din pachet, concurentul apelează repetat

   int getOutcome()
   

   fiecare apel al acestei funcții returnând valoarea unei cărți trase de dealer sau $0$ dacă dealerul s-a oprit din a trage cărți. După ce funcția getOutcome a returnat 0 aceasta nu se mai apelează pentru mâna curentă. Reamintim că dealerul trage cărți din pachet până când suma valorilor cărților lui (să o notăm cu $D$) depășește $16$.
6. Concurentul apelează o singură dată

   int cashIn()
   

   pentru a afla câți bani primește înapoi. Funcția returnează suma primită de concurent după ce a jucat o mână. Reamintim că această sumă este:
   • $2 \times bet$ – dacă $C > D$ și $C \leq 21$, sau dacă $C \leq 21$ și $D > 21$.
   • $bet$ – dacă $C = D$ și $C \leq 21$, sau dacă $C > 21$ și $D > 21$
   • $0$ – dacă $C < D$ și $D \leq 21$, sau dacă $C > 21$ și $D < 21$.

Ca să rezumăm, ordinea în care jucătorul apelează funcțiile pentru o mână este: placeBet(int bet) $\rightarrow$ getDealerCard() $\rightarrow$ getCard() $\times 2 \rightarrow$ getCard() $\times$ (de câte ori mai dorește jucătorul, maxim până depășește $21$) $\rightarrow$ stand() $\rightarrow$ getOutcome() $\times$ (până retunează $0$) $\rightarrow$ cashIn().

void reshuffle();

Această funcție se apelează după terminarea unei mâini pentru a semnaliza concurentului că toate cărțile folosite în mâinile precedente au fost repuse în teanc iar teancul a fost reamestecat.

Restricții și precizări

• $10 \leq nPacks \leq 20$
• $20 \ 000 \leq money \leq 100 \ 000$
• $200 \leq T \leq 500$
• Pentru orice apel al funcției placeBet(int bet), $0 \leq bet \leq m$, unde $m$ reprezintă suma de bani pe care o are concurentul în acel moment.
• Un apel al funcțiilor getCard, getDealerCard sau getOutcome va returna $11$ în cazul în care cartea returnată este un as, și $10$ în cazul în care cartea returnată este un $10$, un popă, o damă sau un valet.
• În cazul în care, după ce s-a terminat de jucat o mână și concurentul are cel puțin $1 \ 000 \ 000 \ 000$ bani, jocul se termină și concurentul primește punctaj maxim pe acel test.
• Punctajul concurentului se va stabili în felul următor: se rulează sursa concurentului și se iau cele $10$ sume de bani cu care concurentul termină fiecare joc și se sortează descrescător. Se elimină primele două și ultimele două din acest șir și se stabilește $S_{concurent}$ = suma valorilor din acest șir. În mod similar se definește pentru sursa comisiei $S_{comisie}$. Definim $raport = S_{concurent}/S_{comisie}$. Punctajul concurentului pe un test este $round(raport^{5} \times 10)$.

Exemplu de interacțiune

grader: startGame(20000, 10)
grader: playHand()
concurent: placeBet(100)
grader: return 19900
concurent: getDealerCard()
grader: return 9
concurent: getCard()
grader: return 11
concurent: getCard()
grader: return 10
concurent: cashIn()
grader: return 200
concurent: getOutcome()
grader: return 5
concurent: getOutcome()
grader: return 6
concurent: getOutcome()
grader: return 0

grader: startGame(2000, 10)
grader: playHand()
concurent: placeBet(100)
grader: return 1900
concurent: getDealerCard()
grader: return 10
concurent: getCard()
grader: return 10
concurent: getCard()
grader: return 9
concurent: getCard()
grader: return 4
concurent: stand()
concurent: getOutcome()
grader: return 10
concurent: getOutcome()
grader: return 0
concurent: cashIn()
grader: return 0

grader: reshuffle()

Explicație

Funcția startGame este apelată cu parametrii $nPacks = 10$, semnificând că în teancul de cărți se vor afla cărțile a $10$ pachete standard, și $money = 20 \ 000$, reprezentând suma de bani pe care o are inițial concurentul.

Se semnalizează concurentului începerea unei mâini.

Concurentul pariază $100$ că va câștiga mâna curentă

Dealerul a primit un $9$.

Concurentul apelează de $2$ ori getCard pentru a primi primele $2$ cărți. El primește un as și un $10$. Suma cărților concurentului este $21$.

Concurentul anunță că nu mai dorește cărți.

Dealerul primește un $5$ și un $6$. Suma cărților dealerului este $20$.

Concurentul a câștigat mâna și primește $200$ de bani. Acum are $2 \ 100$ bani.

Începe a doua seară de joc.

Concurentul mai cere o carte după primele $2$. Aceasta este $4$ și face ca suma să devină $23$.

Concurentul este obligat să apeleze stand acum.

Concurentului îi este semnalizat faptul că teancul de cărți a fost reamestecat.