API tools faq
paste
Guest User

Untitled

a guest
Apr 21st, 2018
59
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 14.29 KB | None | 0 0
raw download clone embed print report
  1. #include <iostream>
  2. #include <string>
  3. #include <fstream>
  4. #include <sstream>
  5.  
  6. typedef struct maillon {
  7. int indice;
  8. int couleur;
  9. struct maillon* suiv;
  10. struct maillon* circ;
  11. } maillon;
  12.  
  13. typedef maillon* liste;
  14. int cube[54]={1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,6,6,6,6,6,6,6,6,6};
  15.  
  16.  
  17. using namespace std;
  18. maillon melanger( maillon *l,int cube[], int cpt, char melange[]);
  19. void display(void);
  20. maillon permu_A( maillon *l,int cube[]);
  21. maillon permu_B( maillon *l,int cube[]);
  22. maillon permu_C( maillon *l,int cube[]);
  23. maillon permu_D( maillon *l,int cube[]);
  24. maillon permu_E( maillon *l,int cube[]);
  25. maillon permu_F( maillon *l,int cube[]);
  26. maillon permu_G ( maillon *l , int cube[]);
  27. maillon permu_H ( maillon *l , int cube[]);
  28. maillon permu_I ( maillon *l , int cube[]);
  29. maillon permu_J ( maillon *l , int cube[]);
  30. maillon permu_K ( maillon *l , int cube[]);
  31. maillon permu_L ( maillon *l , int cube[]);
  32. maillon permu_M ( maillon *l , int cube[]);
  33. maillon permu_N ( maillon *l , int cube[]);
  34. maillon permu_O ( maillon *l , int cube[]);
  35. maillon permu_P ( maillon *l , int cube[]);
  36. maillon permu_Q ( maillon *l , int cube[]);
  37. maillon permu_R ( maillon *l , int cube[]);
  38. maillon permu_S ( maillon *l , int cube[]);
  39. maillon permu_T ( maillon *l , int cube[]);
  40. maillon permu_U ( maillon *l , int cube[]);
  41. maillon permu_V ( maillon *l , int cube[]);
  42. maillon permu_W ( maillon *l , int cube[]);
  43. maillon permu_X ( maillon *l , int cube[]);
  44. maillon permu_Y ( maillon *l , int cube[]);
  45. maillon permu_Z ( maillon *l , int cube[]);
  46. maillon permu_at ( maillon *l , int cube[]);
  47. //void draw_cube(int cube[54]);
  48. //void display(void);
  49. //void draw_face(float vertex[4][3],char color[3]);
  50.  
  51. void displayCube(int* cube) {
  52. ostringstream command("");
  53. command << "rubik-viewer.exe ";
  54. for (int i = 0; i < 54; i++) command << cube[i];
  55. system(command.str().c_str());
  56. }
  57.  
  58. int main()
  59. {
  60. FILE * stream = fopen("I:\\Documents and Settings\\Piednoir\\Bureau\\input.txt","r");
  61. int nbchar=0;
  62.  
  63. if(stream != NULL)
  64. {
  65. int cpt2=0;
  66. char caractereactuel=0;
  67. caractereactuel = fgetc(stream);
  68. while(caractereactuel != EOF)
  69. {
  70. //cout << caractereactuel; // on l'affiche
  71. caractereactuel = fgetc(stream); // on lit un caractère et on le stocke dans caractere
  72. nbchar++;
  73. }
  74. fseek(stream, 0, SEEK_SET);
  75. char melange[nbchar];
  76. caractereactuel = fgetc(stream);
  77. while(caractereactuel != EOF)
  78. {
  79. melange[cpt2]=caractereactuel;
  80. cout << caractereactuel;
  81. caractereactuel = fgetc(stream); // on lit un caractère et on le stocke dans caractere
  82. cpt2++;
  83. }
  84.  
  85. fclose(stream);
  86.  
  87. int permutation[30][4]={{3,30,46,19},{6,33,47,20},{9,36,48,21},{39,37,43,45},{38,40,44,42},{16,7,37,46},{17,8,40,49},{18,9,43,52},{35,31,29,33},{34,28,30,36},{25,16,36,45},{22,13,35,44},{19,10,34,43},{54,52,46,48},{51,53,49,47},{1,28,52,25},{4,31,53,26},{7,34,54,27},{12,18,16,10},{15,17,13,11},{10,1,39,48},{11,2,42,51},{12,3,45,54},{26,24,20,22},{27,21,19,25},{27,18,30,39},{24,15,29,38},{21,12,28,37},{1,7,9,3},{4,8,6,2}};
  88.  
  89. /** De 0 à 4 c'est rotation en X // 5->9 Y // 10->14 Z // 15->19 -X // 20->24 -Y // 25->29 -Z**/
  90.  
  91. int indice=0,val=0;
  92. maillon* m = new maillon;
  93. m->suiv = NULL;
  94. m->circ=NULL;
  95. maillon* l =m;
  96. for ( int cpt = 0 ; cpt <= 5 ; cpt++)
  97. {
  98. maillon *temp = new maillon;
  99. temp->suiv = NULL; /**LISTE CHAINEE ICI**/
  100. maillon *cycl= new maillon;
  101. temp->circ = cycl;
  102. maillon * tmp =cycl;
  103. indice = 0;
  104. for ( int cpt2 = 0 ; cpt2 <= 4 ; cpt2 ++)
  105. {
  106. val=0;
  107. maillon *temp2 = new maillon;
  108. cycl->circ = temp2;
  109. maillon *permu =new maillon; /**LISTE CIRCULAIRE POUR AVOIR ACCES AUX CYCLES DE PERMUTATION**/
  110. maillon *tmp=permu; /** On garde l'adresse de notre maillon du début**/
  111. cycl->suiv = permu;
  112. permu->indice = permutation[indice][val]-1;
  113. permu->couleur = cube[permu->indice];
  114. //cout <<endl<< "couleur : " << permu->couleur;
  115. //cout <<endl<< "indice : " <<permu->indice+1;
  116. val++;
  117. for ( int cpt3 = 0 ; cpt3 <= 2 ; cpt3++) /**ON CREE NOTRE LISTE CIRCULAIRE DE PERMUTATION ICI**/ //à remplir manuellement
  118. {
  119. maillon *temp3 = new maillon;
  120. temp3->indice = permutation[indice][val]-1;
  121. temp3->couleur = cube[temp3->indice];
  122. //cout <<endl<< "couleur : " << temp3->couleur;
  123. //cout <<endl<< "indice : " <<temp3->indice+1;
  124. // system("pause");
  125. permu->circ = temp3;
  126. permu = temp3;
  127. val++;
  128. }
  129. indice++;
  130. permu->circ = tmp; /**On ferme ici la liste circulaire**/
  131. cycl= cycl->circ;
  132. }
  133. cycl->circ = tmp; /** pareil ici **/
  134. m->suiv = temp;
  135. m=m->suiv;
  136. }
  137. displayCube(cube);
  138. permu_B(l,cube);
  139. cout << endl;
  140. //system("pause");
  141. //melanger(l,cube,nbchar,melange);
  142. displayCube(cube);
  143. }
  144. else
  145. {
  146. system("pause");
  147. cerr << "Impossible d'ouvrir le fichier !" << endl;
  148. }
  149. system("pause");
  150.  
  151. //displayCube(cube);
  152.  
  153. }
  154.  
  155. maillon melanger( maillon *l,int cube[], int nbchar, char melange[])
  156. {
  157. for ( int pp = 0 ; pp < nbchar ; pp ++)
  158. {
  159. cout << melange[pp];
  160. }
  161. cout << endl;
  162. for ( int cmpt = 0 ; cmpt < nbchar ; cmpt++)
  163. {
  164. switch ( melange[cmpt])
  165. {
  166. case 'A':
  167. *l = permu_A( l, cube);
  168. break;
  169. case 'B':
  170. *l = permu_B( l, cube);
  171. break;
  172. case 'C':
  173. *l = permu_C( l, cube);
  174. break;
  175. case 'D':
  176. *l = permu_D( l, cube);
  177. break;
  178. case 'E':
  179. *l = permu_E( l, cube);
  180. break;
  181. case 'F':
  182. *l = permu_F( l, cube);
  183. break;
  184. case 'G':
  185. *l = permu_G( l, cube);
  186. break;
  187. case 'H':
  188. *l = permu_H( l, cube);
  189. break;
  190. case 'I':
  191. *l = permu_I( l, cube);
  192. break;
  193. case 'J':
  194. *l = permu_J( l, cube);
  195. break;
  196. case 'K':
  197. *l = permu_K( l, cube);
  198. break;
  199. case 'L':
  200. *l = permu_L( l, cube);
  201. break;
  202. case 'M':
  203. *l = permu_M( l, cube);
  204. break;
  205. case 'N':
  206. *l = permu_N( l, cube);
  207. break;
  208. case 'O':
  209. *l = permu_O( l, cube);
  210. break;
  211. case 'P':
  212. *l = permu_P( l, cube);
  213. break;
  214. case 'Q':
  215. *l = permu_Q( l, cube);
  216. break;
  217. case 'R':
  218. *l = permu_R( l, cube);
  219. break;
  220. case 'S':
  221. *l = permu_S( l, cube);
  222. break;
  223. case 'T':
  224. *l = permu_T( l, cube);
  225. break;
  226. case 'U':
  227. *l = permu_U( l, cube);
  228. break;
  229. case 'V':
  230. *l = permu_V( l, cube);
  231. break;
  232. case 'W':
  233. *l = permu_W( l, cube);
  234. break;
  235. case 'X':
  236. *l = permu_X( l, cube);
  237. break;
  238. case 'Y':
  239. *l = permu_Y( l, cube);
  240. break;
  241. case 'Z':
  242. *l = permu_Z( l, cube);
  243. break;
  244. case '@':
  245. *l = permu_at( l, cube);
  246. break;
  247. default:
  248. cout << endl << "Caractere non reconnu"<< endl;
  249. break;
  250. }
  251. }
  252. return *l;
  253.  
  254. }
  255.  
  256. maillon permu_A( maillon *l ,int cube[])
  257. {
  258. maillon *cour1,*cour;
  259. cour1 = l->suiv->circ;
  260. int tmp;
  261. for ( int cpt = 0 ; cpt <= 4; cpt ++ )
  262. {
  263. cour = cour1->suiv;
  264. tmp=cube[cour->circ->circ->circ->indice];/** YOU WIN!!!!**/
  265. cube[cour->circ->circ->circ->indice]= cube[cour->circ->circ->indice];
  266. cube[cour->circ->circ->indice]= cube[cour->circ->indice];
  267. cube[cour->circ->indice]= cube[cour->indice];
  268. cube[cour->indice]= tmp;
  269. cour1 =cour1->circ;
  270. }
  271. //displayCube(cube);
  272.  
  273. return *l ;
  274. }
  275. maillon permu_B( maillon *l,int cube[])
  276. {
  277. maillon *cour1,*cour;
  278. cour1 = l->suiv->suiv->circ;
  279. int tmp;
  280. for ( int cpt = 0 ; cpt <= 4; cpt ++ )
  281. {
  282. cour = cour1->suiv;
  283. tmp=cube[cour->circ->circ->circ->indice];/** YOU WIN!!!!**/
  284. cube[cour->circ->circ->circ->indice]= cube[cour->circ->circ->indice];
  285. cube[cour->circ->circ->indice]= cube[cour->circ->indice];
  286. cube[cour->circ->indice]= cube[cour->indice];
  287. cube[cour->indice]= tmp;
  288. cour1 =cour1->circ;
  289. }
  290. //displayCube(cube);
  291. return *l ;
  292. }
  293. maillon permu_C( maillon *l,int cube[])
  294. {
  295. maillon *cour1,*cour;
  296. cour1 = l->suiv->suiv->suiv->circ;
  297. int tmp;
  298. for ( int cpt = 0 ; cpt <= 4; cpt ++ )
  299. {
  300. cour = cour1->suiv;
  301. tmp=cube[cour->circ->circ->circ->indice];/** YOU WIN!!!!**/
  302. cube[cour->circ->circ->circ->indice]= cube[cour->circ->circ->indice];
  303. cube[cour->circ->circ->indice]= cube[cour->circ->indice];
  304. cube[cour->circ->indice]= cube[cour->indice];
  305. cube[cour->indice]= tmp;
  306. cour1 =cour1->circ;
  307. }
  308. //displayCube(cube);
  309. return *l ;
  310. }
  311. maillon permu_D( maillon *l,int cube[])
  312. {
  313. maillon *cour1,*cour;
  314. cour1 = l->suiv->suiv->suiv->suiv->circ;
  315. int tmp;
  316. for ( int cpt = 0 ; cpt <= 4; cpt ++ )
  317. {
  318. cour = cour1->suiv;
  319. tmp=cube[cour->circ->circ->circ->indice];/** YOU WIN!!!!**/
  320. cube[cour->circ->circ->circ->indice]= cube[cour->circ->circ->indice];
  321. cube[cour->circ->circ->indice]= cube[cour->circ->indice];
  322. cube[cour->circ->indice]= cube[cour->indice];
  323. cube[cour->indice]= tmp;
  324. cour1 =cour1->circ;
  325. }
  326. //displayCube(cube);
  327. return *l ;
  328. }
  329. maillon permu_E( maillon *l,int cube[])
  330. {
  331. maillon *cour1,*cour;
  332. cour1 = l->suiv->suiv->suiv->suiv->suiv->circ;
  333. int tmp;
  334. for ( int cpt = 0 ; cpt <= 4; cpt ++ )
  335. {
  336. cour = cour1->suiv;
  337. tmp=cube[cour->circ->circ->circ->indice];/** YOU WIN!!!!**/
  338. cube[cour->circ->circ->circ->indice]= cube[cour->circ->circ->indice];
  339. cube[cour->circ->circ->indice]= cube[cour->circ->indice];
  340. cube[cour->circ->indice]= cube[cour->indice];
  341. cube[cour->indice]= tmp;
  342. cour1 =cour1->circ;
  343. }
  344. //displayCube(cube);
  345. return *l ;
  346. }
  347. maillon permu_F( maillon *l,int cube[])
  348. {
  349. maillon *cour1,*cour;
  350. cour1 = l->suiv->suiv->suiv->suiv->suiv->suiv->circ;
  351. int tmp;
  352. for ( int cpt = 0 ; cpt <= 4; cpt ++ )
  353. {
  354. cour = cour1->suiv;
  355. tmp=cube[cour->circ->circ->circ->indice];/** YOU WIN!!!!**/
  356. cube[cour->circ->circ->circ->indice]= cube[cour->circ->circ->indice];
  357. cube[cour->circ->circ->indice]= cube[cour->circ->indice];
  358. cube[cour->circ->indice]= cube[cour->indice];
  359. cube[cour->indice]= tmp;
  360. cour1 =cour1->circ;
  361. }
  362. displayCube(cube);
  363. return *l ;
  364. }
  365.  
  366. maillon permu_G ( maillon *l , int cube[])
  367. {
  368. *l=permu_A(l,cube);
  369. *l=permu_A(l,cube);
  370. *l=permu_A(l,cube);
  371. return *l;
  372. }
  373.  
  374. maillon permu_H ( maillon *l , int cube[])
  375. {
  376. *l=permu_B(l,cube);
  377. *l=permu_B(l,cube);
  378. *l=permu_B(l,cube);
  379. return *l;
  380. }
  381.  
  382. maillon permu_I ( maillon *l , int cube[])
  383. {
  384. *l=permu_C(l,cube);
  385. *l=permu_C(l,cube);
  386. *l=permu_C(l,cube);
  387. return *l;
  388. }
  389. maillon permu_J ( maillon *l , int cube[])
  390. {
  391. *l=permu_D(l,cube);
  392. *l=permu_D(l,cube);
  393. *l=permu_D(l,cube);
  394. return *l;
  395. }
  396.  
  397. maillon permu_K ( maillon *l , int cube[])
  398. {
  399. *l=permu_E(l,cube);
  400. *l=permu_E(l,cube);
  401. *l=permu_E(l,cube);
  402. return *l;
  403. }
  404.  
  405. maillon permu_L ( maillon *l , int cube[])
  406. {
  407. *l=permu_F(l,cube);
  408. *l=permu_F(l,cube);
  409. *l=permu_F(l,cube);
  410. return *l;
  411. }
  412.  
  413. maillon permu_M ( maillon *l , int cube[])
  414. {
  415. *l=permu_A(l,cube);
  416. *l=permu_A(l,cube);
  417. return *l;
  418. }
  419.  
  420. maillon permu_N ( maillon *l , int cube[])
  421. {
  422. *l=permu_B(l,cube);
  423. *l=permu_B(l,cube);
  424. return *l;
  425. }
  426.  
  427. maillon permu_O ( maillon *l , int cube[])
  428. {
  429. *l=permu_C(l,cube);
  430. *l=permu_C(l,cube);
  431. return *l;
  432. }
  433.  
  434. maillon permu_P ( maillon *l , int cube[])
  435. {
  436. *l=permu_D(l,cube);
  437. *l=permu_D(l,cube);
  438. return *l;
  439. }
  440.  
  441. maillon permu_Q ( maillon *l , int cube[])
  442. {
  443. *l=permu_E(l,cube);
  444. *l=permu_E(l,cube);
  445. return *l;
  446. }
  447.  
  448. maillon permu_R ( maillon *l , int cube[])
  449. {
  450. *l=permu_F(l,cube);
  451. *l=permu_F(l,cube);
  452. return *l;
  453. }
  454.  
  455. maillon permu_S ( maillon *l , int cube[])
  456. {
  457. *l=permu_G(l,cube);
  458. *l=permu_D(l,cube);
  459. return *l;
  460. }
  461.  
  462. maillon permu_T ( maillon *l , int cube[])
  463. {
  464. *l=permu_H(l,cube);
  465. *l=permu_E(l,cube);
  466. return *l;
  467. }
  468.  
  469. maillon permu_U ( maillon *l , int cube[])
  470. {
  471. *l=permu_I(l,cube);
  472. *l=permu_F(l,cube);
  473. return *l;
  474. }
  475.  
  476. maillon permu_V ( maillon *l , int cube[])
  477. {
  478. *l=permu_J(l,cube);
  479. *l=permu_A(l,cube);
  480. return *l;
  481. }
  482.  
  483. maillon permu_W ( maillon *l , int cube[])
  484. {
  485. *l=permu_K(l,cube);
  486. *l=permu_B(l,cube);
  487. return *l;
  488. }
  489.  
  490. maillon permu_X ( maillon *l , int cube[])
  491. {
  492. *l=permu_L(l,cube);
  493. *l=permu_C(l,cube);
  494. return *l;
  495. }
  496.  
  497. maillon permu_Y ( maillon *l , int cube[])
  498. {
  499. *l=permu_S(l,cube);
  500. *l=permu_S(l,cube);
  501. return *l;
  502. }
  503.  
  504. maillon permu_Z ( maillon *l , int cube[])
  505. {
  506. *l=permu_T(l,cube);
  507. *l=permu_T(l,cube);
  508. return *l;
  509. }
  510.  
  511. maillon permu_at ( maillon *l , int cube[])
  512. {
  513. *l=permu_U(l,cube);
  514. *l=permu_U(l,cube);
  515. return *l;
  516. }
Add Comment
Please, Sign In to add comment
Public Pastes
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!