C programs

Thursday, January 12, 2006

Spregnute liste

/************************************************************************************
*
* Napisati C program koji demonstrira realizaciju osnovnih operacija sa dinamickom strukturom podataka
* oblika jednostruko spregnute liste. Element liste se sastoji od dva polja: podatak koji predstavlja ceo broj
* i pokazivac na sledeci element liste.
* Operacije koje treba realizovati sa jednostruko spregnutom listom su:
* - unos novog broja, po izboru korisnika (na pocetak ili kraj liste) (NAPOMENA: Zadovoljiti uslov da se u listi
* ne moze nalaziti vise od 5 istih brojeva)
* - modifikacija (umesto jednog broja treba upisati drugi broj)
* - trazenje broja u listi
* - brisanje broja iz liste (ako ima vise istih, izbrisati ih sve)
* DODATNO: Napraviti tabelarni prikaz pojavljivanja brojeva u listi
*
*************************************************************************************/
#include <stdio.h>
#define MAX 5
/**************************************************
*
* struktura podataka za listu
* broj sadrzi podatak
* sledeci je pokazivac na sledeci elenetan liste
*
**************************************************/
typedef struct cvor {
int broj;
struct cvor *sledeci;
} Tcvor;
/*************************
*
* Pokazivac na cvor
*
**************************/
typedef Tcvor *Pcvor;
/**************************************************
*
* Prototipovi funkcija (detalji su u samim funkcijama)
*
**************************************************/
void ini (Pcvor *);
void unosKr (Pcvor *);
void unosPoc (Pcvor *);
void unosPrvi (Pcvor *);
void ispis (Pcvor);
void mod (Pcvor);
void trazi (Pcvor);
void brisi (Pcvor *);
void osobodiMem (Pcvor *);
int opcije(void);
int prebroj(Pcvor, int);
void brPon(Pcvor);
/*char getch();*/
main () {
/********************************************************************************
*
* Definicija promenljivih
* glava je pokazivac na prvi element liste (kad je lista prazna glava pokazuje na NULL
* izbor je promenljiva koja sluzi za biranje opcija iz menija
*
********************************************************************************/
Pcvor glava;
int izbor;
/**********************************************************
*
* Uvodna konverzacija
*
**********************************************************/
printf("\nProgram za prezentaciju osnovnih operacija jednostruko spregnute liste!\n\n");
/***************************************
*
* Inicijalizacija liste
*
***************************************/
ini (&glava);
/*******************************************************************
*
* Prikazivanje menija na ekranu i izvrsavanje operacija koje korisnik zahteva
* sve dok korisnik ne izabere kraj
*
********************************************************************/
do {
izbor = opcije();
switch (izbor) {
case 1: unosPoc(&glava);
break;
case 2: unosKr(&glava);
break;
case 3: mod(glava);
break;
case 4: trazi(glava);
break;
case 5: brisi(&glava);
break;
case 6: ispis(glava);
break;
case 7: brPon(glava);
break;
case 8: ;
}
} while (izbor!=8);
/***************************************
*
* Oslobadjanje zauzete memorije
*
****************************************/
osobodiMem(&glava);
/************************************
*
* Kraj programa
*
************************************/
printf("\n\n***KRAJ PROGRAMA***\n\n\n");
return 0;
}
/******************************************************************
*
* Funkcija: ini
* Svrha: postavlja vodeci pokazivac (glava) na NULL, odnosno inicijalizuje listu
*
******************************************************************/
void ini (Pcvor *glava) {
*glava = NULL; /*postavljanje glave liste da pokazuje na NULL, odnosno na nista*/
}
/******************************************************************
*
* Funkcija: unosKr
* Svrha: unos novog clana liste i smestanje na kraj
*
******************************************************************/
void unosKr (Pcvor *glava) {
/***************************************************************************
*
* Definicija lokalnih promenljivih
* tek je tekuci element liste, a pret je prethodni (prethodni uvek kasni za 1 u odnosu na tekuci)
* novi je element koji je unosi
* k je broj koji se unosi
*
****************************************************************************/
int k;
Pcvor tek, pret, novi;
printf("\nUnos elementa na kraj liste!\n");
/*ako se utvrdi da je lista prazna poziva se funkcija za unos prvog clana*/
if (*glava==NULL) unosPrvi (glava);
/*a ako lista nije prazna clan se dodaje na kraj*/
else {
/*prolazak kroz listu i dolazak do poslednjeg unesenog elementa*/
tek = *glava;
while (tek != NULL) {
pret = tek;
tek = tek->sledeci;
}
/*********************************************************************
*
* Zauzimanje dinamicke memorije za novi clan liste, ucitavanje
* broja sa tastature, postaljanje pokazivaca na sledeci element
* na NULL i pokazivaca prethodnog elementa na upravo uneseni element
*
********************************************************************/
printf("Unesite sledeci element (smesta se na kraj): ");
scanf("%d", &k);
if (prebroj(*glava, k)<MAX) {
novi = (Tcvor *)malloc(sizeof(Tcvor));
novi->broj = k;
novi->sledeci = NULL;
pret->sledeci = novi;
}
else printf("\n\tBroj se pojavljivao maximalan broj puta! Nije dozvoljen unos ovog broja!");
}
}
/******************************************************************
*
* Funkcija: unosPoc
* Svrha: unos novog clana liste i smestanje na pocetak
*
******************************************************************/
void unosPoc(Pcvor *glava) {
/**************************************************************
*
* Definisanje lokalnih promenljivih
* novi je element koji se dodaje u listu
* k je novi broj koji se unosi
*
**************************************************************/
int k;
Pcvor novi;
printf("\nUnos elementa na pocetak liste!\n");
/*ako se utvrdi da je lista prazna poziva se funkcija za unos prvog clana*/
if (*glava==NULL) unosPrvi(glava);
/*a ako lista nije prazna, elemet se unosi na pocetak liste*/
else {
/********************************************************
*
* Zauzimanje dinamicke memorije za novi element liste, ucitavanje novog
* elementa sa tastature, postavljanje glave da pokazuje na taj novi element,
* i postavljanje pokazivaca novog elementa da pokazuje da dosadasnji
* prvi element, koji je sad drugi
*
********************************************************/
printf("Unesite sledeci elementa liste (smesta se na pocetak): ");
scanf("%d", &k);
if (prebroj(*glava, k)<MAX) {
novi = (Tcvor *)malloc(sizeof(Tcvor));
novi->broj = k;
novi->sledeci = *glava;
*glava = novi;
}
else printf("\n\tBroj se pojavljivao maximalan broj puta! Nije dozvoljen unos ovog broja!");
}
}
/********************************************************
*
* Funkcija: unosPrvi
* Svrha: Sluzi za unos elementa ukoliko je lista prazna
* nema je smisla pozivati bez prethode prove da li glava pokazuje
* na NULL
*
*********************************************************/
void unosPrvi (Pcvor *glava) {
/**************************************************************
*
* Definisanje lokalnih promenljivih
* novi je element koji se dodaje u listu
*
**************************************************************/
Pcvor novi;
/*************************************************************
*
* Zauzimanje dinamicke memorije za prvi element u listi, unos sa tastature,
* postavljanje njegovog pokazivaca na NULL i postavljanje glave da pokazuje
* ne njega
*
*************************************************************/
novi = (Tcvor *)malloc(sizeof(Tcvor));
printf("Unesite prvi element liste: ");
scanf("%d", &novi->broj);
novi->sledeci = NULL;
*glava = novi;
}
/*********************************************************
*
* Funckija: ispis
* Svrha: ispisivanje na ekranu svih clanova liste
*
*********************************************************/
void ispis (Pcvor glava) {
/***************************************************************************
*
* Definicija lokalnih promenljivih
* tek je tekuci element liste, a pret je prethodni (prethodni uvek kasni za 1 u odnosu na tekuci)
*
****************************************************************************/
Pcvor tek, pret;
/*lista je prazna ako glava pokazuje na NULL*/
if (glava==NULL) printf("\nLista je prazna\n");
/*a ako nije prazna ispisujemo listu*/
else {
/*************************************************************
*
* tek se krece kroz listu dok ne naidje na pokazivac sa vrednoscu NULL, a
* pret ga prati i ispisuje se broj na koji pokazuje prethodni.
* Ispis se zavrsava kad tek dodje do poslednjeg elementa. Tada pret pokazuje
* na poslednji element, a tek ima vrednost pokazivaca poslednjeg elementa,
* odnosno NULL.
*
*************************************************************/
printf("\nIspis liste:\n\n");
tek = glava;
while (tek !=NULL) {
pret = tek;
printf("\t%d", pret->broj);
tek = tek->sledeci;
}
}
printf("\n");
}
/******************************************************************
*
* Funkcija: mod
* Svrha: menja zadati broj za drugim zadatim brojem na svakom mestu gde se pojavljuje
*
******************************************************************/
void mod (Pcvor glava) {
/*************************************************************
*
* Definicjia lokalnih promenljivih
* k je broj koji se modifikuje
* n je broj koji zamenjuje k
* tek je tekuci element liste, a pret je prethodni (prethodni uvek kasni za 1 u odnosu na tekuci)
* br je broj modifikovanih elemenata
*
*************************************************************/
int k, n, br=0;
Pcvor tek, pret;
printf("\nModifikacija broja iz liste!\n\n");
/*ako glava pokazuje na NULL lista je prazna, pa nema sta da se modifikuje*/
if (glava==NULL) {
printf("\n\tLista je prazna. Nema elemenata za modifikovanje!\n");
}
/*a ako nije prazna, unosi se broj koji treba modifikovati, i broj u koji se modifikuje taj broj*/
else {
printf("\tUnesite broj koji hocete da promenite\n\t (promenice se na svim lokacijama gde se pojavljuje): ");
scanf("%d", &k);
printf("\tUnesite broj sa kojim hocete da zamenite broj %d : ", k);
scanf("%d", &n);
if ((prebroj(glava, k) + prebroj(glava, n))<=MAX) {
/*************************************************************
*
* tek prolazi kroz celu listu dok ne naidje na element sa pokazivacom NULL
* (poslednji element), a pret ga prati i proverava da li je element jednak
* broj koji treba modifikovati, i ako jeste menja mu vrednost.
* Petlja se prekida kad tek dobije vrednost NULL. Tada pret pokazuje na posednji
* element, a tek ima vrednost pokazivaca poslednjeg elementa, odnosno NULL.
*
*************************************************************/
tek = glava;
while (tek != NULL) {
pret = tek;
if (pret->broj==k) {
pret->broj = n;
br++;
}
tek = tek->sledeci;
}
if (br==0) printf("\n\tNi jedan element nije modifikovan!\n");
else printf("Broj elemenata koji su modifikovani je: %d!\n", br);
}
else printf("\n\n\tUkoliko se izvrsi modifikacija, broj %d ce se\n\tpojavljivati u listi vise puta nego sto je to dozvoljeno!\n", n);
}
}
/*******************************************************
*
* Funkcija: trazi
* Svrha: proverava da li se odredjeni broj nalazi u listi
*
*******************************************************/
void trazi (Pcvor glava) {
/********************************************************************************
*
* Definisanje lokalnih promenljivih i enumeracije
* k je broj koji se trazi
* n pamti da li je broj pronadjen broj u listi
* tek je tekuci element liste, a pret je prethodni (prethodni uvek kasni za 1 u odnosu na tekuci)
* br je broj pojavljivanja trazenog elementa u listi
*
********************************************************************************/
int k, br=0;
Pcvor tek, pret;
printf("\nPretraga liste!\n\n");
/*ako glava pokazuje na NULL lista je prazna i nema sta da se pretrazuje*/
if (glava==NULL) {
printf("\n\tLista je prazna. Nema elemenata za pretragu!\n");
}
/*a ako nije prazna unosi se broj koji se trazi*/
else {
printf("\tKoji broj zelite da nadjete u listi? ");
scanf("%d", &k);
tek = glava;
/**********************************************************
*
* tek i pret prolaze kroz listu (pret kasni za tek) i proverava se za svaki
* element liste da li je jedank trazenom broju. Ako jeste brojac se uvecava
* za jedan.
*
**********************************************************/
while (tek != NULL) {
pret = tek;
if (pret->broj==k) {
br++;
}
tek = tek->sledeci;
}
/***********************************************************
*
* Ako je brojac jedank nuli, ne postoji u listi element koji se trazi, a ako nije
* ispisuje se koliko puta se taj element pojavljuje
*
***********************************************************/
if (br==0) printf("\n\tTrazeni broj ne postoji u listi!\n");
else printf("\n\tBroj puta koliko se broj %d pojavljuje u listi je: %d!\n", k, br);
}
}
/**********************************************************
*
* Funkcija: brisi
* Svrha: brise broj koji je korisnik zadao iz liste gde god se pojavi
*
**********************************************************/
void brisi (Pcvor *glava) {
/*****************************************************************
*
* Definisanje lokalnih promenljivih
* enumeracija sluzi za lakse pamcenje da li jos ima elementa u listi koje treba brisati
* k je broj koji treba obrisati
* n pamti da li ima jos elemenata koje treba brisati
* br je broj obrisanih
* tek i pret su pokazivaci na cvorove koji prolaze kroz listu
*
******************************************************************/
enum {NEMA, IMA};
int k, n=IMA, br=0;
Pcvor tek, pret;
printf("\nBrisanje elementa iz liste!\n\n");
/*ako je lista prazna, nema sta da se brise*/
if (*glava==NULL) {
printf("\n\tLista je prazna. Nema elemenata za brisanje!\n");
}
/*a ako nije, unosi se broj koji treba obrisati*/
else {
printf("\n\tKoji broj zelite da obrisete (bice obrisan sa svih lokacija)? ");
scanf("%d", &k);
/*ova petlja se ponavlja dok ima elemenata za brisanje*/
while (n==IMA) {
/*trazi element koji odgovara uslovima za brisanje*/
tek = *glava;
pret = *glava;
while ((tek!=NULL) && (tek->broj !=k)) {
pret = tek;
tek = tek->sledeci;
}
/*ako tek pokazuje na NULL znaci da je pretraga dosla do kraja i da nije
pronadjen ni jedan element za brisanje, pa se n postavlja na vresnost nema*/
if (tek==NULL) {
n = NEMA;
}
/*u suprotnom ako je element za brisanje prvi element liste, glava se postavlja da pokazuje na drugi
element, a pokazivacu prvog se dodeljuje vrenost NULL*/
else {
if (tek==*glava) {
*glava = tek->sledeci;
tek->sledeci = NULL;
}
/*ako nije brvi element u pitanju, pokazivacu njegovog prethodnika se daje vrednost njegovog pokazivaca
(njegov sledbenik), a njegov pokazivac se postavlja na NULL*/
else {
pret->sledeci = tek->sledeci;
tek->sledeci = NULL;
}
/*i na kraju i fizicki oslobadjamo memoriju koju je zauzimao taj element*/
free(tek);
/*povecavamo broj obrisanih za jedan*/
br++;
}
}
if (br==0) printf("\n\tNi jedan element nije obrisan\n");
else printf("\n\tBroj lokacija sa kojih je broj %d izbrisan je: %d!\n", k, br);
}
}
/*********************************************************
*
* Funkcija osobodiMem
* Svrha: brise celu listu iz dinamicke memorije
*
*********************************************************/
void osobodiMem (Pcvor *glava) {
/**************************************************
*
* Definisanje lokalnih promenljivih
* tek je cvor koji se trenutno brise (prvi clan liste)
*
***************************************************/
Pcvor tek;
/****************************************************************
*
* Oslobadjanje memorije se vrsi tako sto se brise prvi element iz liste, drugi se
* postavlja da bude prvi i to se ponavlja dok svi elementi ne budu izbrisani.
* Posto glava uzima vrednost pokazivaca prvog elementa, imace vrednost NULL kada
* se poslednji element obrise. Samim tim i znamo da je lista prazna, jer glava ima
* vrednost NULL.
*
*****************************************************************/
while (*glava!=NULL) {
tek = *glava;
*glava = tek->sledeci;
free(*glava);
}
}
/**********************************************************
*
* Funkcija: opcije
* Svrha: prikazijavnje osnovnog menije za izbor
*
**********************************************************/
int opcije () {
/***********************************************************************************
*
* Definicija lokalnih promenljivih
* izbor je promenljiva koji pamti sta je izabrano iz menija i to je vrednost koju f-ja vraca
*
************************************************************************************/
int izbor=0;
/*ispisivanje menija i ucitavanje vredosti koju je korisnik uneo sa tastature*/
printf("\n\t1) Dodaj na pocetak\n\t2) Dodaj na kraj\n\t3) Modifikuj\n\t4) Pretrazi\n\t5) Obrisi\n\t6) Ispisi\n\t7) Tabelarni prikaz\n\t8) Kraj\n");
printf("\n\tIzaberite opciju: ");
scanf("%d", &izbor);
while ((izbor>8) || (izbor<1)) {
printf("\t\tNe postoji ta opcija!");
printf("\n\t1) Dodaj na pocetak\n\t;2) Dodaj na kraj\n\t3) Modifikuj\n\t4) Pretrazi\n\t5) Obrisi\n\t6) Ispisi\n\t7) Tabelarni prikaz\n\t8) Kraj\n");
printf("\n\tIzaberite opciju: ");
scanf("%d", &izbor);
}
/*vracanje ucitane vrednosti*/
return izbor;
}
/*********************************************************************
*
* Funkcija: prebroj
* Svrha: broji koliko puta se u listi pojavljuje neki clan
*
*********************************************************************/
int prebroj (Pcvor glava, int broj) {
/*******************************************************
*
* Definisanje lokalnih promenljivih
* br pamti broj ponavljanja nekog broja u listi
* tek i pret sluze za prolazak kroz listu
*
*******************************************************/
int br=0;
Pcvor tek, pret;
tek = glava;
while (tek!=NULL) {
pret = tek;
if (pret->broj==broj) br++;
tek = tek->sledeci;
}
return br;
}
/********************************************************************
*
* Funkcija: brPov
* Svrha: prikazuje tabelarni prikaz koliko se puta koji broj pojavljivao u listi
*
********************************************************************/
void brPon(Pcvor glava) {
/*int k;
Pcvor tek, pret;
printf("\n\tTablearni prikaz broja pojavljivanja elemenata u listi!\n");
tek = glava;
while (tek!=NULL) {
pret = tek;
k = prebroj(glava, pret->broj);
printf("%d se pojavljivao %d", pret->broj, k);
if (k==1) printf(" put!\n\n");
else printf(" puta!\n\n");
tek = tek->sledeci;
}
*/
/*****************************************************************
*
* Alternativna f-ja koja bi trebalo da bude bolja, ali ima neke bugove i ne radi kako treba
*
*****************************************************************/
enum {NEMA, IMA};
Pcvor tek, pret;
Pcvor novaG, noviTek, noviPret, novi;
short k;
printf("\n\tTablearni prikaz broja pojavljivanja elemenata u listi!\n\n");
if (glava==NULL) {
printf("\n\n\tLista je prazna. Ne postoji statistika koju treba ispisati!\n\n");
}
else {
ini (&novaG);
tek = glava;
while (tek!=NULL) {
pret = tek;
k = NEMA;
noviTek = novaG;
while (noviTek!=NULL) {
noviPret = noviTek;
if (noviPret->broj == pret->broj) k = IMA;
noviTek = noviTek->sledeci;
}
if (k==NEMA) {
printf("\n\tBroj pojavljivanja broja %d u listi je %d!\n\n", pret->broj, prebroj(glava, pret->broj));
if (novaG==NULL) {
novaG = (Tcvor *)malloc(sizeof(Tcvor));
novaG->broj = pret->broj;
novaG->sledeci = NULL;
}
else {
novi = (Tcvor *)malloc(sizeof(Tcvor));
novi->broj = pret->broj;
novi->sledeci = novaG;
novaG = novi;
}
}
tek = tek->sledeci;
}
osobodiMem(&novaG);
}
}
/*char getch() {
char c,e;
c = getchar();
e = getchar();
return c;
}*/

posted by del-boy # 4:57 PM 0 comments

Wednesday, December 21, 2005

Ocena studenta na osnovu tri kolokvijuma

/**********************************************************************
* Napisati C program koji za svakog studenta ucitava broj indexa i osvojene bodove za
* tri zadatka A B i C, a zatim izracunava ukupan broj osvojenih bodova i na osnovu tog
* pozivom funkcije odredjuje zakljcnu ocenu.
*
* Obezbediti da se rezultati stampaju u po opadajucoj vrednosti broja bodova u obliku:
*
* 1. 11541 21 54 32 8
* 2. 11335 62 32 48 10
*
* maximalan broj bodova po zadacima je 30, 30 i 40. Ocena se formiara po pravilu:
* 0-54 - 5
* 55-64 - 6
* 65-74 - 7
* 75-84 - 8
* 85-94 - 9
* 95-100 - 10
**********************************************************************/
#include <stdio.h>
#define MAX_NIZ 1000
/******************************************
*
* Prototip funkcije
*
******************************************/
int ocena (int);
main () {
/*******************************************************************
*
* Inicijalizacija promenljivih
* stud je matrica u kojo se cuvaju brojevi indexa i bodovi svakog studenta
* i, j, k su brojaci za petlje
* n je broj studenata
* pom sluzi za menjanje vrednosti prilikom sortiranja
* again je promenljiva za ponavaljanje programa ako korisnik to zeli
*
*******************************************************************/
int stud[MAX_NIZ][6], i, j, n, pom, k;
char again='y';
while (again=='y') {
/******************************
*
* Inicijalizacija matrice
*
*****************************/
for (i=0; i<MAX_NIZ; i++) for (j=0; j<4; stud[i][j++] = 0) ;
/*****************************
*
* Uvodna konverzavija
*
******************************/
printf("Program za racunanje ocene studenata na osnovu bodova iz 3 testa\n");
/****************************
*
* Unos broja studenata
*
****************************/
printf("\n\tZa koliko studenta zelite da racunate ocenu? ");
scanf("%d", &n);
while (n<=0 || n>MAX_NIZ) {
printf("Broj je van opsega! Za koliko studenata zelite da racunate ocenu? ");
scanf("%d", &n);
}
/***************************
*
* Unos matrice sa podacima
*
***************************/
/***************************
*
* 0 - broj indexa
* 1 - broj bodova iz testa A
* 2 - broj bodova iz testa B
* 3 - broj bodova iz testa C
* 4 - ukupan broj bodova
* 5 - ocena
*
***************************/
for (i=0; i<n; i++) {
/**********************************************
*
* Unsos brojeva indexa
*
**********************************************/
printf("\tUnesite broj indexa studenta za %d. studenta : ", i+1);
scanf("%d", &stud[i][0]);
/*********************************************
*
* Unos bodova iz prvog testa
*
**********************************************/
printf("\tUnesite broj bodova iz testa A za %d. studenta : ", i+1);
scanf("%d", &stud[i][1]);
while (stud[i][1]<0 || stud[i][1]>30) {
printf("\t\tBroj bodova je izvan osega\n\tUnesite broj bodova iz testa A za %d. studenta : ", i+1);
scanf("%d", &stud[i][1]);
}
/**********************************************
*
* Unos bodova iz drugog testa
*
**********************************************/
printf("\tUnesite broj bodova iz testa B za %d. studenta : ", i+1);
scanf("%d", &stud[i][2]);
while (stud[i][2]<0 || stud[i][2]>30) {
printf("\t\tBroj bodova je izvan osega\n\tUnesite broj bodova iz testa B za %d. studenta : ", i+1);
scanf("%d", &stud[i][2]);
}
/**********************************************
*
* Unos bodova iz treceg testa
*
**********************************************/
printf("\tUnesite broj bodova iz testa C za %d. studenta : ", i+1);
scanf("%d", &stud[i][3]);
while (stud[i][3]<0 || stud[i][3]>40) {
printf("\t\tBroj bodova je izvan osega\n\tUnesite broj bodova iz testa C za %d. studenta : ", i+1);
scanf("%d", &stud[i][3]);
}
printf("\n\n");
/***************************************
*
* Racunanje ukupnog broja bodova
*
***************************************/
stud[i][4] = stud[i][1] + stud[i][2] + stud[i][3];
/**************************************
*
* Racunanje ocene pomocu funkcije ocena
*
***************************************/
stud[i][5] = ocena(stud[i][4]);
}
/**************************************
*
* Sortiranje matrice na osnovu broja bodova
*
**************************************/
for (i=0; i<n-1; i++) {
for (j=i; j<n; j++) {
if (stud[j][4]>stud[i][4]) {
for (k=0; k<6; k++) {
pom = stud[i][k];
stud[i][k] = stud[j][k];
stud[j][k] = pom;
}
}
}
}
/************************************
*
* Ispis rezultata
*
************************************/
printf("\n\tBodovna lista: \n");
printf(" Red.br Br. indexa Test A Test B Test C Ukupno Ocena\n");
for (i=0; i<n; i++) {
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]);
}
/************************************************
*
* Provera da li korinik zeli da ponovi program
*
************************************************/
printf("\nDa li zelite da ponovite program? (y/n) ");
scanf("%c", &again);
scanf("%c", &again);
while (again!='y' && again !='n') {
printf("Pogresan unos! Da li zelite da ponovite program? (y/n) ");
scanf("%c", &again);
scanf("%c", &again);
}
}
/*************************************
*
* Kraj programa
*
*************************************/
printf("\n\n***KRAJ PROGRAMA***\n\n\n");
}
/************************************************
*
* funkcija za racunanje ocene
*
************************************************/
int ocena (int bodovi) {
/**************************************************************
*
* Definisanje lokalnih promenljivih
* o je ocena na onovu broja bodova (to je vrednost koju funkcija vraca)
*
**************************************************************/
int o=0;
switch (bodovi) {
case 55: case 56: case 57: case 58: case 59: case 60: case 61: case 62:
case 63: case 64: o = 6; break;
case 65: case 66: case 67: case 68: case 69: case 70: case 71: case 72:
case 73: case 74: o = 7; break;
case 75: case 76: case 77: case 78: case 79: case 80: case 81: case 82:
case 83: case 84: o = 8; break;
case 85: case 86: case 87: case 88: case 89: case 90: case 91: case 92:
case 93: case 94: o = 9; break;
case 95: case 96: case 97: case 98: case 99: case 100: o = 10; break;
default : o = 5; break;
}
return o;
}

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!

/***********************************************************
*
* Duz kruznog puta nalazi se N gradova. U svakom od njih postoji
* prodavnica bele tehnike. Poznata je cena zamrzivaca u svakom
* gradu i cena voznje do svakog grada sa povratkom. Za mestane
* svakog grada odrediti grad u kome ce najekonomicnije proci
* prilikom kupovine zamrzivaca i u kom smeru da putuju.
*
************************************************************/
#include <stdio.h>
#define MAX_NIZ 50
main () {
/******************************************
*
* Definisanje enumeracije
*
******************************************/
enum pozneg {NEG, POZ};
/***********************************************************************
*
* Deklaracija promenljivih
* n je broj gradova
* fridz je niz sa cenama frizidera u svakom gradu
* put je niz sa cenom puta do svakog grada
* i, j je brojac za petlju
* grad je broj grada gde se kupac nalazi
* eko1 i eko2 su nizovi sa ukupnim cenama frizidera sa putovanjem
* u oba smera (eko1 je pozitivan smer, a eko2 negativan)
* sumput je ukupna cena svih putovanja (putovanje u krug)
* min1 i min2 su najmanji clanovi nizova eko1 i eko2
* min je najmanja cena iz oba pravca
* pozneg pamti najekonomicniji smer kretanja kupca
* eko1grad i eko2grad pamte broj najekonomicnijeg grada
* ekograd je broj najekonomicnijeg grada uopste
* again je pomocna promenljiva za ponavljanje programa ako to korinsik zeli
*
**********************************************************************/
float fridz[MAX_NIZ], put[MAX_NIZ], eko1[MAX_NIZ], eko2[MAX_NIZ], sumput, min1, min2, min;
int n, i, j, grad, pozneg, eko1grad, eko2grad, ekograd;
char again = 'y';
/*****************************************
*
* Uvodna konverzacija
*
*****************************************/
printf("Program za odredjivanje najekonomicnije kupovine frizidera!");
while (again=='y')
{
/*****************************************
*
* Inicijalizacija niza
*
******************************************/
for (i=0; i<MAX_NIZ; i++) fridz[i] = put[i] = eko1[i] = eko2[i] = 0;
/****************************************
*
* Unos broja gradova
*
****************************************/
printf("\nUnesite broj gradova: ");
scanf("%d", &n);
while (n<=0 || n>MAX_NIZ) {
printf("Unos je van opsega! Unesite ponovo broj gradova: ");
scanf("%d", &n);
}
/**************************************
*
* Unos cena frizidera u svakom gradu
*
**************************************/
printf("\n\tUnos cena frizidera u svakom gradu\n");
for (i=0; i<n; i++) {
printf("Unesite cenu frizidera u gradu %d: ", i+1);
scanf("%f", &fridz[i]);
while (fridz[i]<0) {
printf("\n\tCena ne moze biti negativna! Unesite cenu frizidera u gradu %d: ", i+1);
scanf("%f", &fridz[i]);
}
}
/***************************************
*
* Unos cena puta izmedju svakog grada i racunanje
* ukupne cene ako bi se obisao krug kroz sve gradove
*
***************************************/
sumput = 0; /*postavljanje sume cena svih puteva na nulu*/
printf("\n\tUnos cena puta izmedju svaka dva grada!\n");
for (i=0; i<n; i++) {
if (i==(n-1)) {
printf("Unesite cenu puta izmedju gradova %d i 1 : ", i+1);
scanf("%f", &put[i]);
while (put[i]<0) {
printf("\n\tCena ne moze biti negativna. Unesite cenu puta izmedju gradova %d i 1 : ", i+1);
scanf("%f", &put[i]);
}
}
else {
printf("Unesite cenu puta izmedju gradova %d i %d : ", i+1, i+2);
scanf("%f", &put[i]);
while (put[i]<0) {
printf("\n\tCena ne moze biti negativna. Unesite cenu puta izmedju gradova %d i %d : ", i+1, i+2);
scanf("%f", &put[i]);
}
}
sumput += put[i];
}
/*****************************************
*
* Unos grada gde se kupac nalazi
*
*****************************************/
/*printf("\n\tU kom gradu se kupac nalazi? ");
scanf("%d", &grad);
while (grad<=0 || grad>n) {
printf("Unesti grad je izvan opsega! U kom gradu se kupac nalazi? ");
scanf("%d", &grad);
}
grad--;
*/
/**********************************************************************
*
* Petlja koja prolazi kroz sve gradove i ispisuje rezultate za njih
*
**********************************************************************/
for (grad=0; grad<n; grad ++) {
/*****************************************
*
* Inicijalizacija nizova i promenljivih
*
******************************************/
for (i=0; i<n; i++) eko1[i] = eko2[i] = 0;
/*****************************************
*
* Kreiranje niza cena u svim gradovima zajedno sa
* putovanjem do tih gradova u pozitivnom smeru
* (suprotan kretanju kazaljke na satu)
*
*****************************************/
for (i=0; i<n; i++) {
/*************************************
*
* U gradu gde se kupac nalazi troskovi su jednaki
* ceni frizidera u tom gradu
*
**************************************/
if (i==grad) {
eko1[i] = fridz[i];
}
else {
/**********************************************************************
*
* Ako do nekog grada moramo stici prolazeci kroz kraj kruga (put od poslednjeg do
* prvog grada) onda od ukupne cene putovanja kroz ceo krug oduzimamo cenu puta
* koji kupac ne mora da predje da bi stigao do odredjenog grada i dodajemo cenu
* frizidera u tom gradu
*
***********************************************************************/
if (i<grad) {
eko1[i] = sumput;
for (j=i; j<grad; j++) eko1[i] -= put[j];
eko1[i] += fridz[i];
}
/***********************************************************************
*
* Ako se do grada moze stici u pozitivnom smeru bez prolaska kroz kraj kruga (put
* od poslednjeg do prvog grada) onda saberemo cenu svakog puta koji kupac treba
* da prodje da bi stigao do odredjenog grada i dodamo cenu frizidera u tom gradu
*
************************************************************************/
if (i>grad) {
for (j=grad; j<i; j++) eko1[i] += put[j]; ;
eko1[i] += fridz[i];
}
}
}
/*****************************************
*
* Kreiranje niza cena u svim gradovima zajedno sa
* putovanjem do tih gradova u negativnom smeru
* (smer kretanja kazaljke na satu)
*
*****************************************/
for (i=0; i<n; i++) {
/*************************************
*
* U gradu gde se kupac nalazi troskovi su jednaki
* ceni frizidera u tom gradu
*
**************************************/
if (i==grad) {
eko2[i] = fridz[i];
}
else {
/**********************************************************************
*
* Ako do nekog grada moramo stici prolazeci kroz kraj kruga (put od poslednjeg do
* prvog grada) onda od ukupne cene putovanja kroz ceo krug oduzimamo cenu puta
* koji kupac ne mora da predje da bi stigao do odredjenog grada i dodajemo cenu
* frizidera u tom gradu
*
***********************************************************************/
if (i>grad) {
eko2[i] = sumput;
for (j=grad; j<i; j++) eko2[i] -= put[j];
eko2[i] += fridz[i];
}
else
/***********************************************************************
*
* Ako se do grada moze stici u pozitivnom smeru bez prolaska kroz kraj kruga (put
* od poslednjeg do prvog grada) onda saberemo cenu svakog puta koji kupac treba
* da prodje da bi stigao do odredjenog grada i dodamo cenu frizidera u tom gradu
*
************************************************************************/
if (i<grad) {
for (j=i; j<grad; j++) eko2[i] += put[j];
eko2[i] += fridz[i];
}
}
}
/*******************************************
*
* Trazenje najmanjeg clana nizova eko1 i eko2
* i broja najekonomicnijeg grada
*
******************************************/
for (eko1grad = 0, eko2grad = 0, min1 = eko1[0], min2 = eko2[0], i=1; i<n; i++) {
if (eko1[i]<min1) {
min1 = eko1[i];
eko1grad = i;
}
if (eko2[i]<min2) {
min2 = eko2[i];
eko2grad = i;
}
}
/*******************************************
*
* Odredjivanje najmanje cene kod oba smera i broja
* grada koji je najekonomicniji i odredjivanje pravca
* u kom kupac treba da se krece
*
*******************************************/
if (min1<min2) {
min = min1;
ekograd = eko1grad;
pozneg = POZ;
}
else {
min = min2;
ekograd = eko2grad;
pozneg = NEG;
}
/*****************************************
*
* Ispis rezultata na ekranu
*
*****************************************/
printf("\n\nIspis za grad %d!\n", grad+1);
if (grad==ekograd) printf("\n\n\tNajekonomicnije je da kupac kupi frizider u svom gradu!\n");
else {
printf("\n\tNajekonomicnije grad za kupovinu frizidera je %d, i treba da idete u smeru ", ekograd+1);
if (pozneg==NEG) printf("suprotnom od ");
printf("kretanja kazaljke na satu! Cena je %.2f", min);
}
}
/************************************************
*
* Provera da li korinik zeli da ponovi program
*
************************************************/
printf("\nDa li zelite da ponovite program? (y/n) ");
scanf("%c", &again);
scanf("%c", &again);
while (again!='y' && again !='n') {
printf("Pogresan unos! Da li zelite da ponovite program? (y/n) ");
scanf("%c", &again);
scanf("%c", &again);
}
}
/********************************
*
* KRAJ PROGRAMA
*
********************************/
printf("\n\n\t***KRAJ PROGRAMA***\n\n");
return 0;
}

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

