Advertisement
Guest User

Untitled

a guest
Nov 21st, 2019
90
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 19.05 KB | None | 0 0
  1. #include <array>
  2. #include <string>
  3. #include <vector>
  4. #include <iostream>
  5. #include <sstream>
  6. #include <cstring>
  7. #include <vector>
  8.  
  9. ///Kedves Csaba! Örülök, hogy látlak! Hogy vagy?
  10. ///Had vezesseleg végig egy csodálatos utazáson, ami alatt metanulod, hogy mi mit csinál ebben a programban.
  11. int seed = 111;
  12.  
  13.  
  14. char verzio[20] = "69";
  15. unsigned int alaprouter; ///A mi routerünk poziciója
  16. bool finishMode = 0; ///True, kaptunk már legalább 1 üres packet-et
  17. bool egyvegy = false;
  18.  
  19. bool createLeft = 1; ///Create-kor mindig átállítjuk. Jobbra/balra indul a packet.
  20. int lowestEmptyPacket = 9999; ///A legalacsonyabb indexü packet, ami üresen jött
  21. int maxcreate;
  22. ///Innen változatlan
  23. enum class Direction : char
  24. {
  25. LEFT = 'l',
  26. RIGHT = 'r'
  27. };
  28.  
  29.  
  30. struct Data
  31. {
  32. unsigned int currRouter;
  33. unsigned int currStoreId;
  34. unsigned int dataIndex;
  35. unsigned int messageId;
  36. unsigned int fromRouter;
  37. unsigned int toRouter;
  38. char gravity[3];
  39. Direction dir;
  40. };
  41.  
  42. struct MessagePiece
  43. {
  44. int index;
  45. std::string message;
  46.  
  47. };
  48. std::vector<MessagePiece>azenyem;
  49. void swap(MessagePiece* xp, MessagePiece* yp)
  50. {
  51. MessagePiece temp = *xp;
  52. *xp = *yp;
  53. *yp = temp;
  54. }
  55. struct Reader
  56. {
  57. std::array<unsigned int, 3> data;
  58. std::string previous;
  59. std::array<std::array<bool, 10>, 14> routerBits;
  60. std::vector<Data> dataArray;
  61. std::vector<MessagePiece> receivedPieces; ///letarolando, rendezendo
  62. bool hasEnd;
  63. };
  64.  
  65. ///Eddig változatlan
  66.  
  67. ///Possible action egy lehetséges lépés
  68. struct PossibleAction
  69. {
  70. PossibleAction(char c, int i)
  71. {
  72. action = c;
  73. moveRouter = i;
  74. value = 0;
  75. }
  76. ///Ha ez felfele, vagy lefele mutat, akkor egy mozgatás
  77. ///Ebben az esetben a moveRouter a mozgatandó router ID-ja
  78.  
  79. ///Ha c, akkor create
  80. ///Ilyenkor a createSlot tárolja az alaprouter slot-ját, ahol létre akarjuk hozni a packetet
  81. char action; //^, v, c
  82. union
  83. {
  84. int moveRouter;
  85. int createSlot;
  86. };
  87.  
  88. ///Ez lényegében egy return erték. A szimuláló függvény itt adja vissza, hogy mennyire jó nekünk az adott lépés
  89. ///Nagyobb = jobb
  90. int value;
  91. };
  92.  
  93.  
  94. bool priority = true;
  95. ///Ez a szimuláló függvény. Ne nézd az angol kommenteket, azok nekem vannak.
  96. ///A függvény megkapja a pálya állását és egy választott lehetséges akciót.
  97. ///Az akció value értékébe számolja ki a hasznossságát
  98. void simulateAction(std::array < std::array<bool, 10>, 14> routerBits, std::vector<Data> originalPackets, PossibleAction& pa)
  99. {
  100.  
  101. std::vector<Data> packets(originalPackets);
  102.  
  103.  
  104. bool couldMove[99] = { 0 };
  105.  
  106.  
  107. char state[14][10];
  108. for (int i = 0; i < 14; i++)
  109. for (int j = 0; j < 10; j++)
  110. state[i][j] = (routerBits[i][j]) ? '-' : '#'; //- open, #blocked
  111.  
  112. ///Ha a választott akció egy create, akkor elkészítjük a packetet a szimulálás előtt
  113. ///Generate a hypothetical packet?
  114. if (pa.action == 'c')
  115. {
  116. Data addition;
  117. addition.currRouter = alaprouter;
  118. addition.currStoreId = pa.createSlot;
  119. addition.dir = createLeft ? Direction::LEFT : Direction::RIGHT;
  120. addition.fromRouter = alaprouter;
  121. addition.toRouter = (alaprouter + 7) % 14;
  122. packets.push_back(addition);
  123. }
  124.  
  125. ///Minden packetet betöltünk az előbb említett tömbbe
  126. ///Store packets
  127. for (int i = 0; i < packets.size(); i++)
  128. state[packets[i].currRouter][packets[i].currStoreId] = '0' + i;
  129.  
  130. ///Ha a választott akció egy fel/le mozgatás, akkor ezt elvégezzük a tömbben.
  131. ///Todo szólj nekem hogy nézzem meg hogy nem-e %10 kell %14 helyett
  132. ///Shift packets?
  133. char temp;
  134. if (pa.action == '^') ///Ha felfele akarunk mozgatni
  135. {
  136. temp = state[pa.moveRouter][0];
  137. for (int i = 0; i < 9; i++)
  138. state[pa.moveRouter][i] = state[pa.moveRouter][i + 1];
  139. state[pa.moveRouter][9] = temp;
  140.  
  141. for (int i = 0; i < 10; i++)
  142. if (state[pa.moveRouter][i] >= '0' && state[pa.moveRouter][i] <= '9')
  143. {
  144. packets[state[pa.moveRouter][i] - '0'].currStoreId = (packets[state[pa.moveRouter][i] - '0'].currStoreId - 1) % 10;
  145. if (packets[state[pa.moveRouter][i] - '0'].fromRouter != alaprouter)
  146. pa.value = -1;
  147. }
  148.  
  149. }
  150. else if (pa.action == 'v') ///Ugyanaz, lefele
  151. {
  152. temp = state[pa.moveRouter][9];
  153. for (int i = 9; i > 0; i--)
  154. state[pa.moveRouter][i] = state[pa.moveRouter][i - 1];
  155. state[pa.moveRouter][0] = temp;
  156.  
  157. for (int i = 0; i < 10; i++)
  158. if (state[pa.moveRouter][i] >= '0' && state[pa.moveRouter][i] <= '9')
  159. {
  160. packets[state[pa.moveRouter][i] - '0'].currStoreId = (packets[state[pa.moveRouter][i] - '0'].currStoreId + 1) % 10;
  161. if (packets[state[pa.moveRouter][i] - '0'].fromRouter != alaprouter)
  162. pa.value = -1;
  163. }
  164.  
  165. }
  166. ///Megjegyzés: mivel a 2D tömbünk char-okat tárol, '0' kivonásával kaphatunk számokat ('5' - '0' = 5)
  167.  
  168.  
  169. ///Itt elkezdjük szimulálni.
  170. ///Ez a szimuláció csak a mi lépésünket feltételezi, nem számol az ellenségével
  171. ///Todo ezen lehet javítani
  172. ///Start simulating
  173. while (true)
  174. {
  175. togo:
  176. ///Ez a kódrészlet felel azért, hogy automatikusan felfele csússzanak a packetek.
  177. ///Automatic upwards shift
  178.  
  179. /*if ()
  180. {
  181. for (int i = 0; i < packets.size(); i++)
  182. if (packets[i].currStoreId > 0 && state[packets[i].currRouter][packets[i].currStoreId - 1] == '-')
  183. {
  184.  
  185. state[packets[i].currRouter][packets[i].currStoreId - 1] = '0' + i;
  186.  
  187. state[packets[i].currRouter][packets[i].currStoreId] = '-';
  188.  
  189. packets[i].currStoreId--;
  190.  
  191. goto togo;
  192. }
  193. }
  194. */
  195. for(i=0; i<packets.size(); i++)
  196. {
  197. if(packets[i].gravity=='PRI')
  198. {
  199. if (packets[i].currStoreId > 0 && state[packets[i].currRouter][packets[i].currStoreId - 1] == '-')
  200. {
  201.  
  202. state[packets[i].currRouter][packets[i].currStoreId - 1] = '0' + i;
  203.  
  204. state[packets[i].currRouter][packets[i].currStoreId] = '-';
  205.  
  206. packets[i].currStoreId--;
  207.  
  208. goto togo;
  209. }
  210. }
  211. else{
  212. if (packets[i].currStoreId < 9 && state[packets[i].currRouter][packets[i].currStoreId + 1] == '-')
  213. {
  214.  
  215. state[packets[i].currRouter][packets[i].currStoreId + 1] = '0' + i;
  216.  
  217. state[packets[i].currRouter][packets[i].currStoreId] = '-';
  218.  
  219. packets[i].currStoreId++;
  220.  
  221. goto togo;
  222. }
  223.  
  224.  
  225. }
  226.  
  227.  
  228.  
  229.  
  230.  
  231. }
  232.  
  233.  
  234.  
  235.  
  236.  
  237.  
  238. ///Ez pedig az oldalra mozgás
  239. ///Automatic movement
  240. for (int i = 0; i < packets.size(); i++)
  241. {
  242.  
  243. int direction = 1;
  244. if (packets[i].dir == Direction::LEFT)
  245. direction = -1;
  246.  
  247. if (packets[i].currRouter != packets[i].toRouter && state[(int(packets[i].currRouter) + direction) % 14][packets[i].currStoreId] == '-')
  248. {
  249.  
  250. state[(int(packets[i].currRouter) + direction) % 14][packets[i].currStoreId] = '0' + i;
  251. state[packets[i].currRouter][packets[i].currStoreId] = '-';
  252. packets[i].currRouter = (int(packets[i].currRouter) + direction) % 14;
  253. if (packets[i].fromRouter == alaprouter)
  254. {
  255. pa.value++; ///increment action's usefulness
  256. couldMove[i] = 1;
  257. }
  258.  
  259.  
  260. goto togo;
  261.  
  262. }
  263. }
  264.  
  265.  
  266. ///A while minden körében először a felfele csúszást nézi, és csak utána az oldalra valót.
  267. ///Ha egyik sem történt meg, kilép
  268. ///Todo kurva felesleges idea while
  269. break;
  270. }
  271.  
  272. ///Emlékszel erre a 8 emelmű lófaszra?
  273. ///Ha 3 különböző packetünk mozgott, +3 pontot adunk az akciónak, stb.
  274. for (int i = 0; i < 99; i++)
  275. if (couldMove[i])
  276. pa.value++;
  277. }
  278. bool Parbaj_e(std::array < std::array<bool, 10>, 14> routerBits)
  279. {
  280. bool parbaj = false;
  281.  
  282. int hanytorlasz = 0;
  283. for (int j = 0; j < 14; j++)
  284. {
  285. if (routerBits[0][j] == 0)
  286. {
  287. hanytorlasz++;
  288. }
  289. }
  290. if (hanytorlasz > 2)
  291. {
  292. return true;
  293. }
  294. return false;
  295. }
  296. ///Innen megint ismerős
  297. void readData(Reader& to)
  298. {
  299. std::string line;
  300. to.dataArray.clear();
  301. /// to.receivedPieces.clear();
  302.  
  303. while (std::getline(std::cin, line))
  304. {
  305. std::cerr << line;
  306. if (!line.rfind(".", 0))
  307. return;
  308.  
  309. if (!line.rfind("WRONG", 0) ||
  310. !line.rfind("SCORE", 0) ||
  311. !line.rfind("TICK", 0))
  312. {
  313. to.hasEnd = true;
  314. std::cerr << "##end1\n" << line << "\n";
  315. to.previous = std::move(line);
  316. }
  317. else if (!line.rfind("REQUEST", 0))
  318. {
  319. std::stringstream(std::move(line).substr(8)) >> to.data[0] >> to.data[1] >> to.data[2];
  320. alaprouter = to.data[2];
  321. }
  322. else if (!line.rfind("PREVIOUS", 0))
  323. {
  324. to.previous = std::move(line).substr(9);
  325. }
  326. else if (!line.rfind("ROUTER", 0))
  327. {
  328. unsigned int routerIndex;
  329. std::istringstream(line.substr(7)) >> routerIndex >> line;
  330. auto it = line.begin();
  331. for (bool& routers : to.routerBits[routerIndex])
  332. routers = *it++ == '1';
  333. }
  334. else if (!line.rfind("DATA", 0))
  335. {
  336. Data curr;
  337. std::istringstream(std::move(line).substr(5))
  338. >> curr.currRouter
  339. >> curr.currStoreId
  340. >> curr.dataIndex
  341. >> curr.messageId
  342. >> curr.fromRouter
  343. >> curr.toRouter
  344. >> reinterpret_cast<char&>(curr.dir)
  345. >> curr.gravity;
  346.  
  347. to.dataArray.push_back(curr);
  348. }
  349. else if (!line.rfind("MESSAGE"))
  350. {
  351.  
  352. MessagePiece msg;
  353.  
  354. std::istringstream(std::move(line).substr(8)) >> msg.index >> msg.message;
  355.  
  356.  
  357. std::cerr << msg.message << "__" << msg.message.size() << "\n";
  358. if (msg.message.size() == 0)
  359. {
  360. ///Ha bejött egy 0-ás packet, akkor finishMode - többet nem create-ezünk
  361. ///A lowestEmptyPacket-ről szóló rész okkal van kikommentelve, ne foglalkozz vele
  362. finishMode = 1;
  363. if (msg.index < lowestEmptyPacket)
  364. lowestEmptyPacket = msg.index;
  365. std::cerr << "Finish Mode Started\n";
  366.  
  367.  
  368. }
  369.  
  370. to.receivedPieces.push_back(msg);
  371.  
  372. ///Ha finishmode-ban vagyunk és nincs tőlünk packet a pályán, befejezzük a játékot
  373. ///If only enemy packets left, end the game
  374. bool vegem = true;
  375. bool belep2 = true;
  376. for (int i = 0; i < to.dataArray.size(); i++)
  377. {
  378. belep2 = true;
  379. if (to.dataArray[i].fromRouter == alaprouter /*&& to.dataArray[i].dataIndex < lowestEmptyPacket*/) ///causes loss of empty packets, bad score
  380. {
  381. vegem = false;
  382.  
  383. }
  384. }
  385. if (vegem && belep2 && finishMode)
  386. {
  387. to.hasEnd = true;
  388. std::cerr << "##end2\n";
  389. }
  390.  
  391.  
  392.  
  393.  
  394.  
  395.  
  396. ///
  397.  
  398. ///
  399. azenyem.push_back(msg);
  400.  
  401.  
  402. }
  403. else
  404. {
  405. std::cerr << "READER ERROR HAPPENED: unrecognized command line: " << line << std::endl;
  406. to.hasEnd = true;
  407. return;
  408. }
  409. }
  410. std::cerr << "Unexpected input end." << std::endl;
  411. to.hasEnd = true;
  412. std::cerr << "##end3\n";
  413. }
  414.  
  415. int main()
  416. {
  417. std::cerr << "main\n";
  418. char teamToken[] = "tqEzVLvbq6wz_uWr6HS1";
  419.  
  420. int befutott = 0;
  421. std::string solution;
  422. std::cout << "START " << teamToken
  423. << " " << seed << " " << verzio << " " << "1v1"
  424. << std::endl;
  425.  
  426. Reader reader = {};
  427.  
  428. std::string command;
  429.  
  430. int nextCreateIndex = 0; ///A régi "faszpicsa", ez tárolja a következő kiküldendő packet indexét
  431.  
  432.  
  433.  
  434. while (true)
  435. {
  436. readData(reader);
  437. egyvegy = Parbaj_e(reader.routerBits);
  438. if (egyvegy == 1)
  439. {
  440. maxcreate = 4;
  441. }
  442. if (egyvegy == 0)
  443. {
  444. maxcreate = 2;
  445. }
  446.  
  447. if (reader.hasEnd)
  448. {
  449. std::cerr << "##end4\n";
  450. break;
  451. }
  452.  
  453. for (int i = 0; i < reader.dataArray.size(); i++)
  454. {
  455. std::cerr << "DATA " << reader.dataArray[i].currRouter << " " << reader.dataArray[i].currStoreId << " " << reader.dataArray[i].dataIndex << reader.dataArray[i].messageId << " " << reader.dataArray[i].fromRouter << " " << reader.dataArray[i].toRouter << " " << ((char)reader.dataArray[i].dir) << "/n";
  456. }
  457. for (int i = 0; i < 10; i++)
  458. {
  459. std::cerr << "ROUTER ";
  460. for (int j = 0; j < 14; j++)
  461. {
  462. std::cerr << reader.routerBits[i][j];
  463. }
  464. std::cerr << "/n";
  465. }
  466. ///**************************************************************
  467. ///Ugyanaz a számolás, a bitjeim a pályán lévő saját packetek száma
  468. ///Count our active packets
  469. int bitjeim = 0;
  470. for (int i = 0; i < reader.dataArray.size(); i++)
  471. if (reader.dataArray[i].fromRouter == alaprouter)
  472. bitjeim++;
  473.  
  474. ///A vectorban tároljuk az összes lehetséges lépésünket.
  475. ///Nincs olyan kurva sok, max 4 db. felfele mozgatás, 4 db. lefele, és kb. 5 create
  476. std::vector<PossibleAction> posActs;
  477.  
  478. ///Ha <4 packetünk van és még akarunk Create-elni
  479. ///If we can create
  480. if (bitjeim < maxcreate && !finishMode)
  481. {
  482. for (int i = 0; i < 9; i++) ///Végigmegyünk a slotokon
  483. {
  484.  
  485. if (reader.routerBits[alaprouter][i] == 1) ///Ha nem blockoja "piros" routerbit
  486. {
  487. bool slotEmpty = 1;
  488. for (int j = 0; j < reader.dataArray.size(); j++) ///És nem blockolja más packet sem
  489. {
  490. if (reader.dataArray[j].currStoreId == i && reader.dataArray[j].currRouter == alaprouter)
  491. {
  492. slotEmpty = 0;
  493. break;
  494. }
  495. }
  496.  
  497. if (slotEmpty)
  498. {
  499. ///Akkor lehetséges a Create
  500. PossibleAction pa('c', i);
  501. pa.value += 5 * (4 - bitjeim); ///Manuálisan hozzáadunk pár pontot mert jó, ha 4/4 packetünk van a pályán
  502. simulateAction(reader.routerBits, reader.dataArray, pa); ///Leszimuláljuk
  503. posActs.push_back(pa); ///Eltároljuk
  504.  
  505. }
  506.  
  507.  
  508. }
  509.  
  510.  
  511. }
  512. }
  513. ///Ennyi volt a Create. Itt jönnek a mozgások
  514. ///All possible movements
  515. for (int i = 0; i < reader.dataArray.size(); i++)
  516. {
  517.  
  518. if (reader.dataArray[i].fromRouter == alaprouter) ///Végigmegyünk az összes saját packeten
  519. {
  520. ///Leszimuláljuk a router felfele és lefele való mozgatását, eltároljuk
  521. PossibleAction pa1('^', reader.dataArray[i].currRouter);
  522.  
  523. simulateAction(reader.routerBits, reader.dataArray, pa1);
  524.  
  525. posActs.push_back(pa1);
  526.  
  527.  
  528. PossibleAction pa2('v', reader.dataArray[i].currRouter);
  529. simulateAction(reader.routerBits, reader.dataArray, pa2);
  530. posActs.push_back(pa2);
  531.  
  532. ///Igen, ha két packet ugyanazon a routeren van, akkor kétszer szimuláljuk ugyanazt a lépést, de kurvára nem számít
  533.  
  534. }
  535.  
  536. }
  537.  
  538.  
  539. ///Emlékszel a PossibleAction value értékére? Az alapján a legjobbat kiválasztjuk
  540. ///Pick best possible action
  541. int bestID = 0;
  542. for (int i = 1; i < posActs.size(); i++) ///todo if size() = 0 pass
  543. if (posActs[i].value > posActs[bestID].value)
  544. bestID = i;
  545.  
  546.  
  547. ///Run best possible action
  548. PossibleAction& pa = (posActs[bestID]); ///Csak hogy kevesebbet kelljen írni
  549.  
  550. ///A legjobb Possible Action tárolja az utasítást. c/^/v, és a számot. Ezt futtatjuk parancsként.l
  551. if (pa.action == 'c')
  552. {
  553. command = "CREATE " + std::to_string(pa.createSlot) + " " + std::to_string(nextCreateIndex++)+" PRI";
  554. createLeft = !createLeft;
  555. }
  556. else if (pa.action == '^' || pa.action == 'v')
  557. {
  558. command = "MOVE " + std::to_string(pa.moveRouter) + " " + pa.action;
  559. }
  560.  
  561. std::cerr << "RUNCOMMAND0";
  562.  
  563.  
  564. std::cout << reader.data[0] << " " << reader.data[1] << " " << reader.data[2] << " " << command << std::endl;
  565. std::cerr << "." << finishMode << "Command: " << command << "\n";
  566. }
  567.  
  568. /*
  569. for(int i=0; i<azenyem.size(); i++)
  570. {
  571. std::cerr<<azenyem[i].message<<" "<<azenyem[i].index<<std::endl;
  572. }*/
  573.  
  574. ///Ez még mindig a te sortod
  575. ///Sort
  576. for (long unsigned int i = 0; i < azenyem.size() - 1; i++)
  577. {
  578. for (long unsigned int j = 0; j < azenyem.size() - i - 1; j++)
  579. {
  580. if (azenyem[j].index > azenyem[j + 1].index)
  581. {
  582. swap(&azenyem[j], &azenyem[j + 1]);
  583. }
  584. }
  585. }
  586. ///Megoldás kiiratása
  587. std::cerr << "Betaprotokol " << std::endl;
  588. for (int i = 0; i < azenyem.size(); i++)
  589. {
  590. std::cerr << azenyem[i].message << " " << azenyem[i].index << std::endl;
  591. solution = solution + azenyem[i].message;
  592. }
  593. ///************************
  594. std::cerr << "Betaprotokol " << std::endl;
  595.  
  596.  
  597.  
  598. command = "SOLUTION ";
  599. std::cout << reader.data[0] << " " << reader.data[1] << " " << reader.data[2] << " " << command << solution << std::endl;
  600. std::cerr << reader.data[0] << " " << reader.data[1] << " " << reader.data[2] << " " << command << solution << std::endl;
  601. std::cout << "END (latest message): " << reader.previous << std::endl;
  602. std::cerr << "END (latest message): " << reader.previous << std::endl;
  603. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement