API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 19th, 2019
87
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 24.23 KB | None | 0 0
raw download clone embed print report
  1. #include <bits/stdc++.h>
  2. #include <unistd.h>
  3. using namespace std;
  4. typedef long long ll;
  5. const ll S = (ll) 1e17;
  6. const unsigned int B = 500;
  7. const int stala_symulacji = 1000;
  8.  
  9. int rnd(int poc, int kon){
  10. return poc + rand() % (kon - poc + 1);
  11. }
  12.  
  13. struct karta{
  14. string kolor;
  15. string figura;
  16.  
  17.  
  18. // UWAGA, MOZLIWE ZE W KONSTRUKTORACH NALEZY DAC PUBLIC
  19. karta(string x, string y){
  20. kolor = x;
  21. figura = y;
  22. }
  23.  
  24. karta(int X){
  25. if (! (0 <= X and X <= 51)){
  26. cout << "Nie ma karty o numerze: " << X << endl;
  27. exit(0);
  28. }
  29.  
  30. if (X / 13 == 0) kolor = "pik";
  31. if (X / 13 == 1) kolor = "trefl";
  32. if (X / 13 == 2) kolor = "karo";
  33. if (X / 13 == 3) kolor = "kier";
  34.  
  35. if (X % 13 <= 7) figura = "" + (char) (X % 13 + '0' + 2);
  36. if (X % 13 == 8) figura = "10";
  37. if (X % 13 == 9) figura = "J";
  38. if (X % 13 == 10) figura = "Q";
  39. if (X % 13 == 11) figura = "K";
  40. if (X % 13 == 12) figura = "A";
  41. }
  42.  
  43. int id_karty(){
  44. int res = 0;
  45. res += (kolor == "pik") * 0 * 13;
  46. res += (kolor == "trefl") * 1 * 13;
  47. res += (kolor == "karo") * 2 * 13;
  48. res += (kolor == "kier") * 3 * 13;
  49.  
  50. res += (figura == "2") * 0;
  51. res += (figura == "3") * 1;
  52. res += (figura == "4") * 2;
  53. res += (figura == "5") * 3;
  54. res += (figura == "6") * 4;
  55. res += (figura == "7") * 5;
  56. res += (figura == "8") * 6;
  57. res += (figura == "9") * 7;
  58. res += (figura == "10") * 8;
  59. res += (figura == "J") * 9;
  60. res += (figura == "Q") * 10;
  61. res += (figura == "K") * 11;
  62. res += (figura == "A") * 12;
  63.  
  64. return res;
  65. }
  66.  
  67. int moc_karty(){
  68. return id_karty() % 13;
  69. }
  70.  
  71. string nazwa(){
  72. return figura + " " + kolor;
  73. }
  74. };
  75.  
  76. struct ulozenie{
  77. int id_gracza;
  78. ll moc = -1;
  79. string nazwa;
  80. vector <karta> karty;
  81.  
  82. vector <int> zlicz;
  83. vector <pair <int, int> > X;
  84.  
  85. ulozenie(vector <karta> Z, int x){
  86. karty = Z;
  87.  
  88. // pre-processing
  89.  
  90. zlicz.resize(13);
  91. for (int i = 0; i < 13; i ++)
  92. zlicz[i] = 0;
  93.  
  94. for (auto e : karty)
  95. zlicz[e.moc_karty()] ++;
  96.  
  97. for (int i = 0; i < karty.size(); i ++)
  98. X.push_back({karty[i].id_karty(), i});
  99. sort(X.begin(), X.end());
  100.  
  101. // end of pre-processing
  102.  
  103. if (
  104. pokor() or
  105. kareta() or
  106. full() or
  107. kolor() or
  108. strit() or
  109. trojka() or
  110. para2() or
  111. para() or
  112. wysoka()
  113. );
  114.  
  115. id_gracza = x;
  116. }
  117.  
  118. bool pokor(){
  119. int ile = 0, prev = 0, border;
  120.  
  121. for (int i = X.size() - 1; i >= 0; i --){
  122. int x = X[i].first;
  123. int y = X[i].second;
  124.  
  125. if (ile == 0 or border > x or prev != x + 1){
  126. border = x / 13 * 13;
  127. prev = x;
  128. ile = 1;
  129. continue;
  130. }
  131.  
  132. ile ++;
  133. prev = x;
  134. if (ile == 5){
  135. nazwa = "poker " + karty[y].kolor + " od " + karty[y].figura;
  136. moc = S * 8 + karty[y].moc_karty() * (S / 100);
  137. return true;
  138. }
  139. }
  140.  
  141. return false;
  142. }
  143.  
  144.  
  145. bool kareta(){
  146. for (int i = 0; i < 13; i ++)
  147. if (zlicz[i] == 4)
  148. for (int j = 12; j >= 0; j --)
  149. if (zlicz[j] > 0 and zlicz[j] < 4){
  150. nazwa = "kareta " + karta(i).kolor;
  151. moc = S * 7 + i * (S / 100) + j * (S / 10000);
  152. return true;
  153. }
  154.  
  155. return false;
  156. }
  157.  
  158.  
  159. bool full(){
  160. for (int i = 12; i >= 0; i --)
  161. if (zlicz[i] >= 3)
  162. for (int j = 12; j >= 0; j --)
  163. if (i != j and zlicz[j] >= 2){
  164. nazwa = "full " + karta(i).figura + " na " + karta(j).figura;
  165. moc = S * 6 + i * (S / 100) + j * (S / 10000);
  166. return true;
  167. }
  168. return false;
  169. }
  170.  
  171.  
  172. bool kolor(){
  173. int ile = 0, border;
  174.  
  175. for (int i = X.size() - 1; i >= 0; i --){
  176. int x = X[i].first;
  177. int y = X[i].second;
  178.  
  179. if (ile == 0 or border > x){
  180. border = x / 13 * 13;
  181. ile = 1;
  182. continue;
  183. }
  184.  
  185. ile ++;
  186. if (ile == 5){
  187. nazwa = "kolor " + karty[y].kolor;
  188. moc = S * 5 + karty[X[i + 4].second].moc_karty() * (S / (ll) 100)
  189. + karty[X[i + 3].second].moc_karty() * (S / (ll) 10000)
  190. + karty[X[i + 2].second].moc_karty() * (S / (ll) 1000000)
  191. + karty[X[i + 1].second].moc_karty() * (S / (ll) 100000000);
  192. + karty[X[i + 0].second].moc_karty() * (S / (ll) 10000000000);
  193. return true;
  194. }
  195. }
  196. return false;
  197. }
  198.  
  199. bool strit(){
  200. int act = 0;
  201. for (int i = 12; i >= 0; i --){
  202. if (zlicz[i] == 0){
  203. act = 0;
  204. continue;
  205. }
  206.  
  207.  
  208. act ++;
  209. if (act == 5){
  210. nazwa = "strit od " + karta(i).kolor;
  211. moc = S * 4 + i * (S / (ll) 100);
  212. return true;
  213. }
  214. }
  215. return false;
  216. }
  217.  
  218. bool trojka(){
  219. for (int i = 12; i >= 0; i --)
  220. if (zlicz[i] >= 3){
  221. vector <int> kickery;
  222. for (auto e : karty)
  223. if (e.moc_karty() != i)
  224. kickery.push_back(e.moc_karty());
  225.  
  226. sort(kickery.begin(), kickery.end());
  227.  
  228. nazwa = "trojka " + karta(i).figura;
  229. moc = S * 3 + i * (S / (ll) 100)
  230. + kickery[kickery.size() - 1] * (S / (ll) 10000)
  231. + kickery[kickery.size() - 2] * (S / (ll) 1000000);
  232. return true;
  233. }
  234. return false;
  235. }
  236.  
  237. bool para2(){
  238. for (int i = 12; i >= 0; i --)
  239. if (zlicz[i] >= 2)
  240. for (int j = i - 1; j >= 0; j --)
  241. if (zlicz[j] >= 2){
  242. vector <int> kickery;
  243. for (auto e : karty)
  244. if (e.moc_karty() != i and e.moc_karty() != j)
  245. kickery.push_back(e.moc_karty());
  246.  
  247. nazwa = "dwie pary " + karta(i).figura + " & " + karta(j).figura;
  248. moc = S * 2 + i * (S / (ll) 100)
  249. + j * (S / (ll) 10000)
  250. + kickery[kickery.size() - 1] * (S / (ll) 1000000);
  251. return true;
  252. }
  253. return false;
  254. }
  255.  
  256. bool para(){
  257. for (int i = 12; i >= 0; i --)
  258. if (zlicz[i] >= 2){
  259. vector <int> kickery;
  260. for (auto e : karty)
  261. if (e.moc_karty() != i)
  262. kickery.push_back(e.moc_karty());
  263.  
  264. nazwa = "para " + karta(i).figura;
  265. moc = S * 1 + i * (S / (ll) 100)
  266. + kickery[kickery.size() - 1] * (S / (ll) 10000)
  267. + kickery[kickery.size() - 2] * (S / (ll) 1000000)
  268. + kickery[kickery.size() - 3] * (S / (ll) 100000000);
  269. return true;
  270. }
  271. return false;
  272. }
  273.  
  274. bool wysoka(){
  275. for (int i = 12; i >= 0; i --)
  276. if (zlicz[i]){
  277. vector <int> kickery;
  278. for (int j = i - 1; kickery.size() != 4; j --)
  279. if (zlicz[j])
  280. kickery.push_back(j);
  281.  
  282. nazwa = "wysoka karta " + karta(i).figura;
  283. moc = S * 0 + i * (S / (ll) 100)
  284. + kickery[kickery.size() - 1] * (S / (ll) 10000)
  285. + kickery[kickery.size() - 2] * (S / (ll) 1000000)
  286. + kickery[kickery.size() - 3] * (S / (ll) 100000000)
  287. + kickery[kickery.size() - 4] * (S / (ll) 10000000000);
  288. return true;
  289. }
  290. cout << "Blad!!!!! nie wybrano zadnego ulozenia";
  291. exit(0);
  292. }
  293.  
  294. bool operator<(const ulozenie X){
  295. return (this->moc) > (X.moc);
  296. }
  297. };
  298.  
  299. struct gracz{
  300. string nazwa;
  301. int wartosc_stacka;
  302. int id_gracza; // gdzie siedzi
  303. int liczba_pozostalych_graczy;
  304. int trudnosc_bota;
  305. bool uzyte_karty[52];
  306. double szansa; // [0, 1]
  307. bool bot;
  308. bool aktualnie_w_grze;
  309. bool *spasowali;
  310. vector <vector <int> > szanse; /*/ dla kazdego gracza szanse jaka ma karte
  311. poczatkowo:
  312. {{0.19, 0.19, ... , 0.19},
  313. {0.19, 0.19, ... , 0.19}} /*/
  314.  
  315. vector <karta> karty;
  316.  
  317. gracz(string x, int a, int y, int z, int T, bool B, vector <karta> K){
  318. nazwa = x;
  319. wartosc_stacka = a;
  320. id_gracza = y;
  321. liczba_pozostalych_graczy = z;
  322. trudnosc_bota = T;
  323. szansa = 1.0;
  324. bot = B;
  325. aktualnie_w_grze = true;
  326. spasowali = new bool[liczba_pozostalych_graczy];
  327. for (int i = 0; i < liczba_pozostalych_graczy; i ++)
  328. spasowali[i] = 0;
  329.  
  330. vector <int> X = {};
  331. for (int i = 0; i < 52; i ++)
  332. X.push_back(1.0 / 52.0);
  333.  
  334. for (int i = 0; i < liczba_pozostalych_graczy; i ++)
  335. szanse.push_back(X);
  336.  
  337. karty = K;
  338. }
  339.  
  340. bool all_in(){
  341. return (wartosc_stacka == 0);
  342. }
  343. /*/
  344. void aktualizuj_szanse( tu trzeba cos pobrac ze stolu ){
  345.  
  346. }
  347. karta losuj_karte(int* prefsum){
  348. while (true){
  349. double X = (double) rnd(0, 1 << 15) / (double) (1 << 15);
  350. int a = 0, b = 52;
  351. while(a + 1 < b){
  352. int s = (a + b) / 2;
  353. if (prefsum[s] > X) b = s;
  354. else a = s;
  355. }
  356. if (!uzyte_karty[a]){
  357. uzyte_karty[a] = false;
  358. return karta(a);
  359. }
  360. }
  361. }
  362.  
  363. void licz_szanse(vector<karta> karty_na_stole){
  364. int stala_symulacji;
  365. double prefsum_szansa_zbalansowana[52], ile_wygralem = 0;
  366. prefsum_szansa_zbalansowana[0] = 0;
  367. for(int j = 1; j < 52; ++j)
  368. prefsum_szansa_zbalansowana[j] = prefsum_szansa_zbalansowana[j] + 1.0 / 52;
  369.  
  370. vector <vector <int> > prefsum;
  371. prefsum_szanse.resize(szanse.size());
  372. for (int i = 0; i < szanse.size(); i ++)
  373. prefsum_szanse[i].resize(52);
  374.  
  375. for (int i = 0; i < liczba_pozostalych_graczy; ++i){
  376. prefsum_szanse[i][0] = 0;
  377. for(int j = 1; j < szanse[i].size(); ++j)
  378. prefsum_szanse[i][j] = prefsum_szanse[i][j - 1] + szanse[i][j];
  379. }
  380.  
  381. for (int i = 0; i < stala_symulacji; ++i){
  382. for(int j = 0; j < 52; ++j)
  383. uzyte_karty[j] = 0;
  384. uzyte_karty[karty[0].id_karty()] = uzyte_karty[karty[1].id_karty()] = 1;
  385.  
  386. for(int j = 0; j < karty_na_stole.size(); ++j)
  387. uzyte_karty[karty_na_stole[j].id_karty()] = 1;
  388.  
  389. vector <vector <int> > karty_przeciwnikow(liczba_pozostalych_graczy);
  390. for (int j = 0; j < liczba_pozostalych_graczy; j ++)
  391. karty_przeciwnikow[j].resize(2);
  392.  
  393. for (int j = 0; j < liczba_pozostalych_graczy; ++ j){
  394. karty_przeciwnikow[j][0] = losuj_karte(prefsum_szanse[j]);
  395. karty_przeciwnikow[j][1] = losuj_karte(prefsum_szanse[j]);
  396. }
  397.  
  398. int dodatkowe_karty_na_stole = 0;
  399. while (karty_na_stole.size() < 5){
  400. ++ dodatkowe_karty_na_stole;
  401. karty_na_stole.push_back(losuj_karte(prefsum_szansa_zbalansowana));
  402. }
  403.  
  404. vector <ulozenie> X;
  405. karty_przeciwnikow.push_back(karty);
  406.  
  407. int cnt = 0;
  408. for (auto e : karty_przeciwnikow){
  409. for (auto f : e)
  410. karty_na_stole.push_back(f);
  411.  
  412.  
  413. X.push_back(ulozenie(karty_na_stole, cnt, -1 * spasowali));
  414.  
  415. for (auto f : e)
  416. karty_na_stole.pop_back();
  417. }
  418.  
  419. karty_przeciwnikow.pop_back();
  420. sort(X.begin(), X.end());
  421.  
  422. int ile_gosci;
  423. bool odw = false;
  424. for (int j = 0; j < X.size() and X[j].moc == X[0].moc; j ++){
  425. ile_gosci = j + 1;
  426. if (X[j].id_gracza == cnt)
  427. odw = true;
  428. }
  429.  
  430. while(dodatkowe_karty_na_stole > 0){
  431. karty_na_stole.pop_back();
  432. -- dodatkowe_karty_na_stole;
  433. }
  434. }
  435.  
  436. szansa = ile_wygralem / (double) stala_symulacji;
  437. }
  438. /*/
  439. };
  440.  
  441. struct Stol{
  442. vector <gracz> gracze;
  443. vector <karta> karty_na_stole;
  444. vector <karta> karty_wolne;
  445. vector <int> stacki; // ile kto dal
  446. // 1. lista osob ktore wchodza za dana pule
  447. // 2. jaka to pula
  448.  
  449. int kto_rozdaje; // zeby wiedziec jak ida blindy
  450. int big_blind; // ile za wejscie
  451. int ktora_tura; // ktora aktualnie tura
  452. int czyja_kolej; // żeby wiedzieć kogo displayowac
  453.  
  454. Stol(vector <pair <bool, pair <string, int> > > G, int ile_na_start, int startowy_blind){
  455. int cnt = 0;
  456. for (auto e : G){
  457. gracze.push_back(gracz(
  458. e.second.first,
  459. ile_na_start,
  460. cnt,
  461. G.size() - 1,
  462. e.second.second,
  463. e.first,
  464. {}
  465. ));
  466. cnt ++;
  467. }
  468. karty_na_stole = {};
  469. karty_wolne = {};
  470. kto_rozdaje = 0;
  471. big_blind = startowy_blind;
  472. ktora_tura = 0;
  473. czyja_kolej = 0;
  474. odswiez();
  475. }
  476.  
  477. int pula(){
  478. int res = 0;
  479. for (auto e : stacki)
  480. res += e;
  481. return res;
  482. }
  483.  
  484. vector <int> kto_wygrywa(){
  485. vector <ulozenie> X;
  486. vector <karta> Y;
  487. for (auto e : karty_na_stole)
  488. Y.push_back(e);
  489.  
  490. for (auto e : gracze)
  491. if (e.aktualnie_w_grze){
  492. for (auto f : e.karty)
  493. Y.push_back(f);
  494. X.push_back(ulozenie(Y, e.id_gracza));
  495. for (auto f : e.karty)
  496. Y.pop_back();
  497. }
  498.  
  499. sort(X.begin(), X.end());
  500. vector <int> res;
  501. for (auto e : X)
  502. res.push_back(e.id_gracza);
  503. }
  504.  
  505. void pokaz_stol(){
  506. vector <string> T = {" ",
  507. " 2 3 ",
  508. " ",
  509. " ________________________________________________________________________________ ",
  510. " | | ",
  511. " | | ",
  512. " | | ",
  513. " | | ",
  514. " | | ",
  515. " | | ",
  516. " | | ",
  517. " | | ",
  518. " | 2 3 | ",
  519. " | | ",
  520. " | | ",
  521. " | | ",
  522. " | | ",
  523. " | | ",
  524. " | | 0 0",
  525. " | | ",
  526. " | | ",
  527. " | | ",
  528. " | @ | 2",
  529. " | | ",
  530. " | | ",
  531. " | 2 3 | ",
  532. " | | ",
  533. " | | ",
  534. " | | ",
  535. " | | ",
  536. " | | ",
  537. " | | ",
  538. " | | ",
  539. " |________________________________________________________________________________| ",
  540. " ",
  541. " @ 2"
  542. };
  543. for (auto e : T)
  544. cout << e << "\n";
  545. cout << endl;
  546.  
  547. }
  548.  
  549. void pas(int id_gracza){
  550. gracze[id_gracza].aktualnie_w_grze = false;
  551. for (auto e : gracze)
  552. e.spasowali[id_gracza] = true;
  553. }
  554.  
  555. void sprawdz(int id_gracza){
  556. int maks = 0;
  557. for (auto e : stacki)
  558. maks = max(maks, e);
  559.  
  560. int ile_trzeba_podbic = min(maks - stacki[id_gracza],
  561. gracze[id_gracza].wartosc_stacka);
  562.  
  563. gracze[id_gracza].wartosc_stacka -= ile_trzeba_podbic;
  564. stacki[id_gracza] += ile_trzeba_podbic;
  565. }
  566.  
  567. bool podbij(int id_gracza, int x){
  568. if (x < big_blind / 2 and x < gracze[id_gracza].wartosc_stacka){
  569. cout << "\nMinimalne podbicie to " << big_blind / 2 << "!";
  570. return false;
  571. }
  572.  
  573. x = min(x, gracze[id_gracza].wartosc_stacka);
  574. gracze[id_gracza].wartosc_stacka -= x;
  575. stacki[id_gracza] += x;
  576. return true;
  577. }
  578.  
  579. karta losuj_karte(){
  580. if (karty_wolne.empty()){
  581. cout << "\nBLAD PROGRAMU, BRAK WOLNYCH KART DO ROZDANIA!\n";
  582. exit(0);
  583. }
  584.  
  585. swap(karty_wolne[rnd(0, karty_wolne.size() - 1)], karty_wolne.back());
  586. karta cand = karty_wolne.back();
  587. karty_wolne.pop_back();
  588.  
  589. return cand;
  590. }
  591.  
  592. void rozdaj_karty(){
  593. for(int i = 0; i < gracze.size(); ++i){
  594. vector <karta> temp;
  595. temp.push_back(losuj_karte());
  596. temp.push_back(losuj_karte());
  597. gracze[i].karty = temp;
  598. }
  599. }
  600.  
  601. void rozdaj_kase(){
  602. vector <int> wygrani = kto_wygrywa();
  603.  
  604. for (auto e : wygrani){
  605. int zabiera = stacki[e];
  606. for (int i = 0; i < stacki.size(); i ++){
  607. int ile = min(stacki[i], zabiera);
  608. gracze[e].wartosc_stacka += ile;
  609. stacki[i] -= ile;
  610. }
  611. }
  612. }
  613.  
  614. void odswiez(){
  615. ktora_tura ++;
  616. if (ktora_tura % 5 == 0)
  617. big_blind *= 2;
  618.  
  619. karty_wolne.clear();
  620. for(int i = 0; i < 52; ++ i)
  621. karty_wolne.push_back(karta(i));
  622. karty_na_stole.clear();
  623. stacki.resize(gracze.size());
  624. kto_rozdaje = (kto_rozdaje + 1) % gracze.size();
  625. }
  626.  
  627. void wykonaj_ruch_bota(int id_gracza){
  628. return;
  629. }
  630.  
  631. bool wykonaj_ruch_gracza(int id_gracza){
  632. return true;
  633. }
  634.  
  635. void rozgrywaj(){
  636. rozdaj_karty();
  637. int prev_i = 0;
  638. for (int i = 0; i <= 5; i ++){
  639. int kon = gracze.size() - 1;
  640. for (int j = 0; j <= kon; j ++){
  641. cout << "ruch gracza " << gracze[j % gracze.size()].nazwa << endl;
  642. string z; cin >> z;
  643. system("clear");
  644. pokaz_stol();
  645.  
  646. czyja_kolej = j;
  647. if (i == 0 and j == 0){
  648. ++kon;
  649. podbij(czyja_kolej, big_blind / 2);
  650. }
  651. else if (i == 0 and j == 1){
  652. ++kon;
  653. podbij(czyja_kolej, big_blind);
  654. }
  655. else{
  656. if (gracze[j % gracze.size()].bot)
  657. wykonaj_ruch_bota(j % gracze.size());
  658. else if (!wykonaj_ruch_gracza(j % gracze.size())) j --;
  659. }
  660. usleep(B);
  661. }
  662. for (int j = 0; j < i - prev_i; j ++)
  663. karty_na_stole.push_back(losuj_karte());
  664.  
  665. prev_i = i;
  666. if (i == 0) i = 2;
  667. }
  668. rozdaj_kase();
  669. odswiez();
  670. }
  671. };
  672.  
  673. void solve(){
  674. vector <pair <bool, pair <string, int> > > X = {{{0, {"Blachu", -1}}, {0, {"Staszek", -1}}}};
  675. Stol Board(X, 10000, 25);
  676.  
  677.  
  678. while (true)
  679. Board.rozgrywaj();
  680. }
  681.  
  682. int main(){
  683. srand(time(NULL));
  684. ios_base::sync_with_stdio(0);
  685. cout.tie(0);
  686. cin.tie(0);
  687.  
  688. solve();
  689.  
  690. return 0;
  691. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!