Wednesday, December 07, 2005

Program za sortiranje niza!

Ovo je moj prvi program za sortiranje niza, pa verovatno nije najoptimizovaniji! Mada sam ga sam pisao (bez upotrebe poznatih algoritama za sortiranje, bar ih nisam tražio, ako sam slučajno potrefio neki dobro je). U stvari ovo je bio domaći, pa samo treba da radi! Videćemo šta ocena kaže! Evo programa!

/*******************************************
*
* Napisati C program za sortiranje niza
*
********************************************/
#include <stdio.h>
#define MAX_NIZ 50
int main()
{
/*****************************
*
* definisanje enumeracije
*
******************************/
enum bool {FALSE, TRUE};
/*****************************
*
* Inicijalizacija promenljivih
* i, k, j, f su brojaci za petlje
* n je broj elemenata niza
* a je niz koji se unosi
* pom se koristi za zamenu vrednosti
* again sluzi za ponavljanje programa
* za z postoji detaljno objasnjenje u programu
* stop sluzi da zaustavi sortiranje ako je niz sortiran
*
******************************/
int i, k, f, j, n, z, stop;
double a[MAX_NIZ], pom;
char again='y';
/*****************************
*
* Uvodna konverzacija
*
*****************************/
printf("\nProgram za sortiranje niza!\n");
while (again=='y')
{
/*************************
*
* Inicijalizacija niza
*
**************************/
for (i=0; i<MAX_NIZ; a[i++]=0) ;
/*************************
*
* Unos broja elemenata niza
*
*************************/
printf("Koliko imate elemenata niza? ");
scanf("%d", &n);
while ((n<=0) || (n>50))
{
printf("Pogresan unos! Koliko imate elemenata niza? ");
scanf("%d", &n);
}
/*************************
*
* Unos niza
*
*************************/
printf("\nUnos niza: \n");
for (i=0; i<n; i++)
{
printf("Unesite %d. clan niza: ", i+1);
scanf("%lf", &a[i]);
}
/***********************************
*
* Ako je niz sortiran, petlja se ni ne izvrsava
*
***********************************/
stop = TRUE;
for (f=1; f<n; f++) if (a[f-1]>a[f]) stop = FALSE;
if (stop) printf("\n\n\tUneli ste vec sortiran niz!");
else {
/************************
*
* Sortiranje niza
*
************************/
/*******************************
*
* Glavna petlja prolazi samo do polovine niza
* jer se istovremeno trazi i najveci i namanji
* u nizu i stavlja na odgovarajuce mesto
*
*******************************/
for (i=0; i<(n/2); i++)
{
/*********************************
*
* Pomocna petlja se krece unutar dva fixsna
* clana ('i' i 'n-1-i') i uporedjuje svaki clan
* iz te unutrasnjosti sa rubnim clanivuma
* i zamenjuje vrednosti, ako je potrebno.
* Tako na rubna mesta dolaze najmanji i najveci
* clanovi iz unutrasnjosti!
*
*********************************/
for (k=i+1; k<(n-i); k++)
{
/***********************************
*
* Prekida petlju ako je niz vec sortiran
*
***********************************/
stop = TRUE;
for (f=1; f<n; f++) if (a[f-1]>a[f]) stop = FALSE;
if (stop) break;
/****************************************
*
* Ispisuje trenutno stanje niza pre prolaska kroz petlju