Advertisement
Guest User

Untitled

a guest
Apr 19th, 2014
68
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 15.95 KB | None | 0 0
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include<cstdio>
  4. #include<fstream>
  5. #include<cctype>
  6. #include <iostream>
  7. using namespace std;
  8. //////////////////////////////////////////LISTY
  9. struct jeden_onp
  10. {
  11. jeden_onp *nastepny_onp;
  12. jeden_onp *poprzedni_onp;
  13. double znak;
  14. jeden_onp();
  15.  
  16. };
  17. jeden_onp::jeden_onp()
  18. {
  19. nastepny_onp = 0;
  20. poprzedni_onp = 0;
  21. };
  22. struct onp
  23. {
  24. jeden_onp *pierwszy_onp;
  25. jeden_onp *ostatni_onp;
  26. void dodaj_liczbe(double a);
  27. void usun_liczbe();
  28. onp();
  29.  
  30. };
  31. onp::onp()
  32. {
  33. pierwszy_onp = 0;
  34. }
  35. void onp::dodaj_liczbe(double liczba)
  36. {
  37. jeden_onp *Znak = new jeden_onp;
  38. Znak->znak = liczba;
  39. if (pierwszy_onp == 0)
  40. {
  41. Znak->nastepny_onp=0;
  42. Znak->poprzedni_onp=0;
  43. pierwszy_onp = Znak;
  44. ostatni_onp=Znak;
  45. }
  46.  
  47. else
  48. {
  49.  
  50. ostatni_onp->nastepny_onp = Znak;
  51. Znak->nastepny_onp = 0;
  52. Znak->poprzedni_onp = ostatni_onp;
  53. ostatni_onp=Znak;
  54. }
  55. }
  56. void onp::usun_liczbe()
  57. {
  58. if (pierwszy_onp == ostatni_onp)
  59. {
  60. pierwszy_onp=0;
  61. }
  62. else
  63. {
  64. jeden_onp *przed_usuwanym = ostatni_onp->poprzedni_onp;
  65. przed_usuwanym->nastepny_onp = 0;
  66. delete ostatni_onp;
  67. ostatni_onp=przed_usuwanym;
  68. }
  69. }
  70. struct Zmienna
  71. {
  72. char nazwa[100];
  73. double wartosc;
  74. int nr_nastepny;
  75. };
  76. double licze_nawias(Zmienna TablicaZmiennych[]);
  77. int Hasz(char TablicaDoZakodowania[]);
  78. int szukam_w_tablicy(char TablicaDoZnalezienia[]);
  79. int porownanie_ciagu(char Tablica1[], char Tablica2[])
  80. {
  81. int czy_to_samo = 1;
  82. int i =0;
  83. while ((Tablica2[i]!='\0')&&(czy_to_samo ==1))
  84. {
  85. if (Tablica2[i] != Tablica1[i])
  86. {
  87. czy_to_samo=0;
  88. }
  89. i++;
  90. }
  91. return czy_to_samo;
  92. }
  93. int Hasz(char TablicaDoZakodowania[])
  94. {
  95. int Numer_Tablicy=0;
  96. int pomoc;
  97. int i = 0;
  98. while (TablicaDoZakodowania[i] != '\0')
  99. {
  100. // cout<<TablicaDoZakodowania[i]<<" ma numer ";
  101. pomoc = (int)TablicaDoZakodowania[i];
  102. // cout<<"znaku "<<pomoc<<endl;
  103. pomoc=pomoc*123;
  104. Numer_Tablicy += pomoc;
  105. i++;
  106. }
  107. Numer_Tablicy = Numer_Tablicy*333;
  108. Numer_Tablicy = Numer_Tablicy/24.23454;
  109. Numer_Tablicy = Numer_Tablicy%10000;
  110. Numer_Tablicy++;
  111. return Numer_Tablicy;
  112. }
  113. int szukam_w_tablicy(char TablicaDoZnalezienia[], Zmienna TablicaZmiennych[])
  114. {
  115. int gdzie_powinno;
  116. int flaga = 0;
  117. int i = 0;
  118. gdzie_powinno = Hasz(TablicaDoZnalezienia);
  119. if(TablicaZmiennych[gdzie_powinno].nazwa[0] != TablicaDoZnalezienia[0])
  120. {
  121. while((TablicaZmiennych[gdzie_powinno].nazwa[i] != '\n')&&(TablicaDoZnalezienia[i]!= '\n'))
  122. {
  123. if(TablicaZmiennych[gdzie_powinno].nazwa[i] != TablicaDoZnalezienia[i])
  124. flaga=1;
  125. i++;
  126. }
  127. while(flaga==1)
  128. {
  129. gdzie_powinno=TablicaZmiennych[gdzie_powinno].nr_nastepny;
  130. int i = 0;
  131. flaga = 0;
  132. while((TablicaZmiennych[gdzie_powinno].nazwa[i] != '\n')&&(TablicaDoZnalezienia[i]!= '\n'))
  133. {
  134. if(TablicaZmiennych[gdzie_powinno].nazwa[i] != TablicaDoZnalezienia[i])
  135. flaga=1;
  136. i++;
  137. }
  138. }
  139. }
  140.  
  141. return gdzie_powinno;
  142. }
  143. double licze_nawias(Zmienna TablicaZmiennych[])
  144. {
  145. onp *ONP = new onp;
  146. onp *STOS = new onp;
  147. char znak;
  148. double liczba;
  149. //int koniec_stosu=0;
  150. //int koniec_onp=0;
  151. ///int a=0;
  152. while(cin.peek()!= '\n')
  153. {
  154.  
  155. if((cin.peek()=='+')||(cin.peek()=='-'))
  156. {
  157. znak=getchar();
  158. // int flaga = 0;
  159. // koniec_stosu--;
  160. while((STOS->ostatni_onp->znak!='(')&&(STOS->pierwszy_onp!=0))
  161. {
  162. ONP->dodaj_liczbe(STOS->ostatni_onp->znak);
  163. // onp[koniec_onp]=stos[koniec_stosu];
  164. STOS->usun_liczbe();
  165. // stos[koniec_stosu]=0;
  166. // koniec_onp++;
  167. // koniec_stosu--;
  168. // flaga = 1;
  169. }
  170.  
  171. /*if(flaga==1)
  172. {
  173. koniec_onp--;
  174. koniec_stosu++;
  175. }*/
  176. // koniec_stosu++;
  177. double b = (double)znak;
  178. STOS->dodaj_liczbe(b);
  179. // stos[koniec_stosu]=(int)znak;
  180. // koniec_stosu++;
  181. }
  182. else if((cin.peek()=='/')||(cin.peek()=='*'))
  183. {
  184. znak=getchar();
  185. // int flaga = 0;
  186. // koniec_stosu--;
  187. while((STOS->ostatni_onp->znak!='(')&&(STOS->pierwszy_onp!=0)&&(STOS->ostatni_onp->znak!='+')&&(STOS->ostatni_onp->znak!='-'))
  188. {
  189. ONP->dodaj_liczbe(STOS->ostatni_onp->znak);
  190. // onp[koniec_onp]=stos[koniec_stosu];
  191. STOS->usun_liczbe();
  192. // stos[koniec_stosu]=0;
  193. // koniec_onp++;
  194. // koniec_stosu--;
  195. // flaga = 1;
  196. }
  197.  
  198. /*if(flaga==1)
  199. {
  200. koniec_onp--;
  201. koniec_stosu++;
  202. }*/
  203. // koniec_stosu++;
  204. double b = (double)znak;
  205. STOS->dodaj_liczbe(b);
  206. // stos[koniec_stosu]=(int)znak;
  207. // koniec_stosu++;
  208. }
  209. else if((cin.peek()>=48)&&(cin.peek()<=57))
  210. {
  211. cin>>liczba;
  212. liczba=liczba*100;
  213. ONP->dodaj_liczbe(liczba);
  214. // onp[koniec_onp]=liczba*100;
  215. // koniec_onp++;
  216. }
  217. else if(((cin.peek()>='A')&&(cin.peek()<='Z'))||((cin.peek()>='a')&&(cin.peek()<='z')))
  218. {
  219. char *zmienna = new char[100];
  220. int help=0;
  221. while (cin.peek() != ' ')
  222. {
  223. znak = getchar();
  224. if((znak != ' ')&&(((znak>=65)&&(znak<=90))||((znak>=97)&&(znak<=122))))
  225. {
  226. zmienna[help]=znak;
  227. help++;
  228. }
  229. }
  230. zmienna[help] = '\0';
  231. int nr_zmiennej = szukam_w_tablicy(zmienna,TablicaZmiennych);
  232. liczba = TablicaZmiennych[nr_zmiennej].wartosc;
  233. liczba=liczba*100;
  234. ONP->dodaj_liczbe(liczba);
  235. delete[] zmienna;
  236. }
  237. else if(cin.peek()=='(')
  238. {
  239. znak=getchar();
  240. double b = (double)znak;
  241. STOS->dodaj_liczbe(znak);
  242. // stos[koniec_stosu]=(int)znak;
  243. // koniec_stosu++;
  244. }
  245. else if(cin.peek()==')')
  246. {
  247. znak=getchar();
  248. //koniec_stosu -= 1;
  249. while(STOS->ostatni_onp->znak!='(')
  250. {
  251. ONP->dodaj_liczbe(STOS->ostatni_onp->znak);
  252. //onp[koniec_onp]=stos[koniec_stosu];
  253. //stos[koniec_stosu]=0;
  254. //koniec_onp++;
  255. //koniec_stosu--;
  256. STOS->usun_liczbe();
  257. }
  258. //koniec_onp--;
  259. // stos[koniec_stosu]=0;
  260. STOS->usun_liczbe();
  261. }
  262. else
  263. {
  264. znak=getchar();
  265. }
  266.  
  267. }
  268. ONP->dodaj_liczbe(61);
  269. jeden_onp *temp2 = ONP->pierwszy_onp;
  270. while(temp2->nastepny_onp!=0)
  271. {
  272. cout<<temp2->znak<<endl;
  273. temp2=temp2->nastepny_onp;
  274. }
  275.  
  276. delete STOS;
  277. // double wynik [10];
  278. // koniec_onp=0;
  279. // int koniec_wynik=0;
  280. onp *WYNIK = new onp;
  281.  
  282. jeden_onp *temp = ONP->pierwszy_onp;
  283. while ( temp->znak != 61)
  284. {
  285. if (temp->znak==43)///////////////////////////+////////////////////////////
  286. {
  287. WYNIK->ostatni_onp->poprzedni_onp->znak = WYNIK->ostatni_onp->znak + WYNIK->ostatni_onp->poprzedni_onp->znak;
  288. WYNIK->usun_liczbe();//koniec_wynik--;
  289. }
  290. else if (temp->znak==45)///////////////////////////-////////////////////////////
  291. {
  292. WYNIK->ostatni_onp->poprzedni_onp->znak = WYNIK->ostatni_onp->poprzedni_onp->poprzedni_onp->znak - WYNIK->ostatni_onp->poprzedni_onp->znak;
  293. WYNIK->usun_liczbe();//koniec_wynik--;
  294. }
  295. else if (temp->znak==42)///////////////////////////////////////////////////////
  296. {
  297. WYNIK->ostatni_onp->poprzedni_onp->znak = WYNIK->ostatni_onp->znak * WYNIK->ostatni_onp->poprzedni_onp->znak;
  298. WYNIK->usun_liczbe();//koniec_wynik--;
  299. }
  300. else if (temp->znak==47)///////////////////////////\////////////////////////////
  301. {
  302. WYNIK->ostatni_onp->poprzedni_onp->znak = WYNIK->ostatni_onp->poprzedni_onp->znak / WYNIK->ostatni_onp->znak;
  303. WYNIK->usun_liczbe();//koniec_wynik--;
  304. }
  305. else
  306. {
  307. temp->znak=temp->znak/100;
  308. WYNIK->dodaj_liczbe(temp->znak); // =temp->znak;
  309. // koniec_wynik++;
  310. }
  311. temp=temp->nastepny_onp;
  312. }
  313. cout<<WYNIK->pierwszy_onp->znak;
  314. return WYNIK->pierwszy_onp->znak;
  315. }
  316. void ustaw(Zmienna TablicaZmiennych[])
  317. {
  318. // cout<<"Ustawione"<<endl;
  319. for(int i=0;i<5;i++)
  320. {
  321. char polecenie;
  322. polecenie=getchar();
  323. }
  324.  
  325.  
  326. ///////////////////sczytuje zmiennej nazwe/////////////////
  327. int licznik=0;
  328. char *tablica_pomocnicza = new char[100];
  329.  
  330. while(cin.peek() != ' ')
  331. {
  332. tablica_pomocnicza[licznik]=getchar();
  333. licznik++;
  334. }
  335.  
  336. tablica_pomocnicza[licznik] = '\0';
  337.  
  338.  
  339.  
  340. int nr_tab = Hasz(tablica_pomocnicza);
  341. ////////////////////sprawdzic czy puste/////////////////////////
  342. int nr2 = nr_tab;///////////////////////NR TAB to miejsce gdzie wpisze nowa zmienna
  343. if(TablicaZmiennych[nr_tab].wartosc != 0)
  344. {
  345.  
  346. if (!porownanie_ciagu(TablicaZmiennych[nr_tab].nazwa, tablica_pomocnicza))
  347. {
  348. int Flaga = 1;
  349. while((TablicaZmiennych[nr_tab].nr_nastepny != 0)&&(Flaga==1))
  350. {
  351. nr_tab = TablicaZmiennych[nr_tab].nr_nastepny;
  352. nr2 = nr_tab;
  353. if (!porownanie_ciagu(TablicaZmiennych[nr_tab].nazwa, tablica_pomocnicza))
  354. {
  355. Flaga = 0;
  356. }
  357. }
  358. while((TablicaZmiennych[nr_tab].nr_nastepny != 0)&&(Flaga==1))
  359. {
  360. nr_tab++;
  361. }
  362. TablicaZmiennych[nr2].nr_nastepny = nr_tab;
  363. }
  364. }
  365.  
  366. /////////////////////dalej///////////////////////
  367. for(int i=0; i<licznik; i++)
  368. {
  369. TablicaZmiennych[nr_tab].nazwa[i] = tablica_pomocnicza[i];
  370. }
  371. TablicaZmiennych[nr_tab].nazwa[licznik] = '\0';
  372. delete[] tablica_pomocnicza;
  373. ////////////////////sczytuje spacje rownosc i nawias//////////////////////////////////////////
  374. for(int i=0;i<5;i++)
  375. {
  376. char polecenie;
  377. polecenie=getchar();
  378. }
  379. /* char *nic = new char [2];
  380. nic[0] = '.';
  381. nic[1] = '\0';
  382. Para pomocniczo = licze_nawias(TablicaZmiennych, nic);
  383. delete[] nic;
  384. TablicaZmiennych[nr_tab].wartosc=pomocniczo.wynik;
  385. */
  386. TablicaZmiennych[nr_tab].wartosc=licze_nawias(TablicaZmiennych);
  387. /* cout<<"Wartosc w tablicy = "<<TablicaZmiennych[nr_tab].wartosc<<endl;
  388. cout<<"Nr komorki w tab = "<<nr_tab<<endl;
  389. cout<<"Nazwa zmiennej = ";
  390. for (int i=0; i<licznik; i++)
  391. {
  392. cout<<TablicaZmiennych[nr_tab].nazwa[i];
  393.  
  394. }
  395. cout<<endl;
  396. */
  397. }
  398. void oblicz(Zmienna TablicaZmiennych[])
  399. {
  400. for(int i=0;i<8;i++)////////////////////sczytuje slowo
  401. {
  402. char polecenie;
  403. polecenie=getchar();
  404. }
  405. /*
  406. char *nic = new char[2];
  407. nic[0]='.';
  408. nic[1]='\0';
  409. Para cos = licze_nawias(TablicaZmiennych, nic);
  410. double wynik = cos.wynik;
  411. delete[] nic;
  412. */
  413. double wynik = licze_nawias(TablicaZmiennych);
  414. cout<<wynik<<endl;
  415. }
  416. void wyznacz(Zmienna TablicaZmiennych[])
  417. {
  418. /*
  419. char spacja;
  420. for(int i=0;i<7;i++)////////////////////sczytuje slowo
  421. {
  422. spacja=getchar();
  423. }
  424. int licznik=0;
  425. char *liczba_wyznaczana = new char[100];
  426.  
  427. while(cin.peek() != ' ')
  428. {
  429. liczba_wyznaczana[licznik]=getchar();
  430. licznik++;
  431. }
  432. spacja=getchar();
  433. spacja=getchar();
  434. liczba_wyznaczana[licznik] = '\0';
  435. Para lewa, prawa;
  436. lewa = licze_nawias(TablicaZmiennych, liczba_wyznaczana);
  437.  
  438. spacja=getchar();
  439. spacja=getchar();
  440. spacja=getchar();
  441. prawa = licze_nawias(TablicaZmiennych);
  442. // cout<<"ile liczb z lewej = "<<lewa.wynik<<" | ile zmiennych z lewej = "<<lewa.zmienne<<" | ile liczb z prawej = "<<prawa.wynik<<" | ile zmiennych z prawej = "<<prawa.zmienne<<endl;
  443. double ile_zmiennych, ile_liczb, wynik;
  444. ile_zmiennych=lewa.zmienne;
  445. ile_liczb = prawa.wynik - lewa.wynik;
  446. if(ile_zmiennych==0)
  447. {
  448. cout<<"Niepoprawne rownanie"<<endl;
  449. }
  450. else
  451. {
  452. wynik = ile_liczb * (1/ile_zmiennych);
  453. for(int i=0; i<licznik; i++)
  454. {
  455. cout<<liczba_wyznaczana[i];
  456. }
  457. cout<<" = "<<wynik<<endl;
  458. }
  459.  
  460.  
  461.  
  462. int nr_tab = Hasz(liczba_wyznaczana);
  463. ////////////////////sprawdzic czy puste/////////////////////////
  464. int nr2 = nr_tab;///////////////////////NR TAB to miejsce gdzie wpisze nowa zmienna
  465. if(TablicaZmiennych[nr_tab].wartosc != 0)
  466. {
  467.  
  468. if (!porownanie_ciagu(TablicaZmiennych[nr_tab].nazwa, liczba_wyznaczana))
  469. {
  470. int Flaga = 1;
  471. while((TablicaZmiennych[nr_tab].nr_nastepny != 0)&&(Flaga==1))
  472. {
  473. nr_tab = TablicaZmiennych[nr_tab].nr_nastepny;
  474. nr2 = nr_tab;
  475. if (!porownanie_ciagu(TablicaZmiennych[nr_tab].nazwa, liczba_wyznaczana))
  476. {
  477. Flaga = 0;
  478. }
  479. }
  480. while((TablicaZmiennych[nr_tab].nr_nastepny != 0)&&(Flaga==1))
  481. {
  482. nr_tab++;
  483. }
  484. TablicaZmiennych[nr2].nr_nastepny = nr_tab;
  485. }
  486. }
  487. /////////////////////dalej///////////////////////
  488. for(int i=0; i<licznik; i++)
  489. {
  490. TablicaZmiennych[nr_tab].nazwa[i] = liczba_wyznaczana[i];
  491. }
  492. TablicaZmiennych[nr_tab].nazwa[licznik] = '\0';
  493. TablicaZmiennych[nr_tab].wartosc=wynik;
  494. delete[] liczba_wyznaczana;
  495. */
  496. }
  497.  
  498. int main()
  499. {
  500. Zmienna TablicaZmiennych[10000];
  501. for(int i=0; i<10000; i++)
  502. {
  503. TablicaZmiennych[i].wartosc = 0;
  504. TablicaZmiennych[i].nr_nastepny = 0;
  505. }
  506. int a=1;
  507. while(a==1)
  508. {
  509. char polecenie;
  510. polecenie=getchar();
  511. switch(polecenie)
  512. {
  513. case 'U':
  514. ustaw(TablicaZmiennych);
  515. break;
  516. case 'O':
  517. oblicz(TablicaZmiennych);
  518. break;
  519. case 'W':
  520. wyznacz(TablicaZmiennych);
  521. break;
  522. case 'K':
  523. a=0;
  524. break;
  525. default:
  526. cout<<"Prosze wpisac ponownie"<<endl;
  527. break;
  528. }
  529. cin.sync();
  530.  
  531. }
  532. /*
  533. for(int i=0; i<10000; i++)
  534. {
  535. if(TablicaZmiennych[i].wartosc != 0)
  536. {
  537. int j=0;
  538. while(TablicaZmiennych[i].nazwa[j] != '\0')
  539. {
  540. cout<<TablicaZmiennych[i].nazwa[j];
  541. j++;
  542. }
  543. cout<<" = "<<TablicaZmiennych[i].wartosc<<endl;
  544. }
  545. }
  546. */
  547.  
  548. return 0;
  549. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement