C programs

Wednesday, December 21, 2005

 

Ocena studenta na osnovu tri kolokvijuma

  1. /**********************************************************************
  2. *  Napisati C program koji za svakog studenta ucitava broj indexa i osvojene bodove za
  3. *  tri zadatka A B i C, a zatim izracunava ukupan broj osvojenih bodova i na osnovu tog
  4. *  pozivom funkcije odredjuje zakljcnu ocenu.
  5. *
  6. *  Obezbediti da se rezultati stampaju u po opadajucoj vrednosti broja bodova u obliku:
  7. *
  8. *  1.  11541  21  54  32  8
  9. *  2.  11335  62  32  48  10
  10. *
  11. *  maximalan broj bodova po zadacima je 30, 30 i 40. Ocena se formiara po pravilu:
  12. *  0-54 - 5
  13. *  55-64 - 6
  14. *  65-74 - 7
  15. *  75-84 - 8
  16. *  85-94 - 9
  17. *  95-100 - 10
  18. **********************************************************************/
  19.  
  20. #include <stdio.h>
  21. #define MAX_NIZ 1000
  22.  
  23. /******************************************
  24. *
  25. *  Prototip funkcije
  26. *
  27. ******************************************/
  28. int ocena (int);
  29.  
  30.  
  31. main () {
  32.  
  33.     /*******************************************************************
  34.     *
  35.     *      Inicijalizacija promenljivih
  36.     *  stud je matrica u kojo se cuvaju brojevi indexa i bodovi svakog studenta
  37.     *  i, j, k su brojaci za petlje
  38.     *  n je broj studenata
  39.     *  pom sluzi za menjanje vrednosti prilikom sortiranja
  40.     *  again je promenljiva za ponavaljanje programa ako korisnik to zeli
  41.     *
  42.     *******************************************************************/
  43.     int stud[MAX_NIZ][6], i, j, n, pom, k;
  44.     char again='y';
  45.    
  46.  
  47.     while (again=='y') {
  48.             /******************************
  49.             *
  50.             *  Inicijalizacija matrice
  51.             *
  52.             *****************************/
  53.             for (i=0; i<MAX_NIZ; i++) for (j=0; j<4; stud[i][j++] = 0) ;
  54.            
  55.             /*****************************
  56.             *
  57.             *  Uvodna konverzavija
  58.             *
  59.             ******************************/
  60.             printf("Program za racunanje ocene studenata na osnovu bodova iz 3 testa\n");
  61.            
  62.             /****************************
  63.             *
  64.             *  Unos broja studenata
  65.             *
  66.             ****************************/
  67.             printf("\n\tZa koliko studenta zelite da racunate ocenu? ");
  68.             scanf("%d", &n);
  69.             while (n<=0 || n>MAX_NIZ) {
  70.                 printf("Broj je van opsega! Za koliko studenata zelite da racunate ocenu? ");
  71.                 scanf("%d", &n);
  72.                 }
  73.                
  74.                
  75.             /***************************
  76.             *
  77.             *  Unos matrice sa podacima
  78.             *
  79.             ***************************/
  80.             /***************************
  81.             *
  82.             *  0 - broj indexa
  83.             *  1 - broj bodova iz testa A
  84.             *  2 - broj bodova iz testa B
  85.             *  3 - broj bodova iz testa C
  86.             *  4 - ukupan broj bodova
  87.             *  5 - ocena
  88.             *
  89.             ***************************/
  90.             for (i=0; i<n; i++) {
  91.            
  92.                 /**********************************************
  93.                 *
  94.                 *  Unsos brojeva indexa
  95.                 *
  96.                 **********************************************/
  97.                 printf("\tUnesite broj indexa studenta za %d. studenta : ", i+1);
  98.                 scanf("%d", &stud[i][0]);
  99.                
  100.                 /*********************************************
  101.                 *
  102.                 *  Unos bodova iz prvog testa
  103.                 *
  104.                 **********************************************/
  105.                 printf("\tUnesite broj bodova iz testa A za %d. studenta : ", i+1);
  106.                 scanf("%d", &stud[i][1]);
  107.                 while (stud[i][1]<0 || stud[i][1]>30) {
  108.                     printf("\t\tBroj bodova je izvan osega\n\tUnesite broj bodova iz testa A za %d. studenta : ", i+1);
  109.                     scanf("%d", &stud[i][1]);
  110.                     }
  111.                    
  112.                 /**********************************************
  113.                 *
  114.                 *  Unos bodova iz drugog testa
  115.                 *
  116.                 **********************************************/
  117.                 printf("\tUnesite broj bodova iz testa B za %d. studenta : ", i+1);
  118.                 scanf("%d", &stud[i][2]);
  119.                 while (stud[i][2]<0 || stud[i][2]>30) {
  120.                     printf("\t\tBroj bodova je izvan osega\n\tUnesite broj bodova iz testa B za %d. studenta : ", i+1);
  121.                     scanf("%d", &stud[i][2]);
  122.                     }
  123.                    
  124.                 /**********************************************
  125.                 *
  126.                 *  Unos bodova iz treceg testa
  127.                 *
  128.                 **********************************************/
  129.                 printf("\tUnesite broj bodova iz testa C za %d. studenta : ", i+1);
  130.                 scanf("%d", &stud[i][3]);
  131.                 while (stud[i][3]<0 || stud[i][3]>40) {
  132.                     printf("\t\tBroj bodova je izvan osega\n\tUnesite broj bodova iz testa C za %d. studenta : ", i+1);
  133.                     scanf("%d", &stud[i][3]);
  134.                     }
  135.                
  136.                 printf("\n\n");
  137.                
  138.                 /***************************************
  139.                 *
  140.                 *  Racunanje ukupnog broja bodova
  141.                 *
  142.                 ***************************************/
  143.                 stud[i][4] = stud[i][1] + stud[i][2] + stud[i][3];
  144.                
  145.                 /**************************************
  146.                 *
  147.                 *  Racunanje ocene pomocu funkcije ocena
  148.                 *
  149.                 ***************************************/
  150.                 stud[i][5] = ocena(stud[i][4]);
  151.                
  152.             }
  153.  
  154.            
  155.             /**************************************
  156.             *
  157.             *  Sortiranje matrice na osnovu broja bodova
  158.             *
  159.             **************************************/
  160.             for (i=0; i<n-1; i++) {
  161.                 for (j=i; j<n; j++) {
  162.                     if (stud[j][4]>stud[i][4]) {
  163.                         for (k=0; k<6; k++) {
  164.  
  165.                             pom = stud[i][k];
  166.                             stud[i][k] = stud[j][k];
  167.                             stud[j][k] = pom;
  168.                            
  169.                         }         
  170.                     }      
  171.                 }   
  172.             }
  173.            
  174.             /************************************
  175.             *
  176.             *  Ispis rezultata
  177.             *
  178.             ************************************/
  179.             printf("\n\tBodovna lista: \n");
  180.             printf("    Red.br     Br. indexa   Test A   Test B   Test C   Ukupno   Ocena\n");
  181.             for (i=0; i<n; i++) {
  182.                 printf("%8d.%14d%9d%9d%9d%9d%8d\n", i+1, stud[i][0], stud[i][1], stud[i][2], stud[i][3], stud[i][4], stud[i][5]); 
  183.            
  184.            
  185.             }
  186.             /************************************************
  187.             *
  188.             *  Provera da li korinik zeli da ponovi program
  189.             *
  190.             ************************************************/
  191.             printf("\nDa li zelite da ponovite program? (y/n) ");
  192.             scanf("%c", &again);
  193.             scanf("%c", &again);
  194.             while (again!='y' && again !='n') {
  195.                 printf("Pogresan unos! Da li zelite da ponovite program? (y/n) ");
  196.                 scanf("%c", &again);
  197.                 scanf("%c", &again);
  198.                 }
  199.            
  200.     }
  201.     /*************************************
  202.     *
  203.     *  Kraj programa
  204.     *
  205.     *************************************/
  206.     printf("\n\n***KRAJ PROGRAMA***\n\n\n");
  207.    
  208. }
  209.  
  210. /************************************************
  211. *
  212. *  funkcija za racunanje ocene
  213. *
  214. ************************************************/
  215. int ocena (int bodovi) {
  216.     /**************************************************************
  217.     *
  218.     *      Definisanje lokalnih promenljivih
  219.     *  o je ocena na onovu broja bodova (to je vrednost koju funkcija vraca)
  220.     *
  221.     **************************************************************/
  222.     int o=0;
  223.     switch (bodovi) {
  224.         case 55: case 56: case 57: case 58: case 59: case 60: case 61: case 62:
  225.         case 63: case 64: o = 6; break;
  226.         case 65: case 66: case 67: case 68: case 69: case 70: case 71: case 72:
  227.         case 73: case 74: o = 7; break;
  228.         case 75: case 76: case 77: case 78: case 79: case 80: case 81: case 82:
  229.         case 83: case 84: o = 8; break;
  230.         case 85: case 86: case 87: case 88: case 89: case 90: case 91: case 92:
  231.         case 93: case 94: o = 9; break;
  232.         case 95: case 96: case 97: case 98: case 99: case 100: o = 10; break;
  233.         default : o = 5; break;
  234.            
  235.         }
  236.        
  237.    
  238.     return o;
  239.    
  240.     }
  241.  

posted by del-boy  # 2:10 PM 0 comments

Wednesday, December 14, 2005

 

Najekonomicnija kupovina frizidera

Ova verzija ispisuje najekonomicniji grad za kupovinu frizidera u svakom gradu, medjutim postoji i kod (koji je iskomentarisan) za razultat sam u odredjenom gradu. Ako Vam to treba, odkomentarisite taj kod i sklonite pelju koja vrti promenljivu grad kroz sve vrednosti od 0 do n-1! Detaljan text zadatka je u samom kodu u vidu komentara!
  1. /***********************************************************
  2. *
  3. *  Duz kruznog puta nalazi se N gradova. U svakom od njih postoji
  4. *  prodavnica bele tehnike. Poznata je cena zamrzivaca u svakom
  5. *  gradu i cena voznje do svakog grada sa povratkom. Za mestane
  6. *  svakog grada odrediti grad u kome ce najekonomicnije proci
  7. *  prilikom kupovine zamrzivaca i u kom smeru da putuju.
  8. *
  9. ************************************************************/
  10.  
  11.  
  12. #include <stdio.h>
  13. #define MAX_NIZ 50
  14.  
  15. main () {
  16.  
  17.     /******************************************
  18.     *
  19.     *  Definisanje enumeracije
  20.     *
  21.     ******************************************/
  22.     enum pozneg {NEG, POZ};
  23.  
  24.     /***********************************************************************
  25.     *
  26.     *      Deklaracija promenljivih
  27.     *  n je broj gradova
  28.     *  fridz je niz sa cenama frizidera u svakom gradu
  29.     *  put je niz sa cenom puta do svakog grada
  30.     *  i, j je brojac za petlju
  31.     *  grad je broj grada gde se kupac nalazi
  32.     *  eko1 i eko2 su nizovi sa ukupnim cenama frizidera sa putovanjem
  33.     *               u oba smera (eko1 je pozitivan smer, a eko2 negativan)
  34.     *  sumput je ukupna cena svih putovanja (putovanje u krug)
  35.     *  min1 i min2 su najmanji clanovi nizova eko1 i eko2
  36.     *  min je najmanja cena iz oba pravca
  37.     *  pozneg pamti najekonomicniji smer kretanja kupca
  38.     *  eko1grad i eko2grad pamte broj najekonomicnijeg grada
  39.     *  ekograd je broj najekonomicnijeg grada uopste
  40.     *  again je pomocna promenljiva za ponavljanje programa ako to korinsik zeli
  41.     *
  42.     **********************************************************************/
  43.     float fridz[MAX_NIZ], put[MAX_NIZ], eko1[MAX_NIZ], eko2[MAX_NIZ], sumput, min1, min2, min;
  44.     int n, i, j, grad, pozneg, eko1grad, eko2grad, ekograd;
  45.     char again = 'y';
  46.  
  47.     /*****************************************
  48.     *
  49.     *  Uvodna konverzacija
  50.     *
  51.     *****************************************/
  52.     printf("Program za odredjivanje najekonomicnije kupovine frizidera!");
  53.  
  54.     while (again=='y')
  55.     {
  56.             /*****************************************
  57.             *
  58.             *  Inicijalizacija niza
  59.             *
  60.             ******************************************/
  61.             for (i=0; i<MAX_NIZ; i++) fridz[i] = put[i] = eko1[i] = eko2[i] = 0;
  62.  
  63.             /****************************************
  64.             *
  65.             *  Unos broja gradova
  66.             *
  67.             ****************************************/
  68.             printf("\nUnesite broj gradova: ");
  69.             scanf("%d", &n);
  70.             while (n<=0 || n>MAX_NIZ) {
  71.                 printf("Unos je van opsega! Unesite ponovo broj gradova: ");
  72.                 scanf("%d", &n);
  73.             }
  74.  
  75.             /**************************************
  76.             *
  77.             *  Unos cena frizidera u svakom gradu
  78.             *
  79.             **************************************/
  80.             printf("\n\tUnos cena frizidera u svakom gradu\n");
  81.             for (i=0; i<n; i++) {
  82.                 printf("Unesite cenu frizidera u gradu %d: ", i+1);
  83.                 scanf("%f", &fridz[i]);
  84.                 while (fridz[i]<0) {
  85.                     printf("\n\tCena ne moze biti negativna! Unesite cenu frizidera u gradu %d: ", i+1);
  86.                     scanf("%f", &fridz[i]);
  87.                     }
  88.                 }
  89.  
  90.             /***************************************
  91.             *
  92.             *  Unos cena puta izmedju svakog grada i racunanje
  93.             *  ukupne cene ako bi se obisao krug kroz sve gradove
  94.             *
  95.             ***************************************/
  96.             sumput = 0;   /*postavljanje sume cena svih puteva na nulu*/
  97.             printf("\n\tUnos cena puta izmedju svaka dva grada!\n");
  98.             for (i=0; i<n; i++) {
  99.                 if (i==(n-1)) {
  100.                     printf("Unesite cenu puta izmedju gradova %d i 1 : ", i+1);
  101.                     scanf("%f", &put[i]);
  102.                     while (put[i]<0) {
  103.                         printf("\n\tCena ne moze biti negativna. Unesite cenu puta izmedju gradova %d i 1 : ", i+1);
  104.                         scanf("%f", &put[i]);
  105.                     }
  106.  
  107.                 }
  108.                 else {
  109.                     printf("Unesite cenu puta izmedju gradova %d i %d : ", i+1, i+2);
  110.                     scanf("%f", &put[i]);
  111.                     while (put[i]<0) {
  112.                         printf("\n\tCena ne moze biti negativna. Unesite cenu puta izmedju gradova %d i %d : ", i+1, i+2);
  113.                         scanf("%f", &put[i]);
  114.                     }
  115.                 }
  116.                 sumput += put[i];
  117.             }
  118.  
  119.             /*****************************************
  120.             *
  121.             *  Unos grada gde se kupac nalazi
  122.             *
  123.             *****************************************/
  124.             /*printf("\n\tU kom gradu se kupac nalazi? ");
  125.             scanf("%d", &grad);
  126.             while (grad<=0 || grad>n) {
  127.                 printf("Unesti grad je izvan opsega! U kom gradu se kupac nalazi? ");
  128.                 scanf("%d", &grad);
  129.                 }
  130.                 grad--;
  131.             */
  132.            
  133.            
  134.             /**********************************************************************
  135.             *
  136.             *  Petlja koja prolazi kroz sve gradove i ispisuje rezultate za njih
  137.             *
  138.             **********************************************************************/
  139.             for (grad=0; grad<n; grad ++) {
  140.                
  141.                 /*****************************************
  142.                 *
  143.                 *  Inicijalizacija nizova i promenljivih
  144.                 *
  145.                 ******************************************/
  146.                 for (i=0; i<n; i++) eko1[i] = eko2[i] = 0;
  147.                
  148.                
  149.                 /*****************************************
  150.                 *
  151.                 *  Kreiranje niza cena u svim gradovima zajedno sa
  152.                 *  putovanjem do tih gradova u pozitivnom smeru
  153.                 *  (suprotan kretanju kazaljke na satu)
  154.                 *
  155.                 *****************************************/
  156.                 for (i=0; i<n; i++) {
  157.                     /*************************************
  158.                     *
  159.                     *  U gradu gde se kupac nalazi troskovi su jednaki
  160.                     *  ceni frizidera u tom gradu
  161.                     *
  162.                     **************************************/
  163.                     if (i==grad) {
  164.                         eko1[i] = fridz[i];
  165.                     }
  166.                     else {
  167.                    
  168.                         /**********************************************************************
  169.                         *
  170.                         *  Ako do nekog grada moramo stici prolazeci kroz kraj kruga (put od poslednjeg do
  171.                         *  prvog grada) onda od ukupne cene putovanja kroz ceo krug oduzimamo cenu puta
  172.                         *  koji kupac ne mora da predje da bi stigao do odredjenog grada i dodajemo cenu
  173.                         *  frizidera u tom gradu
  174.                         *
  175.                         ***********************************************************************/
  176.                         if (i<grad) {
  177.                                 eko1[i] = sumput;
  178.                                 for (j=i; j<grad; j++) eko1[i] -= put[j];
  179.                                 eko1[i] += fridz[i];
  180.                                 }
  181.                         /***********************************************************************
  182.                         *
  183.                         *  Ako se do grada moze stici u pozitivnom smeru bez prolaska kroz kraj kruga (put
  184.                         *  od poslednjeg do prvog grada) onda saberemo cenu svakog puta koji kupac treba
  185.                         *  da prodje da bi stigao do odredjenog grada i dodamo cenu frizidera u tom gradu
  186.                         *
  187.                         ************************************************************************/
  188.                         if (i>grad) {
  189.                             for (j=grad; j<i; j++) eko1[i] += put[j];  ;
  190.                             eko1[i] += fridz[i];
  191.                        
  192.                             }
  193.                         }
  194.                 }
  195.                
  196.                 /*****************************************
  197.                 *
  198.                 *  Kreiranje niza cena u svim gradovima zajedno sa
  199.                 *  putovanjem do tih gradova u negativnom smeru
  200.                 *  (smer kretanja kazaljke na satu)
  201.                 *
  202.                 *****************************************/
  203.                 for (i=0; i<n; i++) {
  204.                     /*************************************
  205.                     *
  206.                     *  U gradu gde se kupac nalazi troskovi su jednaki
  207.                     *  ceni frizidera u tom gradu
  208.                     *
  209.                     **************************************/
  210.                     if (i==grad) {
  211.                         eko2[i] = fridz[i];   
  212.                         }
  213.                         else {
  214.                             /**********************************************************************
  215.                             *
  216.                             *  Ako do nekog grada moramo stici prolazeci kroz kraj kruga (put od poslednjeg do
  217.                             *  prvog grada) onda od ukupne cene putovanja kroz ceo krug oduzimamo cenu puta
  218.                             *  koji kupac ne mora da predje da bi stigao do odredjenog grada i dodajemo cenu
  219.                             *  frizidera u tom gradu
  220.                             *
  221.                             ***********************************************************************/
  222.                             if (i>grad) {
  223.                                 eko2[i] = sumput;
  224.                                 for (j=grad; j<i; j++) eko2[i] -= put[j];
  225.                                 eko2[i] += fridz[i];           
  226.                         }
  227.                         else
  228.                             /***********************************************************************
  229.                             *
  230.                             *  Ako se do grada moze stici u pozitivnom smeru bez prolaska kroz kraj kruga (put
  231.                             *  od poslednjeg do prvog grada) onda saberemo cenu svakog puta koji kupac treba
  232.                             *  da prodje da bi stigao do odredjenog grada i dodamo cenu frizidera u tom gradu
  233.                             *
  234.                             ************************************************************************/
  235.                             if (i<grad) {
  236.                                 for (j=i; j<grad; j++) eko2[i] += put[j];
  237.                                 eko2[i] += fridz[i];               
  238.                             }
  239.                     }
  240.                 }      
  241.                
  242.                
  243.                 /*******************************************
  244.                 *
  245.                 *  Trazenje najmanjeg clana nizova eko1 i eko2
  246.                 *  i broja najekonomicnijeg grada
  247.                 *
  248.                 ******************************************/
  249.                 for (eko1grad = 0, eko2grad = 0, min1 = eko1[0], min2 = eko2[0], i=1; i<n; i++) {
  250.                     if (eko1[i]<min1) {
  251.                         min1 = eko1[i];
  252.                         eko1grad = i;
  253.                         }
  254.                     if (eko2[i]<min2) {
  255.                         min2 = eko2[i];
  256.                         eko2grad = i;
  257.                         }
  258.                 }   
  259.                
  260.                 /*******************************************
  261.                 *
  262.                 *  Odredjivanje najmanje cene kod oba smera i broja
  263.                 *  grada koji je najekonomicniji i odredjivanje pravca
  264.                 *  u kom kupac treba da se krece
  265.                 *
  266.                 *******************************************/
  267.                 if (min1<min2) {
  268.                     min = min1;
  269.                     ekograd = eko1grad;
  270.                     pozneg = POZ;      
  271.                     }
  272.                     else {
  273.                         min = min2;
  274.                         ekograd = eko2grad;
  275.                         pozneg = NEG;      
  276.                     }
  277.    
  278.                
  279.                 /*****************************************
  280.                 *
  281.                 *  Ispis rezultata na ekranu
  282.                 *
  283.                 *****************************************/
  284.                 printf("\n\nIspis za grad %d!\n", grad+1);
  285.                 if (grad==ekograd) printf("\n\n\tNajekonomicnije je da kupac kupi frizider u svom gradu!\n");
  286.                 else {
  287.                     printf("\n\tNajekonomicnije grad za kupovinu frizidera je %d, i treba da idete u smeru ", ekograd+1);
  288.                     if (pozneg==NEG) printf("suprotnom od ");   
  289.                     printf("kretanja kazaljke na satu! Cena je %.2f", min);
  290.                 }
  291.            
  292.                
  293.             }
  294.             /************************************************
  295.             *
  296.             *  Provera da li korinik zeli da ponovi program
  297.             *
  298.             ************************************************/
  299.             printf("\nDa li zelite da ponovite program? (y/n) ");
  300.             scanf("%c", &again);
  301.             scanf("%c", &again);
  302.             while (again!='y' && again !='n') {
  303.                 printf("Pogresan unos! Da li zelite da ponovite program? (y/n) ");
  304.                 scanf("%c", &again);
  305.                 scanf("%c", &again);
  306.                 }
  307.                
  308.     }
  309.        
  310.    
  311.     /********************************
  312.     *
  313.     *  KRAJ PROGRAMA
  314.     *
  315.     ********************************/
  316.     printf("\n\n\t***KRAJ PROGRAMA***\n\n");
  317.     return 0;
  318.  
  319. }
  320.  

posted by del-boy  # 3:52 PM 0 comments

Archives

November 2005   December 2005   January 2006  

This page is powered by Blogger. Isn't yours?