API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 29th, 2015
78
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 17.08 KB | None | 0 0
raw download clone embed print report
  1. //Buffon-féle tű probléma megvalósítása
  2. //Készítettel: Lévai Gábor
  3. //Neptun: AKTA7P
  4.  
  5. //When I wrote this, only God and I understood what I was doing
  6. //Now, God only knows
  7.  
  8. #define _CRT_SECURE_NO_WARNINGS
  9. #define Pi 3.14159265359
  10.  
  11. #include<stdio.h>
  12. #include<string.h>
  13. #include<stdlib.h>
  14. #include<math.h>
  15. #include<time.h>
  16. //#include<SDL.h>
  17.  
  18. /*Struktúra meghatározása*/
  19. typedef struct lista
  20. {
  21. int sorszam;
  22. double x;
  23. double y;
  24. double fok;
  25. int vegeredmeny;
  26. struct lista *kovetkezo; /*Egy irányba láncolt lista*/
  27. }lista;
  28.  
  29. /*Kezdőlista felvétele*/
  30. lista *kezdolista;
  31.  
  32. /*Random koordináta generáló függvény*/
  33. void Random_koordinata(int n)
  34. {
  35. int i; //Futóváltozó
  36. double x,y;
  37. double xertek1,xertek2,xertek3,xertek4;
  38. double yertek1,yertek2,yertek3,yertek4;
  39. char *fnev="koordinata.txt";
  40. FILE *tfp; //Text File Pointer
  41.  
  42. if((tfp = fopen(fnev, "w")) != NULL) {
  43. fprintf(stderr, "\nSiker a %s file megnyitasakor!\n",fnev);}
  44. else{
  45. fprintf(stderr, "\nHiba a %s file megnyitasakor!\n",fnev);}
  46.  
  47. time_t t;
  48. srand((unsigned) time(&t)); //Kívül kell lennie a for cikluson, nemtudni miért de tapasztalat szerint így működik, úgy nem.
  49. for(i=0; i<n; i++)
  50. {
  51. xertek1=rand() % 10;
  52. xertek2=rand() % 10;
  53. xertek3=rand() % 10;
  54. xertek4=rand() % 10;
  55.  
  56. yertek1=rand() % 10;
  57. yertek2=rand() % 10;
  58. yertek3=rand() % 10;
  59. yertek4=rand() % 10;
  60.  
  61. x=((xertek1*10)+(xertek2)+(xertek3/10)+(xertek4/100)); //A maradékos osztások elvégzése után itt és a következő sorban visszalakítunk.
  62. y=((yertek1*10)+(yertek2)+(yertek3/10)+(yertek4/100)); //Valójában az x koordináta felesleges Pi meghatározásához, egyedül az y a fontos tényező.
  63.  
  64. fprintf(tfp,"x:%lf y:%lf ",x,y); //Fájlba írás
  65. }
  66. fclose(tfp); /*Fájl bezárása*/
  67. free(tfp); /*tfp visszaadása*/
  68. }
  69.  
  70. /*Random dőlésszög generáló függvény*/
  71. void Random_dolesszog(int n)
  72. {
  73. int i;
  74. time_t t;
  75. double fok[1];
  76.  
  77. srand((unsigned) time(&t)); //A srand() mindig kívül van a cikluson, és úgy működik. Ez nincs leírva sehol, mert nekik evidens. :)
  78.  
  79. FILE *bfp; //Binary File Pointer
  80. char *fnev="dolesszog.dat";
  81.  
  82. if((bfp = fopen(fnev, "wb")) != NULL) {
  83. fprintf(stderr,"\nSiker a %s file megnyitasakor!\n",fnev);}
  84. else{
  85. fprintf(stderr,"\nHiba a %s file megnyitasakor!\n",fnev);} /*Else ágba nyílik hogy ne legyen memory leak.*/
  86.  
  87. for(i=0; i<n; i++)
  88. {
  89. fok[0] = rand() % 181;
  90. if(fwrite(fok,sizeof(double),1,bfp)!=1) /*fok[1] tömb típusban double méretű (a majdani sin függvény miatt) 1db elemet írunk bfp pointerrel.*/
  91. {
  92. fprintf(stderr,"\nHiba a dolesszogek kiirasakor!\n");
  93. }
  94. }
  95. fclose(bfp);/*Fájl bezárása*/
  96. free(bfp);/*bfp visszaadása*/
  97. }
  98.  
  99. /*Pi kiírására szolgáló függvény*/
  100. lista *Pikiir(lista *kezdolista, int stick, int line)
  101. {
  102. double szamlalo=0, nevezo=0;
  103. double valoszinuseg, pi, kulonbseg;
  104. lista *mozgo=kezdolista; /*Helyezzük a lista legelejér a mozgo pointert*/
  105. for(mozgo=kezdolista; mozgo!=NULL; mozgo=mozgo->kovetkezo) //Lista bejárása
  106. {
  107. if((mozgo->vegeredmeny)==1)
  108. szamlalo++;
  109. if((mozgo->vegeredmeny)==0)
  110. nevezo++;
  111. }
  112. nevezo=nevezo+szamlalo;
  113. valoszinuseg=(szamlalo/nevezo);
  114.  
  115. pi=(stick)/(line*valoszinuseg);
  116. kulonbseg=(Pi-pi);
  117.  
  118. printf_s("\nIgazi Pi: 3.14159265359\n");
  119. printf_s("\nSzamolt Pi: %lf\n",pi);
  120. printf_s("\nA kulonbseg: %lf\n",kulonbseg);
  121.  
  122. free(mozgo);/*mozgo felszabadítása*/
  123. return kezdolista;
  124. }
  125.  
  126. /*A listát felépítő függvény. Az adatokat a Központi függvényből hívja meg.*/
  127. lista *Kezdolista_beszur(lista*eleje, double x, double y,double fi,int stick, int line, int i,int n)
  128. {
  129. double egyseghossz=line, eredmeny=0;
  130. double h, h1, c;
  131. do{
  132. c=((stick*sin(fi))/2);
  133. h=egyseghossz-y;
  134. h1=line-h;
  135. if(((h>=0)&&(h<=c))||((h1>=0)&&(h1<=c))) /*Ezt még Buffon határozta meg így. ANNO 1777*/
  136. {
  137. eredmeny=1;
  138. }
  139. else
  140. {
  141. eredmeny=0;
  142. egyseghossz=egyseghossz+line;
  143. }
  144. }while((egyseghossz<=100) && (eredmeny==0)); /*Lehetne módosítani (100+(stick/2)) -re is akár*/
  145.  
  146. lista *lp=(lista*)malloc(sizeof(lista));
  147. lp->x=x;
  148. lp->y=y;
  149. lp->fok=fi;
  150. lp->vegeredmeny=eredmeny;
  151. lp->sorszam=n-i; //ELLENŐRZŐ PONT //printf_s("\n%d. \t %lf \t %lf \t %lf \t %d\n",lp->sorszam,lp->x,lp->y,lp->fok,lp->vegeredmeny);
  152. lp->kovetkezo=eleje;
  153. return lp;
  154. }
  155.  
  156. /*Itt hajtódik végre a fájlból olvasás és az adatok továbbísa a láncolt listát megalkotó beszúró függvényhez*/
  157. lista *Kozponti_fv(int n, int set, int line, int stick)
  158. {
  159. FILE *tfp;
  160. FILE *bfp;
  161. int i=0; //Sorszámot ad meg, nullától kezdődik.
  162. double x,y;
  163. double fok[1], fi;
  164.  
  165. tfp=fopen("koordinata.txt","r");
  166. if(tfp!=NULL){
  167. printf_s("\nSiker a koordinata.txt fajl olvasasakor!\n");}
  168. else{
  169. printf_s("\nHiba a koordinata.txt fajl olvasasakor!\n");}
  170.  
  171. bfp=fopen("dolesszog.dat","rb");
  172. if(bfp!=NULL){
  173. printf_s("\nSiker a dolesszog.dat olvasasakor!\n");}
  174. else{
  175. printf_s("\nHiba a dolesszog.dat olvasasakor!\n");}
  176.  
  177. //LISTA LÉTREHOZÁS//
  178.  
  179. lista *kezdolista = NULL;
  180. while((fscanf(tfp,"x:%lf y:%lf ",&x,&y)==2) && (fread(fok,sizeof(double),1,bfp)==1))
  181. {
  182. fi=fok[0];
  183. kezdolista=Kezdolista_beszur(kezdolista,x,y,fi,stick,line,i,n);
  184. i++;
  185. }
  186. fclose(tfp);
  187. fclose(bfp);
  188. free(tfp);
  189. free(bfp);
  190. kezdolista=Pikiir(kezdolista,stick,line);
  191. return kezdolista;
  192. }
  193.  
  194. /*Rendező függvény, mely a kívánt set érték szerint sorba rendez.*/
  195. lista *Csere_fv(lista*kezdolista,int n, int set)
  196. {
  197. int i;
  198. lista *bp=(lista*)malloc(sizeof(lista));
  199. lista *lemarado=kezdolista;
  200. lista *mozgo=kezdolista->kovetkezo;
  201.  
  202. /*Minden egyes függvény a set_fv ben meghatározott módon rendezi sorba az elemeket. A rendezés n*n-szer fut végig, mert ha az utolsó elemmel akarunk valamit,
  203. például előre hozni, akkor azt n-szer biztosan előrébb kell hozzni. A lépészám kijön n^2-ből.
  204. Lehet hogy lehet kevesebből is, de házit írok nem a NASA-t töröm fel! :)*/
  205.  
  206. if(set==0){
  207. printf_s("\nSorszam szerinti rednezes!\n");
  208. for(mozgo=kezdolista,i=0; mozgo!=NULL,i<n; mozgo=mozgo->kovetkezo,i++)
  209. {
  210. mozgo->sorszam=i;
  211. printf_s("\n%d. \t %lf \t %lf \t %lf \t %d\n",mozgo->sorszam,mozgo->x,mozgo->y,mozgo->fok,mozgo->vegeredmeny);
  212. }
  213. free(bp);
  214. free(mozgo);
  215. return kezdolista;
  216. }
  217. if(set==1){
  218. printf_s("\nX szerint novekvo rednezes!\n");
  219. for(i=0;i<n*n;i++)
  220. {
  221. lemarado=kezdolista;
  222. mozgo=kezdolista->kovetkezo;
  223. do{
  224. if((lemarado->x)>(mozgo->x))
  225. {
  226. (bp->x)=(lemarado->x);
  227. (lemarado->x)=(mozgo->x);
  228. (mozgo->x)=(bp->x);
  229. lemarado=lemarado->kovetkezo;
  230. mozgo=mozgo->kovetkezo;
  231. }
  232. else
  233. {
  234. lemarado=lemarado->kovetkezo;
  235. mozgo=mozgo->kovetkezo;
  236. }
  237. }while(mozgo!=NULL);
  238. }
  239. free(bp);
  240. free(lemarado);
  241. for(mozgo=kezdolista,i=0; mozgo!=NULL,i<n; mozgo=mozgo->kovetkezo,i++)
  242. {
  243. mozgo->sorszam=i;
  244. printf_s("\n%d. \t %lf \t %lf \t %lf \t %d\n",mozgo->sorszam,mozgo->x,mozgo->y,mozgo->fok,mozgo->vegeredmeny);
  245. }
  246. free(mozgo);
  247. return kezdolista;
  248. }
  249. if(set==2){ printf_s("\nY szerint novekvo rednezes!\n");
  250. for(i=0;i<n*n;i++)
  251. {
  252. lemarado=kezdolista;
  253. mozgo=kezdolista->kovetkezo;
  254. do{
  255. if((lemarado->y)>(mozgo->y))
  256. {
  257. (bp->y)=(lemarado->y);
  258. (lemarado->y)=(mozgo->y);
  259. (mozgo->y)=(bp->y);
  260. lemarado=lemarado->kovetkezo;
  261. mozgo=mozgo->kovetkezo;
  262. }
  263. else
  264. {
  265. lemarado=lemarado->kovetkezo;
  266. mozgo=mozgo->kovetkezo;
  267. }
  268. }while(mozgo!=NULL);
  269. }
  270. free(bp);
  271. free(lemarado);
  272. for(mozgo=kezdolista,i=0; mozgo!=NULL,i<n; mozgo=mozgo->kovetkezo,i++)
  273. {
  274. mozgo->sorszam=i;
  275. printf_s("\n%d. \t %lf \t %lf \t %lf \t %d\n",mozgo->sorszam,mozgo->x,mozgo->y,mozgo->fok,mozgo->vegeredmeny);
  276. }
  277. free(mozgo);
  278. return kezdolista;
  279.  
  280. }
  281. if(set==3){ printf_s("\nFok szerint novekvo rednezes!\n");
  282. for(i=0;i<n*n;i++)
  283. {
  284. lemarado=kezdolista;
  285. mozgo=kezdolista->kovetkezo;
  286. do{
  287. if((lemarado->fok)>(mozgo->fok))
  288. {
  289. (bp->fok)=(lemarado->fok);
  290. (lemarado->fok)=(mozgo->fok);
  291. (mozgo->fok)=(bp->fok);
  292. lemarado=lemarado->kovetkezo;
  293. mozgo=mozgo->kovetkezo;
  294. }
  295. else
  296. {
  297. lemarado=lemarado->kovetkezo;
  298. mozgo=mozgo->kovetkezo;
  299. }
  300. }while(mozgo!=NULL);
  301. }
  302. free(bp);
  303. free(lemarado);
  304. for(mozgo=kezdolista,i=0; mozgo!=NULL,i<n; mozgo=mozgo->kovetkezo,i++)
  305. {
  306. mozgo->sorszam=i;
  307. printf_s("\n%d. \t %lf \t %lf \t %lf \t %d\n",mozgo->sorszam,mozgo->x,mozgo->y,mozgo->fok,mozgo->vegeredmeny);
  308. }
  309. free(mozgo);
  310. return kezdolista;
  311.  
  312. }
  313. if(set==-1){ printf_s("\nX szerint csokkeno rednezes!\n");
  314. for(i=0;i<n*n;i++)
  315. {
  316. lemarado=kezdolista;
  317. mozgo=kezdolista->kovetkezo;
  318. do{
  319. if((lemarado->x)<(mozgo->x)){
  320. (bp->x)=(mozgo->x);
  321. (mozgo->x)=(lemarado->x);
  322. (lemarado->x)=(bp->x);
  323. lemarado=lemarado->kovetkezo;
  324. mozgo=mozgo->kovetkezo;}
  325. else{
  326. lemarado=lemarado->kovetkezo;
  327. mozgo=mozgo->kovetkezo;}
  328. }while(mozgo!=NULL);}
  329. free(bp);
  330. free(lemarado);
  331. for(mozgo=kezdolista,i=0; mozgo!=NULL,i<n; mozgo=mozgo->kovetkezo,i++){
  332. mozgo->sorszam=i;
  333. printf_s("\n%d. \t %lf \t %lf \t %lf \t %d\n",mozgo->sorszam,mozgo->x,mozgo->y,mozgo->fok,mozgo->vegeredmeny);
  334. }
  335. free(mozgo);
  336. return kezdolista;
  337. }
  338. if(set==-2){ printf_s("\nY szerint csokkeno rednezes!\n");
  339. for(i=0;i<n*n;i++){
  340. lemarado=kezdolista;
  341. mozgo=kezdolista->kovetkezo;
  342. do{
  343. if((lemarado->y)<(mozgo->y)){
  344. (bp->y)=(mozgo->y);
  345. (mozgo->y)=(lemarado->y);
  346. (lemarado->y)=(bp->y);
  347. lemarado=lemarado->kovetkezo;
  348. mozgo=mozgo->kovetkezo;}
  349. else{
  350. lemarado=lemarado->kovetkezo;
  351. mozgo=mozgo->kovetkezo;}
  352. }while(mozgo!=NULL);}
  353. free(bp);
  354. free(lemarado);
  355. for(mozgo=kezdolista,i=0; mozgo!=NULL,i<n; mozgo=mozgo->kovetkezo,i++)
  356. {
  357. mozgo->sorszam=i;
  358. printf_s("\n%d. \t %lf \t %lf \t %lf \t %d\n",mozgo->sorszam,mozgo->x,mozgo->y,mozgo->fok,mozgo->vegeredmeny);
  359. }
  360. free(mozgo);
  361. return kezdolista;
  362. }
  363. if(set==-3){ printf_s("\nFok szerint csokkeno rednezes!\n");
  364. for(i=0;i<n*n;i++)
  365. {
  366. lemarado=kezdolista;
  367. mozgo=kezdolista->kovetkezo;
  368. do{
  369. if((lemarado->fok)<(mozgo->fok))
  370. {
  371. (bp->fok)=(mozgo->fok);
  372. (mozgo->fok)=(lemarado->fok);
  373. (lemarado->fok)=(bp->fok);
  374. lemarado=lemarado->kovetkezo;
  375. mozgo=mozgo->kovetkezo;
  376. }
  377. else
  378. {
  379. lemarado=lemarado->kovetkezo;
  380. mozgo=mozgo->kovetkezo;
  381. }
  382. }while(mozgo!=NULL);
  383. }
  384. free(bp);
  385. free(lemarado);
  386. for(mozgo=kezdolista,i=0; mozgo!=NULL,i<n; mozgo=mozgo->kovetkezo,i++)
  387. {
  388. mozgo->sorszam=i;
  389. printf_s("\n%d. \t %lf \t %lf \t %lf \t %d\n",mozgo->sorszam,mozgo->x,mozgo->y,mozgo->fok,mozgo->vegeredmeny);
  390. }
  391. free(mozgo);
  392. return kezdolista;
  393. }
  394. /*Ez az else ág kell, mert hisztizett a fordító*/
  395. else
  396. {
  397. free(lemarado);
  398. free(mozgo);
  399. free(bp);
  400. return kezdolista;
  401. }
  402. }
  403.  
  404. /*Az adott elemeket törlő függvény*/
  405. lista *Torol_fv(lista*kezdolista, int del,int stick, int line)
  406. {
  407. /*Három esetre bontjuk szét*/
  408.  
  409. lista *lemarado=NULL, *mozgo=kezdolista;
  410. while(mozgo!=NULL && mozgo->sorszam!=del) /*Itt keressük meg az elemet, tehát itt megy végbe a keresés!*/
  411. {
  412. lemarado=mozgo; mozgo=mozgo->kovetkezo;
  413. }
  414. if(mozgo==NULL)
  415. {
  416. printf_s("\nNincs ilyen elem!\n"); /*Itt állapítja meg a függvény, hogy van-e egyáltalán megfelelő eleme a sorozatnak.*/
  417. free(lemarado); //Bár a lemarado úgyis a NULL-ra mutat.
  418. return kezdolista;
  419. }
  420. if(lemarado==NULL)
  421. { //Az első cucc törlésésre. //Ha az első cuccot kell törölni.
  422. lista *ujkezdolista=mozgo->kovetkezo;
  423. free(mozgo);
  424.  
  425. lista *mocorgo; //Újra kiírás, mert ez is a program feladata.
  426. printf_s("\nUjra kiiras!\n");
  427. for(mocorgo=ujkezdolista;mocorgo!=NULL;mocorgo=mocorgo->kovetkezo)
  428. {
  429. printf_s("\n%d. \t %lf \t %lf \t %lf \t %d\n",mocorgo->sorszam,mocorgo->x,mocorgo->y,mocorgo->fok,mocorgo->vegeredmeny);
  430. }
  431. ujkezdolista=Pikiir(ujkezdolista,stick,line);
  432. return ujkezdolista;
  433. }
  434. lemarado->kovetkezo=mozgo->kovetkezo; //Közepe vagy vége
  435. free(mozgo);
  436. lista *mocorgo; /*Azért kellett a mocorgo pointer, mert nem lehetett tovább dolgozni a mozgo pointerrel, hiszen azt már felszabadítottuk.*/
  437. printf_s("\nUjra kiiras!\n");
  438. for(mocorgo=kezdolista;mocorgo!=NULL;mocorgo=mocorgo->kovetkezo)
  439. {
  440. printf_s("\n%d. \t %lf \t %lf \t %lf \t %d\n",mocorgo->sorszam,mocorgo->x,mocorgo->y,mocorgo->fok,mocorgo->vegeredmeny);
  441. }
  442. kezdolista=Pikiir(kezdolista,stick,line);
  443. return kezdolista;
  444. }
  445.  
  446. /*Adatbekérő függvény [n]*/
  447. int dobas_szam()
  448. {
  449. int n;
  450. double limit=2147483648; //Ennyit bír az int. Többet nagyon úgyse érdemes, mert itt ülünk még jövő ugyanekkor is.
  451. do{
  452. printf_s("\n\nHany feldobast szeretne megvalositani? Csak egesz szamot adjon meg!\n");
  453. scanf_s("%d",&n);
  454. if(n>0 && n<=limit)
  455. {
  456. return n;
  457. }
  458. else
  459. {
  460. printf_s("\nHiba!\n");
  461. }
  462. }while(n<=0 || n>limit);
  463. return n; /*Ezt is csak azért kellett, mert visított a fordító...*/
  464. }
  465.  
  466. /*Adatbekérő függvény [set]*/
  467. int set_fv()
  468. {
  469. int set;
  470. do{
  471. printf_s("\nMilyen sorrendben szeretne legeneralni a majdani legeneralt ertekeket?\n[(Csokkeno: - vagy Novekvo: + ) \nHelybenhagyas:0; X szerint: 1; Y szerint: 2; Fok szerint: 3]\nCsak egesz szamot adjon meg!\n");
  472. scanf_s("%d",&set);
  473. if(set>3 || set<-3){
  474. printf_s("\nHiba!\n");
  475. }
  476. }while(set>3 || set<-3);
  477. return set;
  478. }
  479.  
  480. /*Adatbekérő függvény [line]*/
  481. int line_fv()
  482. {
  483. int line;
  484. do{
  485. printf_s("\nKerem adja meg a parhuzamos vonalak tavolsagat, mely minimum +2 es maximum +50 lehet!\nCsak egesz szamot adjon meg!\n");
  486. scanf_s("%d",&line);
  487. if(line<=1 || line>50)
  488. {
  489. printf_s("\nHiba!\n");
  490. }
  491. }while(line<=1 || line>50);
  492. return line;
  493. }
  494.  
  495. /*Adatbekérő függvény [stick]*/
  496. int stick_fv(int line)
  497. {
  498. int stick;
  499. do{
  500. printf_s("\nKerem adja meg a tu hosszat! Legyen nem negativ egesz es kisebbegyenlo mint a parhuzamos vonalak tavolsaga!\n");
  501. scanf_s("%d",&stick);
  502. if(stick<=0 || stick>line)
  503. {
  504. printf_s("\nHiba!\n");
  505. }
  506.  
  507. }while(stick<=0 || stick>line);
  508. return stick;
  509. }
  510.  
  511. /*A "Szeretne-e törölni?" függvény*/
  512. int delc_beker(){
  513. int delnumber;
  514. do{
  515. printf_s("\nSzeretne elemet torolni? Igen=1 || Nem=0\nCsak egesz szamot adjon meg!\n");
  516. scanf_s("%d",&delnumber);
  517. if(delnumber==1)
  518. {
  519. return 1;
  520. }
  521. if(delnumber==0)
  522. {
  523. return 0;
  524. }
  525. else{printf_s("\nHiba!\n");}
  526. }while((delnumber!=0) || (delnumber !=1));
  527. return 0;
  528. }
  529.  
  530. /*A "Melyik elemet szeretné törlölni?" függvény [deln]*/
  531. int del_beker(int deln)
  532. {
  533. /*Nem feladata megállapítani hogy már egy elemet töröltünk-e korábban a listában*/
  534. int del;
  535. do{
  536. printf_s("\nMelyik elemet szeretne torolni?\nCsak egesz szamot adjon meg!\n");
  537. scanf_s("%d",&del);
  538. if((0<=del) && (del<deln)){}
  539. if(del<0 || del>=deln)
  540. {
  541. printf_s("\nHiba! Nincs ilyen elem\n");
  542. }
  543. }while(del<0 || del>=deln);
  544. return del;
  545. }
  546.  
  547. /*A fő függvény.*/
  548. int main(){
  549. printf_s("\t\tWelcome User!\n");
  550.  
  551. //ELSŐ FÁZIS - ADATOK BEKÉRÉSE//
  552.  
  553. //0//
  554.  
  555. int n;
  556. n=dobas_szam();
  557.  
  558. //1//
  559.  
  560. int set;
  561. set=set_fv();
  562.  
  563. //2//
  564.  
  565. int line;
  566. line=line_fv();
  567.  
  568. //3//
  569.  
  570. int stick;
  571. stick=stick_fv(line);
  572.  
  573. //MÁSODIK FÁZIS - KOORDINÁTA ÉRTÉKEK LEGENERÁLÁSA//
  574.  
  575. Random_koordinata(n); //Fájlba is ír, minden zsír ezzel a gyöngyszemmel!
  576.  
  577. //HARMADIK FÁZIS - SZÖG ÉRTÉKEK LEGENERÁLÁSA//
  578.  
  579. Random_dolesszog(n); //Jó, ha int értékel nem megy, akkor csináljuk struktúrával! //S lám, azzal megy :D
  580.  
  581. //NEGYEDIK FÁZIS - KOORDINÁTÁK ÉS SZÖGEK BEOLVASÁSA FÁJLBÓL LÁNCOLT LISTÁBA - A FŐ PROGRAMRÉSZ //
  582.  
  583. kezdolista=Kozponti_fv(n,set,line,stick);
  584.  
  585. //ÖTÖDIK FÁZIS - ELEMEK RENDEZÉSE//
  586.  
  587. kezdolista=Csere_fv(kezdolista,n,set);
  588.  
  589. //HATODIK FÁZIS - ELEMEK TÖRLÉSE - PI újbóli számolt értékének kiírása//
  590.  
  591. int delc;
  592. int del;
  593. do{
  594. delc=delc_beker();
  595. if(delc==1)
  596. {
  597. del=del_beker(n);
  598. kezdolista=Torol_fv(kezdolista,del,stick,line);
  599. }
  600. if(delc==0)
  601. {
  602. printf_s("\nTobb elem torlesere nincs lehetoseg!\n");
  603. }
  604. }while(delc==1);
  605.  
  606. //HETEDIK FÁZIS - Könnyes búcsú//
  607.  
  608.  
  609. free(kezdolista);
  610. printf_s("\n\t\tGoodby User!\t\t\n");
  611. getchar();
  612. getchar();
  613. return 0;
  614. }
  615.  
  616. /*Már csak az SDL-es megírás maradt, de ezt a laborvezető, Nagy Balázs megengedte, hogy december 4-éig bemutassam, tehát kitolta a határidőt!*/
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!