Zbirka nalog iz programskega jezika C

Zbirka nalog iz programskega jezika C
1.
Prvi programi
1
nic // Namen: // minimum od minimuma, ki se se prevede v exe kodo programa. // Naloga // not doing anything ... 2
hello // Namen // znameniti Hello, world! // Naloga // Program naj izpise // Hello, world! 3
vizitka // Namen: // printf za enostavne semi­graficne izpise // Naloga: // Naredite program, ki izpise vizitko osebe. 4
izpis_printf // Namen: // printf(). vrnjena vrednost je dolzina izpisa. // Naloga: // s printf() izpisite poljuben niz in v naslednjem printf() // izpisite vrnjeno vrednost prvega printf(). 5
racki // Namen // raba printf za semi­graficen izpis // Naloga // Naredite program, ki narise dve gledajoci se raci. // // __ __ // ( ')> >(' ) // \( )/ // )\ /( // \­­­­' \ / `­­­­/ // \ ­­~ ) ( ~­­ / // ~^~^~^~^~^~^~^~^~^~^~^~^~^~^ // \ ­ Backslash (posevnica nazaj) je ubezni znak. // To pomeni, da ima znak za njim poseben pomen, // npr. \n (new line) nadaljuje izpis v naslednji vrstici // \t tab, \a (alert) zazvoni. // Za izpis enojnega backslash­a napisemo dva skupaj \\, izpise se eden. 6
komentar // Namen // oba nacina oznacitve komentarja // Naloga // Program naj izpise c:\ Pozdravljen, svet. 2.
Spremenljivke in aritmetika
2.1. Spremenljivke
1
kaj_naredim // Namen: // enostavni izrazi, NICLA na prvem mestu uvede OKTALNO zapisano stevilo // Naloga: // Prvemu stevilu z vrednostjo 10 pristejemo 10 // Drugemu stevilu z vrednostjo 10 pristejemo 010 // Obe stevili izpisemo. Kateri vrednosti sta v izpisu? 2
abeceda // Namen: // povezava med tipoma spremenljivk short int in char. // char so urejeni, kot to doloca ASCII tabela znakov. // Naloga: // v zanki izpisite velike crke abecede. 3
kaj_naredimA // Namen: // tipa char in int. // bitna manipulacija stevila, menjava pozicij gornjih in spodnjih 4 bitov // 8­bitne spremenljivke. // sestnajstiski in desetiski izpis // Naloga: // Vpisite znak: // vpisete npr A // Znak 'A' =0x41 je 65. ASCII znak. 4
preberi_get_char // Namen: char, c=getchar(); putchar(c) // Naloga: // Vpisite besedilo (koncajte vpis z Enter, program pa s . (piko)): // program izpise vneseno besedilo. // branje in pisanje besedila se izvaja v zanki z getchar() in putchar() 5
preberi_scanf // Namen: // printf(), scanf() // Naloga: // Vpisite ime: // janez // Vpisite starost: // 123 // G//ga Janez je star/a 123 let. 6
vnos // Namen: // printf(), scanf() za int, double, unsigned int (v hex), niz char[] // Naloga: // Vpisite celo stevilo: npr. 12 // Vpisite realno stevilo in vpisite celo stevilo v hex.: npr. 3.456 0x12 // Vpisite niz: npr. anakonda // Vpisali ste: 12, 3.456000, 12, anakonda 7
znaki // Namen: // ASCII znaki, izpis // Naloga: // izpisite ASCII znake od i=0 do i=255 s // printf("%d %c\n", i, i); 8
znaki_iz_intervala // Namen: // printf() za int, za char // Naloga: // Sestavimo program, ki bo izpisal ASCII znake stevilk z vnesenega intervala. // Vpisite spodnjo mejo: npr. 48 // Vpisite zgornjo mejo: npr. 57 // 48 = '0' // 49 = '1' // 50 = '2' // 51 = '3' // 52 = '4' // 53 = '5' // 54 = '6' // 55 = '7' // 56 = '8' // 57 = '9' 2.2. printf
9
izpis_printf_c // Namen: // printf() formatiranje za izpis tipa char // Naloga: // Najprej ugotovite obliko izpisa za program spodaj, // nato preverite svoj rezultat. 10
izpis_printf_d // Namen: // printf() formatiranje za izpis tipa int // Naloga: // Najprej ugotovite obliko izpisa za program spodaj, // nato preverite svoj rezultat. 11
izpis_printf_e // izpis_printf_e // Namen: // printf() formatiranje e za izpis tipa double // Naloga: // Najprej ugotovite obliko izpisa za program spodaj, // nato preverite svoj rezultat. 12
izpis_printf_f // Namen: // printf() formatiranje f za izpis tipa double // Naloga: // Najprej ugotovite obliko izpisa za program spodaj, // nato preverite svoj rezultat. 13
izpis_printf_g // Namen: // printf() formatiranje g za izpis realnih stevil. // Naloga: // Najprej ugotovite obliko izpisa za program spodaj, // nato preverite svoj rezultat. 14
izpis_printf_o // Namen: // printf() formatiranje o za izpis tipa int // Naloga: // Najprej ugotovite obliko izpisa za program spodaj, // nato preverite svoj rezultat. 15
izpis_printf_s // Namen: // printf() formatiranje s za izpis niza znakov (string) // Naloga: // Najprej ugotovite obliko izpisa za program spodaj, // nato preverite svoj rezultat. 16
izpis_printf_x // Namen: // printf() formatiranje x za izpis tipa int // Naloga: // Najprej ugotovite obliko izpisa za program spodaj, // nato preverite svoj rezultat. 17
kaj_izpisem // Namen: // printf() formatiranje d, c, x za izpis tipov int, char // Naloga: // Najprej ugotovite obliko izpisa za program spodaj, // nato preverite svoj rezultat. 2.3. Aritmetične operacije
18
racunske_operacije // Namen // + ­ * / % na spremenljivkah tipa int // Naloga // Napisite program, ki prebere dve celi števili ter izpiše vsoto, razliko, // produkt, kvocient in ostanek pri deljenju. // Vpisite 1. celo stevilo: npr. 5 // Vpisite 2. celo stevilo: npr. 4 // 5 + 4 = 9 // 5 ­ 4 = 1 // 5 * 4 = 20 // 5 / 4 = 1 // 5 % 4 = 1 19
temperatura // Namen: // double, printf(), scanf(), algebra with real­type variables // Naloga: // Vpisite temperaturo (v stopinjah Fahrenheita): npr 100 // 100 stopinj Fahrenheita = 37.78 stopinj Celzija. // branje v stopinjah Fahrenheita, preracun, izpis v stopinjah Celzija // na dve decimalni mesti natancno. 20
krog // Namen // variable type double, printf(), scanf(), Pi // Naloga // Vpisite polmer kroga: npr. 100 // Obseg kroga je 628.319, povrsina kroga = 31415.927. 21
deljivo7 // Namen: // operator modulo, oz. operator ostanka. // Naloga: // Vpisite naravno stevilo: npr. 8 // Stevilo 8 ni deljivo s 7. // ali // Vpisite naravno stevilo: npr. 147 // Stevilo 147 je deljivo s 7. 22
pre_post // Namen // subtleties of a unary operator ++ // Naloga // Najprej ugotovite, kaj se izpise po spodnjih vrsticah in nato // vase ugotovitve preverite z izvedbo vrstic. // Ugotovitve: // samostojen ++x, x++ , x je v obeh primerih povecan za 1 // y = ++x priredi y­u ZA ENO POVECAN x, x je po izrazu za 1 povecan // y = x++ priredi y­u x, x je po izrazu za 1 povecan 23
pre_post2 // Namen // subtleties of a unary operator ++ // izvajanje in neizvajanje segmentov sestavljenega logicnega pogoja // Naloga // Najprej ugotovite, kaj se izpise po spodnjih vrsticah in nato // vase ugotovitve preverite z izvedbo vrstic. // Ugotovitve: // x++ == Nekaj: primerja se x, po izrazu je x povecan za 1 // ++x == Nekaj: primerja se x+1, po izrazu je x povecan za 1 // if (a && b): ce je a==false, se b SPLOH NE IZVAJA! // zato: ce x=0, potem x++ != 1, zato se (y++ == 1) ne izvaja in ce y=0, potem y OSTANE 0! // zato rezultat x=1, y=0, z=0. 24
obrat_stevila // Namen // operatorja / % na spremenljivkah tipa int // Naloga // Napisite program, ki prebere trimestno naravno število in ga // izpise v obratnem vrstnem redu. // Vpisite trimestno naravno stevilo: npr. 726 // Obrat stevila 726 je 627. 25
vsota_kotov // Namen // znajti se pri enostavnem racunanju. // Naloga // Napisite program, ki prebere dva kota v stopinjah, minutah in sekundah // (celoštevilske vrednosti). Nato naj izracuna in izpise njuno vsoto. // Rezultat naj bo spet v stopinjah, minutah in sekundah. // // Vpisite prvi kot: // stopinje: npr. 14 // minute: npr. 43 // sekunde: npr. 15 // Vpisite drugi kot: // stopinje: npr. 55 // minute: npr. 21 // sekunde: npr. 57 // Vsota obeh kotov je 70 stopinj, 5 minut in 12 sekund. 26
kot_pretvorba // Namen // znajti se pri enostavnem racunanju. // Naloga // Napisite program, ki prebere kot v radianih (realno število) in ga izpiše // v stopinjah in minutah (celi števili). // Vpisite kot v radianih: npr. 2.185 // 2.185 radianov = 125 stopinj, 11 minut. 2.4. Ostalo
27
spremenljivke // Namen: // Razlikovati med lokalno in lokalno­lokalno spremenljivko. // lepse in splosnejse povedano, razlikovati med globalno in lokalno spremenljivko. // Naloga: // Kaj izpise spodnja koda? int main(int argc, char* argv[]) { int x = 4; int y =4; if (x > 3) { int y = 3; printf("x = %d\n", x); printf("y = %d\n", y); } printf("y = %d\n", y); return 0; } //­­­­­­­­­­­­­­­­­­­­­­­­ 3.
Ponavljalne strukture
3.1. for
1
c5_xrcss_4 // Namen: // zanka for, // uporaba podatka iz n­1 iteracije v n­ti iteraciji // Naloga: // Napisite program, ki izracuna in izpise tabelo faktoriel za stevila od 1 do 10. // npr. 5! = 5 x 4 x 3 x 2 x 1 = 120 // // Izpis: // Tabela prvih 10 faktoriel: // i i! // // 1 1 // 2 2 // 3 6 // 4 24 // 5 120 // 6 720 // 7 5040 // 8 40320 // 9 362880 // 10 3628800 2
for // Namen: // for najbolj osnovna zanka // ++x ali x++ se izvede na koncu zanke; potek programa je v obeh primerih enak // Naloga: // v for zanki izpisimo stevila od 1 do N s presledkom v vrsto. 3
zanka // Namen: // for zanka // ++x, x++ : enak potek (inkrement se izvaja na koncu zanke, // ni zdruzen z logicnim pogojem v en izraz // Naloga: // s for zanko zapisite v vrsto 1, 2, ...., 10 4
sinus // Namen: // raba for zanke za iterativen racunski postopek // operator += // znajti se pri rabi funkcij iz knjiznice: deg / rad; pi // Naloga: // tabelirajte sin(x) med 0 in 360 stopinj (2*Pi radianov) // s korakom 10 stopinj 5
integral // Namen: // uporaba for zanke za numericno racunanje (poljubnega) integrala // Naloga: // Racunamo integral funkcije f(x) = x^2 + 5x + 3 na intervalu [0, 10] // s korakom 0.001 (10000 korakov) 6
produkt_nenic_cifer // Namen // kompaktna raba zanke, logicni pogoj, kompaktna prireditev spremenljivke // Naloga // Sestavite program, ki prebere naravno število in izracuna produkt njegovih // nenicelnih števk. // Vnesi naravno število: 53802602 // Produkt nenicelnih stevk je 2880. 7
Fibonacci // Namen // zanka, sprotno izpisovanje rezultata iz zanke // Naloga // Sestavi program, ki izpiše prvih n clenov Fibonaccijevega zaporedja // (to je zaporedje, podano s predpisom: f1 = 1, f2 = 1, fn = fn­1 + fn­2. // Vpisite stevilo clenov: 10 // Cleni zaporedja so: 1 1 2 3 5 8 13 21 34 55 8
piramida // Namen // iterativen izpis v zanki // Naloga // Sestavimo program, ki bo izpisal piramido velikosti n, // kot je to prikazano na primeru. Uporabnik vnese n ­ stevilo vrstic oz. visino. // Spodnja vrstica piramide naj bo ob levem robu okna. // Vpisite visino piramide: 6 // * // *** // ***** // ******* // ********* //*********** 9
piramide // Namen: // zanka, sprotno izpisovanje v zanki // Naloga: // Sestavite program, ki bo eno poleg druge izpisal piramide velikosti // od n do 1, kot je to prikazano na primeru. Pri tem je n podatek, // ki ga vnese uporabnik. Prva piramida naj bo ob levem robu okna, // med piramidami naj bo en presledek. // Vpisite visino prve piramide: 6 // * // *** * // ***** *** * // ******* ***** *** * // ********* ******* ***** *** * //*********** ********* ******* ***** *** * 3.2. Relacijski operatorji
10
zanka2 // Namen: // uporaba sestavljenih pogojev v for zanki // Naloga: // Za spodnjo kodo ugotovite izpis. Pozenite program in uskladite // razmislek z delovanjem programa. 3.3. Vgnezdena for zanka
11
postevanka // Namen: // v for zanki vgnezdena for zanka za racunanje matricnega izraza // oblikovanje izpisa celostevilskega stevila na 4 mesta // Naloga: // Izpisite tabelo postevanke od 1 do 10. 12
dn_print_postevanka // Namen: // zanke. // Naloga: // izpis postevanke od 1 do 10, z oznakami 1­10 zgoraj in ob strani. 3.4. while
13
c5_xrcss_11 // Namen: // zanka while() // vgnezdena zanka // Naloga: // Napisite program, ki izracuna vsoto stevk vnesenega stevila. // Vpis stevila, izracun in izpis naj bodo v zanki, katere izvajanje prekinemo // z vnosom stevila 999 14
vnos // Namen: // uporaba zanke while() za korekcijo nepravilnega vnosa // Naloga: // Program od uporabnika zahteva vnos naravnega // stevila. Ce bomo vnesli negativno stevilo // (ali nic), bo program ponovno zahteval, da // vnesemo naravno stevilu. In ce bo treba, se // enkrat in se enkrat, vse dokler ne vnesemo // naravnega stevila. 15
vsota_stevk // Namen: // zanka while() // kompaktni operatorji +=, /= // Naloga: // Vpisite naravno stevilo: // Vsota stevk stevila je N 16
while // Namen // enostaven while() // spodnji ++x ali x++ da enak rezultat, ker je izvajan loceno od logicnega pogoja // ce inkrement x pisemo v logicni pogoj, x++ da za 1 vecje // stevilo ponavljanj zanke od ++x. // Naloga // z while() zanko pisite 1, 2, ...., 10 v vrsto 17
while2 // Namen: // kontrolno spremenljivko while() zanke spreminjamo razlicno, in // na razlicnih mestih. Ugotavljamo efekte. // Naloga: // Kaj izpisejo spodnje zanke? // Najprej ugotovite sami, potem pozenite program in uskladite neskladja // prvotnega razmisleka in dejanskega delovanja spodnjih zank. 18
kubi_do_stevila // Namen: // raba while() kot omejilni kriterij. // float spremenljivka izpisovana kot int je izpisana popolnoma narobe, // dinamicna prilagoditev tipa resi neskladnost. // Naloga: // Sestavimo program, ki prebere naravno število n in // izpiše vse popolne kube med 1 in n. // Vpisite zgornjo mejo: 100 // Kubi do 100 so: 1 8 27 64 19
e_vrsta // Namen // while, kompaktno pisanje prireditvenih operatorjev // Naloga // Sestavi program, ki prebere realno stevilo x in naravno število n ter // izracuna vsoto prvih n clenov potencne vrste za e^x. // x^2 x^3 x^(n­1) // e^x = 1 + x + ­­­ + ­­­ + ... + ­­­­­­­ // 2! 3! (n­1)! // // Vpisite x: 1.5 // Vpisite n: 10 // Vsota: 4.48167 // Prvi clen vrste je 1. Vsak naslednji clen lahko izracunamo // iz prejsnjega, tako da ga pomnozimo z x in delimo z ustreznim // faktorjem (ki je najprej 1, nato 2, nato 3, ...). 20
vrsta_ex // Namen // kompakten while. razmislek o e^neg. st. // Naloga // Sestavimo program, ki prebere realno število x in izracuna ex s pomocjo // spodnje potencne vrste. Sešteje naj toliko clenov vrste, da bo prišel // do clena, ki je manjsi od neke predpisane konstante EPS // (tega naj vec ne upošteva). // x^2 x^3 // e^x = 1 + x + ­­­ + ­­­ + ... // 2! 3! // // Vpisite x: 1.5 // e^1.5 = 4.48169 3.5. do/while
21
do_while // Namen // do while() najbolj osnovna zanka // razlika med ++x in x++ v logicnem pogoju // Naloga // v do while() zanki izpisi stevila od 1 do N s presledkom v vrsto. // N = 4 // ++pogoj: 1, 2, 3, 4 // pogoj++: 1, 2, 3, 4, 5 3.6. break, continue, goto, return
22
break_continue // Namen // for zanka, ki jo prekinja continue in jo prekine break // izpis v zanki sluzi razumevanju oz. razhroscevanju. // Naloga // zanka 5 iteracij in vgnezdena zanka 5 iteracij. // printf v zanki ­ izpisov bi bilo 25 // z if()oma pogojena continue in break v vgnezdeni zanki // dolocene izpise izlocita. // Iz pregleda kode ugotovi, kaj od 25 moznih izpisov bo izpisano. #pragma argsused int main(int argc, char* argv[]) { int x; int y; for (x=1; x <= 5; x++) { printf( "\n%d: ", x ); for (y=1; y <= 5; y++) { if ((x + y) % 3 == 0) continue; if ((x * y) == 3 ) break; printf( "%d ", y ); } } return 0; } 23
je_prastevilo // Namen: // for, %, break // Naloga: // Sestavimo program za preverjanje, ali je dano naravno število praštevilo. // Vpisite naravno število: 7623 // Število 7623 ni prastevilo. // prvih 25 poz. prastevil: // 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97 3.7. Ostalo
24
evklid_delitelj // Namen: // razumeti izvedbeno zahtevo algoritma in narediti kompakten izvedbeni program // ena izmed ponovitvenih zank, if, %, kompaktna priredba vrednosti // Naloga: // Sestavi program, ki z Evklidovim algoritmom izracuna najvecji // skupni delitelj naravnih stevil a in b. // Vpisite a: 3672 // Vpisite b: 624 // Najvecji skupni delitelj stevil 3672 in 624 je 24. // Evklidov algoritem, iskanje najvecjega skupnega delitelja. // izvajamo zanko dokler ni delilni ostanek enak nic. takrat je c mnogokratnik a­ja // primer 27,9: // iscemo najvecji skupni delitelj 102 in 33: (3) // 102 % 33 = 3 // 33 % 3 = 0 // 542, 456, (2) // 542 % 456 = 86 // 456 % 86 = 26 // 86 % 26 = 8 // 26 % 8 = 2 // 8 % 2 = 0 // 3672 in 624 (24) // 3672 % 624 = 552 // 624 % 552 = 72 // 552 % 72 = 48 // 72 % 48 = 24 // 48 % 24 = 0 // Najvecji skupni delitelj stevil 3672 in 624 je 24. // c(0) = a(27) % b(9) // a = b(9) // b = c(0) 25
vevklid_delitelj_pregleden // Vaja_evklid_delitelj_pregleden, gre skupaj z Vaja_4_1__evklid_delitelj, // tam je tudi podroben opis evklidovega algoritma // http://wiki.fmf.uni­lj.si/wiki/Evklidov_algoritem // Namen // kompaktno pisanje izrazov v zanki z izpisom v zanki. // nadomestilo polja z zanko ­ manj pisanja, elegantna oblika programa. // Naloga // Sestavi program, ki z Evklidovim algoritmom izracuna najvecji // skupni delitelj naravnih števil a in b. // Vnesi a: 3672 // Vnesi b: 624 // Najvecji skupni delitelj stevil 3672 in 624 je 24. // Dopolni Evklidov algoritem tako, da bo program sproti izpisoval še vse vmesne rezultate: // Vnesi a: 3672 // Vnesi b: 624 // 3672 = 5 * 624 + 552 // 624 = 1 * 552 + 72 // 552 = 7 * 72 + 48 // 72 = 1 * 48 + 24 // 48 = 2 * 24 + 0 // Najvecji skupni delitelj stevil 3672 in 624 je 24. 4.
Odločitvene strukture
4.1. if
1
if_stavek // Namen: // if (); // Naloga: // Vnesite celo stevilo: // Mozen izpis // Stevilo Vneseno je negativno. 2
relatorji // Namen: // if () ; // relacijski operatorji: ==, !=, <, >, <=. >= // Naloga: // Vnesi celo stevilo. // Mozni izpisi: // x je enak 10 // x ni enak 10 // x je manjsi od 10 // x je vecji od 10 // x je manjsi ali enak 10 // x je vecji ali enak 10 4.2. if/else if/else
3
if_else_stavek // Namen: // a) if (); else if (); else () // Naloga: // Vnesite celo stevilo: // Mozni izpisi: // Stevilo Vneseno je negativno. // Stevilo Vneseno je pozitivno. // Stevilo Vneseno je enako nic. 4
6_xrcss_2 // Namen: // while (true) ; break; // if (); else; kompakten logicni pogoj // Naloga: // Ali je prvo stevilo celostevilsko deljivo z drugim? // Vpisite dve celi stevili, 999 999 za konec: // Mozni izpisi: // A je celostevilsko deljivo z B // A ni celostevilsko deljivo z B // Konec. 5
ugani // Namen: // a) while() // b) if (); else if (); else; // c) rand() // Naloga: // Sestavite program, ki izbere nakljucno naravno število med 1 in 100, potem pa // od uporabnika zahteva, da to število ugane. Po vsakem poskusu naj izpiše, // ali je izbrano število manjše ali vecje od vnešenega. Program konca, // ko uporabnik ugane stevilo. // Namig: rand() vrne nakljucno celo število med 0 in RAND_MAX. // Pred tem je treba nastaviti generator nakljucnih števil, kar storimo // ssrand((unsigned)time(NULL)) (samo enkrat na zacetku programa). // Vse potrebne funkcije so definirane v stdlib.h in time.h. // Uganite nakljucno generirano stevilo med 1 in 100: // 1. poizkus: 50 // Narobe. Stevilo 50 je premajhno. // 2. poizkus: 75 // Narobe. Stevilo 75 je preveliko. // 3. poizkus: 62 // Narobe. Stevilo 62 je preveliko. // 4. poizkus: 57 // Cestitka. Stevilo 57 ste uganili v 4. poskusu. 6
6_xrcss_3 // Namen: // while (true) ; break; continue; // if (); else; kompakten logicni pogoj // dinamicno dolocen tip spremenljivke // Naloga // Deljenje dveh celih stevil, kvocient je izracunan na tri decimalna mesta. // Vpisite dve celi stevili, 999 999 za konec: // Mozni izpisi: // Deljenje z niclo, ni izracunljivo! // A deljeno z B je x.xxx // Konec. 7
kroga // Namen: // if (); else if (); else ; // vpis vecih realnih stevil v vrsti s presledki // uporaba enostavnih funkcij iz math.h // gre skupaj z v_2_3__kroga_preverba // Naloga: // Vpisite podatke za prvi krog (x,y;r): // Vpisite podatke za drugi krog (x,y;r): // Mozni izpisi: // Kroga se sekata. // Kroga se ne sekata. // Kroga se dotikata. 8
prastevilo // Namen // a) for (;;); posebno izvajanje praznega stavka, vrednost tekoce spremenljivke // je pomembna v nadaljevanju // b) if (); else; // c) izdelava smiselnega algoritma, kjer ni veliko racunanja in kjer je malo kode // in kjer je koda enostavno berljiva 9
kroga_preverba // Namen // if (); else if (); else ; // uporaba enostavnih funkcij iz math.h // gre skupaj s p_3_9__kroga // Naloga // Dva kroga, vpisite x1: // Dva kroga, vpisite y1: // Dva kroga, vpisite r1: // Dva kroga, vpisite x2: // Dva kroga, vpisite y2: // Dva kroga, vpisite r2: // Mozni izpisi: // Kroga sovpadata. // Kroga se dotikata. // Kroga sta locena ­ drug v drugem ali ob drugem. // Kroga se sekata v dveh tockah. 10
branje_poprecje // Namen: // a) n++ // b) while (true) ; // c) break; // d) if (); else ; // Naloga: // Sestavi program, ki bere števila, dokler ne vnesemo števila 0. // Program naj sproti izpisuje najvecje število, najmanjše število ter povprecje števil. // Vnesi celo število: 15 // min = 15, max = 15, povp = 15 // Vnesi celo število: 8 // min = 8, max = 15, povp = 11.5 // Vnesi celo število: 25 // min = 8, max = 25, povp = 16 // Vnesi celo število: 13 // min = 8, max = 25, povp = 15.25 // Vnesi celo število: 0 11
funkcija_izpis // Namen: // a) if (); else if (); else() // b) razlikovanje med racunanjem ostanka pri celostevilskem deljenju (operator % modulus) // in racunanjem ostanka pri deljenju realnih stevil. // floor(5.0 / 4.0) da 1. kar je isto kot (int) (5.0 / 4.0) // isto dobim z floor() ali z dynamic typecasting // Naloga: // Realna periodicna funkcija s periodo 10 je na intervalu [0, 10) podana z naslednjim predpisom: // f(x) = x + sin(x), za 0 <= x < 2 // f(x) = |x ­ 3|, za 2 <= x <= 4 // f(x) = (x ­ 5) * 2, za 4 < x < 7 // f(x) = 12 ­ 5x, za 7 <= x < 10 // Sestavimo program, ki bo za dano realno število x izracunal vrednost te funkcije. // Namig: ker je funkcija periodicna, poišcemo najprej tocko na intervalu [0,10), // pri kateri ima funkcija enako vrednost. 4.3. Sestavljeni logični pogoji
12
kaj_izpisem // Namen: // a) delovanje prireditvenih in relacijskih operatorjev // b) if () ; s tezkimi logicnimi pogoji // Naloga: // Zacetni pogoj: x=0, y=1 // ugotoviti, kateri sestavljeni logicni pogoji so true, oziroma 1. 13
kaj_izpisem2 // Namen: // a) delovanje prireditvenih in relacijskih operatorjev in unarnega operatorja // b) if () ; s tezkimi logicnimi pogoji // Naloga: // Zacetni pogoj: x=0, y=1 // ugotoviti, kateri sestavljeni logicni pogoji so true, oziroma 1. 14
kaj_izpisem3 // Namen: // a) delovanje prireditvenih in relacijskih operatorjev in unarnega operatorja // b) if () ; s tezkimi logicnimi pogoji // Naloga: // Zacetni pogoj: x=0, y=1 // ugotoviti, kateri sestavljeni logicni pogoji so true, oziroma 1. 15
prestopno // Namen: // if, if else vgnezdeni stavek. primer popolne nepreglednosti pisanja. // pogoji so nepregledni, isti izpis je definiran na vec mestih, koda je neberljiva. // Naloga: // Vnesi letnico: // Mozna izpisa: // Leto je prestopno. // Leto ni prestopno. 16
prestopnoA // Namen: // if (); else ; s kompleksno sestavljenim logicnim pogojem // raba taksnih pogojev zelo skrajsa pisanje kode in omogoci // mocne odlocitve // Naloga: // Vpisite leto: // mozna izpisa: // Leto Vneseno je prestopno. // Leto Vneseno ni prestopno. 17
prestopno2 // Namen: // if (); else ; // kompaktno pisanje pogojev, odlicna preglednost kode. // Naloga: // Vnesi letnico: // Mozna izpisa: // Leto je prestopno // Leto ni prestopno 18
trikotnik_preverba // Namen: // if (); else ; z zelo kompleksnim pogojem ­ odlicna preglednost kode // lokalna definicija spremenljivk v if (); stavku za doseganje kompaktnosti kode // Naloga: // Trikotnik, vpisite dolzino stranice a: // Trikotnik, vpisite dolzino stranice b: // Trikotnik, vpisite dolzino stranice c: // Izpis: // Tak trikotnik obstoja. // Tak trikotnik ne obstoja. 4.4. Vgnezdeni if stavki
19
sahovnica // Namen // a) if (); if (); else if (); vgnezdenost if stavkov // b) za vajo zunanje if stavke spremeniti v switch / case // c) sestavljeni logicni pogoji so osnova kompaktnega pisanja kode // gre skupaj z v_2_1__sah_preverba // Naloga // Prvo polje (i,j): // Drugo polje (k,l): // Oznaka figure (1=trdnjava, 2=tekac, 3=kralj, 4=kraljica): // Mozni izpisi: // Trdnjava napada figuro na drugem polju. // Trdnjava ne napada figure na drugem polju. // Tekac napada figuro na drugem polju. // Tekac ne napada figure na drugem polju. // Kraljica napada figuro na drugem polju. // Kraljica ne napada figure na drugem polju. // Kralj napada figuro na drugem polju. // Kralj ne napada figure na drugem polju. // Konj napada figuro na drugem polju. // Konj ne napada figure na drugem polju. 20
sah_preverba // Namen // if (); else if (); // c) sestavljeni logicni pogoji so osnova kompaktnega pisanja kode // gre skupaj z p_3_13__sahovnica // Naloga // Vnesi x koordinato prvega polja: // Vnesi y koordinato prvega polja: // Vnesi x koordinato drugega polja: // Vnesi y koordinato drugega polja: // Mozni izpisi: // Polji sta enake barve. // Polji nista enake barve. // Trdnjava napada figuro na drugem polju. // Trdnjava ne napada drugega polja. // Tekac napada figuro na drugem polju. // Tekac ne napada drugega polja. // Kraljica napada figuro na drugem polju. // Kraljica ne napada figure na drugem polju. // Konj napada figuro na drugem polju. // Konj ne napada figure na drugem polju. // Kralj napada figuro na drugem polju. // Kralj ne napada figure na drugem polju. 4.5. switch/case
21
switch_stavek // Namen // switch / case // Naloga // Vnesi celo stevilo: // Mozni izpisi: // Imam 1 jagodo. // Imam 2 jagodi. // Imam 3 jagode. // Imam 4 jagode. // Imam x jagod. 22
racunska_operacija // Namen: // a) switch / case; // b) vnos in izpis spremenljivk tipov int, char // c) logicna relacija s spremenljivko tipa char // Naloga: // Vnesite prvo celostevilsko stevilo: // Vnesite drugo celostevilsko stevilo: // Vnesite racunsko operacijo ( +, ­, *, / ): // Mozni izpisi: // a + b = c // a ­ b = c // a * b = c // a / b = c // Napaka: deljenje z 0. // Napaka: neznana racunska operacija. // Napaka. 23
switch_stavek2 // Namen // switch / case podrobnosti: // izpustiti break // case je lahko samo konkretna vrednost, ne more biti logicni pogoj kot pri if (); // omejiti nabor stevilskih moznosti z uporabo ostanka celostevilskega deljenja // Naloga // Vnesi celo stevilo: // Mozni izpisi: // Imam 1 jagodo. // Imam 2 jagodi. // Imam 3 jagode. // Imam 4 jagode. // Imam x jagod. // Nimam nobene jagode. 4.6. Pogojni operator (stisnjeni if)
24
unija_pravokotnikov // Namen: // a) if () ; // b) x = (pogoj) ? a : b // c) definicija spremenljivk samo za rabo v sestavljenem stavku // Naloga: // Sestavimo program, ki bo izracunal obseg in površino unije dveh pravokotnikov. // Stranice pravokotnikov so vzporedne koordinatnima osema. Vsak pravokotnik // je podan s koordinatami dveh nasprotnih si oglisc. // Podatki o prvem pravokotniku: // Vnesi koordinati oglisca: // Vnesi koordinati nasprotnega oglisca: // Podatki o drugem pravokotniku: // Vnesi koordinati oglisca: // Vnesi koordinati nasprotnega oglisca: // obseg = Izracunan // ploscina = Izracunana 4.7. Ostalo
25
6_xrcss_6 // Namen: // switch, case // for, do while, ­ obracanje stevk v nizu // Naloga: // Vpisite pozitivno stevilo z najvec 10 znaki. 999 za konec: // Mozna izpisa // stevke v besedah // Konec. // ima se majhne tezave z 0 // Write a program that takes an integer keyed in from the terminal and extracts and // displays each digit of the integer in English. So, if the user types in 932, the program // should display // devet tri dva // Remember to display “zero” if the user types in just a 0. (Note: This exercise is a // hard one!) 26
6_xrcss_ 4 // Namen: // if () kompleksni pogoj // switch case // sestavljena prireditev vrednosti += // Naloga: // Write a program that acts as a simple “printing” calculator.The program should // allow the user to type in expressions of the form // number operator // The following operators should be recognized by the program: // + ­ * / S E // The S operator tells the program to set the “accumulator” to the typed­in number. // The E operator tells the program that execution is to end.The arithmetic operations // are performed on the contents of the accumulator with the number that was // keyed in acting as the second operand. 5.
Podatkovna polja
5.1. Definicija polj
1
c7_xrcss_4 // Namen: // polje spremenljivk float, inicializacija, indeksi elementov // Naloga: // Program naj izracuna poprecje polja 10 spremenljivk tipa plavajoce vejice (floating point) 2
c7_xrcss_5 // Namen: // branje nizov in zank // Naloga: // What output do you expect from the program below? // // Vsak element polja je po vrsti izracunan kot vsota predhodnih elementov. // Rezultat, ki se izpise: // 1 1 2 4 8 16 32 64 128 256 3
kaj_naredim // Namen: // izpis v zanki elementov polja na obicajen nacin a[i] // in izpis v zanki elementov polja na neobicajen nacin i[a] // Naloga: // Imam polje stirih int stevil z inicializiranimi vrednostmi. // Izpisimo to polje v dveh iteriranih stavkih. // Prvic formatirajmo printf za obliko a[i], // drugic formatirajmo printf za obliko i[a] 4
izpis // Namen: // popolnjujemo polje z vnesenini stevili // v rastoci in padajoci zanki for tiskamo elemente polja // Naloga: // Sestavi program, kjer bo uporabnik najprej vpisal podatke v tabelo celih števil. // Program naj nato tabelo izpiše v obe smeri. // // Od leve proti desni: 7 2 8 32 ­4 // Od desne proti levi: ­4 32 8 2 7 5.2. Raba elementov polja kot števcev
5
kopiranje_enostavno // Namen: // Elementi polja ob definiranju niso inicializirani // najenostavnejse kopiranje je priredba vrednosti med posameznima elementoma dveh polj. // izpis a[i] in i[a] // Naloga: // Imamo dve polji, vsebujoci po 6 int spremenljivk. // Kopirajmo vrednosti inicializiranega polja v vrednosti neinicializiranega polja // Preverimo neinicializiranost spremenljivk neinicializiranega polja in // preverimo rezultat kopiranja. 6
tabela // Namen: // tabela kot polje // vnos elementov, iskanje elementa, sortiranje tabele, izpis elementa tabele // Naloga: // preuci, napisi, ni pretezko 7
iskanje_v_tabeli // Namen: // popolnimo polje spremenljivk // iscimo izbrano vrednost // zanka for, if else, break // Naloga: // Sestavimo program, kjer bo uporabnik najprej vpisal podatke v tabelo // celih števil. Program naj nato uporabnika sprašuje po celih številih, // za vsako vpisano število pa naj poišce mesto v tabeli, kjer se to število // pojavi prvic. Vnos števil zakljucimo z niclo. 8
stetje_v_nakljucni_tabeli // v_6_3__stetje_v_nakljucni_tabeli // Namen: // polnjenje polja nakljucne dimenzije z nakljucnimi stevili // algoritem izpisa pogostosti posameznega stevila // Naloga: // Sestavi program, ki bo najprej ustvaril nakljucno tabelo. Število elementov // v tabeli naj bo nakljucno število med 0 in LEN, posamezni elementi tabele // pa nakljucna števila med 0 in MAX (LEN in MAX sta vnaprej definirana simbola). // Program naj tabelo izpiše, nato pa še prešteje, kolikokrat se pojavi katero // število. // Izpiše naj frekvence samo tistih elementov, ki se v tabeli pojavijo vsaj enkrat. // Tabela: 1 6 3 0 8 3 6 3 5 7 // Stevilo 0 se pojavi 1­krat. // Stevilo 1 se pojavi 1­krat. // Stevilo 3 se pojavi 3­krat. // Stevilo 5 se pojavi 1­krat. // Stevilo 6 se pojavi 2­krat. // Stevilo 7 se pojavi 1­krat. // Stevilo 8 se pojavi 1­krat. 5.3. Generiranje Fibonaccijevih števil
9
fibonacci // Namen: // delo s polji ­ arrays // elementi polja: ep[0] .... ep[DIM­1] // sekvencno polnjenje polja integerjev z rastocim indeksom // sekvencno branje polja integerjev s padajocim indeksom // Naloga: // izracunajte in izpisite 25 zaporednih fibonaccijevih stevil // f1 = 0, f2 = 1, f[n] = f[n­1] + f[n­2] 10
fibonacci // Namen: // delo s polji ­ arrays // elementi polja: ep[0] .... ep[14] // sekvencno polnjenje polja integerjev z rastocim indeksom // sekvencno branje polja integerjev Z RASTOCIM indeksom // Naloga: // izracunajte in izpisite 25 zaporednih fibonaccijevih stevil // f1 = 0, f2 = 1, f[n] = f[n­1] + f[n­2] 5.4. Inicializacija polj
11
znesek // Namen // definicija inicializiranega polja, // stevilo elementov iz razmerja velikosti polje / element // zanka if­a s sprotnim pisanjem rezultata // Naloga // Vpisite znesek: npr 2322, potem izpis // 2 * 1000 // 1 * 200 // 1 * 20 // 1 * 2 12
malo_bankovcev // Namen // definicija inicializiranega polja, // zanka if­a s sprotnim pisanjem rezultata // Naloga // Vpisite znesek: npr 2322, sledi izpis: // 2 * 1000 // 1 * 200 // 1 * 20 // 1 * 2 5.5. Polja znakov
13
asciiArt // Namen: // inicializirana polja char, int // raba elementov polja B za kontrolne spremenljivke izpisa elementov polja A // raba elementov polja C za kontrolne spremenljivke ponavljanja izpisa polja A // Naloga: // narisimo sovo iz podatkov: // polje risarskih char znakov // polje indeksov zaporedne rabe risarskih znakov // polje indeksov ponavljanja risarskega znaka 5.6. Večdimenzijska polja
14
transponiranje // Namen: // vecdimenzionalno polje, konkretno dvodimenzionalno polje // transponiranje matrike: a[i][j] = a[j][i] // vpis elementov // izpis matrike // Naloga: // Vnesi razseznost kvadratne matrike: 3 // a[1,1] =1; a[1,2] =2; a[1,3] =3; // a[2,1] =4; a[2,2] =5; a[2,3] =6; // a[3,1] =7; a[3,2] =8; a[3,3] =9; // // Izpis matrike in izpis transponirane matrike 15
vektor_produkt_vsota // Namen: // dva poljubnodimenzionalna vektorja // vsota in skalarni produkt dveh poljubnodimenzionalnih vektorjev // Naloga: // Primer vnosa: // Dimenzija: 3 // a[0] = 2 // a[1] = 0 // a[2] = ­3 // b[0] = 1 // b[1] = 4 // b[2] = 5 // Vsota: 3 4 2 // Skalarni produkt: ­13 5.7. Ostalo
16
nepadajoca_tabela // Namen: // polje, for, if, break // Naloga: // Ugotavljamo nepadajoco urejenost tabele // Vnesi stevilo elementov (med 0 in 100): 5 // 1. element: 1 // 2. element: 2 // 3. element: 8 // 4. element: 8 // 5. element: 23 // Tabela je nepadajoce urejena. // (Tabela ni nepadajoce urejena.) 6.
Fukcije
6.1. Definicija in klic funkcije
1
funkcije // Namen: // Strukturiranje programa od zgoraj navzdol v funkcije // za hitrejse pisanje, za vecjo preglednost in za mozno recikliranje funkcij. // Naloga // Programcek naj vprasa po vnosu dveh stevil // Stevili naj sesteje, in naj izpise rezultat. // Programcek naj bo strukturiran v funkcije // int preberi(void); // int vsota (int a, in t b); // void izpisi (int a) 2
zamenjaj // Namen: // Funkcija ne spremeni svojih vhodnih parametrov. // Naloga: // Najprej ugotovite, kaj naredi funkcija // void zamenjaj(int a, int b); // Svojo ugotovitev preverite z izvajanjem programa. 3
zamenjaj3 // Namen: // Globalne spremenljivke lahko spreminjamo kjerkoli v programu. // Naloga: // Najprej ugotovite, kaj naredi funkcija // void zamenjaj(void); // Svojo ugotovitev preverite z izvajanjem programa. 4
8_xrcss_8 // Namen: // Pisanje programa od zgoraj navzdol. // Strukturiranje programa v funkcije. // Naloga: // Napisite program za racunanje resitev kvadratne enacbe. // // Kvadratna enacba ima obliko: // a * x^2 + b * x + c = 0. // // Npr. 4 * x^2 ­ 17 * x ­ 15 = 0 je kvadratna enacba s koeficienti // a = 4, b = ­17, c = ­15. // Za izracunati resitev x lahko vpisemo a, b, in c v // D = b ^ 2 – 4 * a * c // x1, x2 = (­b +­ sqrt(D)) / 2a // Ce je D < 0, naj program izpise, da so resitve imaginarne, ce pa je D >= 0, // naj program izracuna in izpise resitvi. 5
NSD // Namen: // izdelava in uporaba funkcije // int NSD(int a, int b); // funkcija mora biti robustna oz. odporna na // nepricakovane stevilske vnose (nicla) // Naloga: // Racunajmo NSD v funkciji // int NSD(int a, int b); // in napisimo program, ki vprasa po obeh stevilih in izpise NSD. 6
fib_iter // Namen: // Zapisati in verificirati funkcijo za izracun poljubnega Fibonaccijevega stevila, // ki za poljuben argument vrne ustrezno Fibonaccijevo stevilo. // Naloga: // Izracunajmo Fibonaccijevo stevilo z uporabo funkcije // int fib(int n), // v kateri zapisemo izracun Fibonaccijevega stevila v // for zanki. // Z uporabo te funkcije izpisimo prvih 35 clenov Fibonaccijevega zaporedja. 6.2. Argumenti in lokalne spremenljivke
7
izpis_niz // Namen // return vrednosti funkcij C knjiznic // Naloga // cemu sluzi x (puts return value)? //int puts ( const char * str ); // Writes string to stdout // Writes the C string pointed by str to stdout and appends a newline character ('\n'). // The function begins copying from the address specified (str) until it // reaches the terminating null character ('\0'). This final null­character is not copied to stdout. // On success, a non­negative value is returned. // On error, the function returns EOF. 8
izpis_znak // Namen // return vrednosti funkcij C knjiznic // Naloga // cemu sluzi x (putchar return value)? 6.3. Funkcije in polja
9
8_xrcss_11 // Namen // raba funkcije z vhodno spremenljivko tipa niz // Naloga // Napisite funkcijo // long int vsota_elementov_niza(int niz[], int dolzina_niza) // ki izracuna in vrne vsoto elementov niza. // Funkcijo uporabite v programu, kjer najprej definirate 2 niza, // potem dvakrat klicete vsota_elementov_niza in izpisete // vsoti elementov obeh nizov. 10
obrni // Namen // izdelava in klic funkcije za delo z nizom. // Naloga // Naredite program, ki vprasa za vnos niza in izpise obrnjen niz. // Niz naj obraca funkcija // void obrni(char []); // // Vpisite besedilo: // npr. "Janez se pelje v mesto." // Obrnjen niz: // ".otsem v ejlep es zenaJ" 11
bisekcija // Namen: // Iskanje elementa v nizu // Naloga: // Napisite program, ki bo v po velikosti urejenem nizu 20 poljubnih stevil // nasel iskano stevilo. // funkcija iskanja naj bo deklarirana kot // IndeksNahajanja najdi(int IskanoStevilo, int UrejeniNiz[], int DolzinaUrejenegaNiza); // Ce iskanega stevila ni v tabeli, naj IndeksNahajanja vrne ­1. 12
izpis // Namen: // Izpis elementov niza (enodimenzionalne tabele) s pomocjo funkcije // void izpis(int t[], int len) // v kateri izpisujete elemente niza v for zanki // Naloga: // int main(int argc, char* argv[]) { // int tabela[10] = {1, 2, 5, 10, 20, 50, 100, 200, 500, 1000}; // izpis(tabela, 10); // return 0; // } 13
argument_tabela // Namen: // raba funkcije z argumentom polja // sizeof() funkcija iz stdio knjiznice za velikosti spremenljivk in polj // Naloga: // Imamo tabelo oz. polje 5 stevil: int tab[] = {1, 2, 3, 4, 5}; // naredimo program, s katerim menjamo pozicije teh stevil v tabeli. // program naj bo strukturiran v dve funkciji: // ­ izpis tabele: void izpisi(int a[], int n); // ­ menjava stevil: void zamenjaj(int a[], int i, int j) 6.4. Rekurzija
14
rekurzija // Namen: // rekurzivna funkcija // preglednost rekurzivnega klica: breakpoint v funkciji, potem view, debug, call stack // Naloga: // Naredite program za racunanje faktoriele // v rekurzivni funkciji. 15
fib // Namen: // rekurzivna raba funkcije (funkcija klice sama sebe) // view: debug windows: call stack // Naloga: // Izracunajte prvih 35 elementov Fibonaccijevega zaporedja // z uporabo rekurzivne funkcije. 6.5. Ostalo, vararg
16
vararg // Namen: // zapis in raba funkcije s spremenljivim stevilom argumentov // to omogocajo funkcije deklarirane v stdarg.h // Naloga: // printf( "%g\n", zmnozek(2, 2.1, 3.4 )); // printf( "%g\n", zmnozek(4, 1.2, 0.3, 2.1, 3.4 )); // napisite main(), vsebujoc printf zgoraj in printf zgoraj, kjer prvi argument pove stevilo naslednjih argumentov 7.
Strukture
1
p_7_10__struct // Namen // definiranje in raba strukturiranega podatkovnega tipa // Naloga // struct oseba sestoji iz imena in starosti // program naj sam vpise ime in naj vprasa po starosti osebe. // natisneta naj se ime in starost struct oseba. 2
p_6_5__kroznica // Namen: // definicija in raba strukturiranega podatkovnega tipa // Naloga: // definirajte strukturo tocka(x,y) in strukturo krog(tocka,r). // program naj izracuna razdaljo med kroznico in tocko za // tocka: (3,8) // krog: ((3,4)2.5) 8.
Znakovni nizi
8.1. Znakovni nizi
1
niz1 // Namen: // relacija med char in string // printf() // Naloga: // definirajte niz Peter, program naj ga izpise // spremenite posamicne crke v tem nizu, npr zadnji del v ra, izpisite ime // spremenite posamicne crke v tem nizu, npr zadnji del v rica, izpisite ime // // Izpis programa: // Dober dan, Peter. // Dober dan, Petra, // Dober dan, Petrica. 2
niz2 // Namen: // razlicni nacini definiranja niza, // zveza med nizom, char, in int // printf(), strcpy() // Naloga: // Na cim vec nacinov definirajte niz Peter, izpisite ga z izpisom niza, crk (char) in // stevilk (int). 8.2. Vnos znakovnih nizov
3
preberi_gets // Namen: // vnos in izpis niza // printf(),gets(), puts() // Naloga // Napisimo program za vnos in izpis niza // Vpisite niz (koncaj z Enter): npr. Se malo in bivanje bo postalo zanimivo.<Enter> // Vpisali ste: Se malo in bivanje bo postalo zanimivo. 8.3. Operacije nad znaki
4
10_xrcss_5 // Namen: // pisanje funkcije za v knjiznico dela z nizi // Naloga: // Napisite funkcijo findString, ki ugotovi, ce v nizu obstoja dolocen podniz. // rabe te funkcije: // index = findString ("a chatterbox", "hat"); // Deklaracija te funkcije // int findString (const char source[], const char s[]); // return vrednost naj bo indeks, kjer se iskani podniz zacne. // ce se iskanega podniza ne najde, naj funkcija vrne ­1. // vgornjem primeru funkcija vrne 3, je mesto znaka 'h', zacensi z mestom 0. 5
10_xrcss_6 // Namen: // pisanje funkcije za v knjiznico dela z nizi // Naloga: // Napisite funkcijo removeString, ki iz niza odstrani doloceno stevilo znakov od // dolocenega mesta naprej. // rabe te funkcije: // bool removeString (char source[], NStart, NcharsToRemove); // primer: // char Text[] = "the wrong son"; // bool Success = removeString (Text, 4, 6); // Novi Text je "the son". // Funkcija vrne true, ce je odstranitev uspesna, in false, ce // vhodnih zahtev ne izpolni (indeksi izven dolzine vhodnega niza) 6
10_xrcss_7 // Namen: // pisanje funkcije za v knjiznico dela z nizi // Naloga: // Napisite funkcijo insertString, ki v niz vrine drug niz. // rabe te funkcije: // void insertString (char source[], const char s[], int i); // primer: // char Text[] = "the wrong son"; // insertString (text, "per", 10); // vstaviti "per" na 10. mesto v nizu Text // Novi Text je "the wrong person". 7
10_xrcss_8 // Namen: // pisanje funkcije za v knjiznico dela z nizi // Naloga: // v prejsnjih nalogah ste napisali funkcije findString, removeString, and insertString. // Z uporabo teh funkcij napisite // replaceString (source, s1, s2); // ki zamenja v nizu source podniz s1 z nizom s2. // Deklaracija za replaceString: // void replaceString (char stringMain[], const char substringToRemove[], // const char substringToExchangeRemoved[]); // Nova funkcija naj z findString najde s1, potem naj klice removeString za // odstraniti s1, potem naj klice insertString za vstaviti s2. // Klic funkcije // replaceString (text, "1", "one"); // zamenja prvo "1" z "one" v nizu text, ce "1" v nizu Text obstoja. // Podobno, // replaceString (text, "*", ""); // zamenja prvo "*" z "" v nizu text, ce "*" v nizu Text obstoja. Torej, odstrani // prvo "*", saj jo nadomesti s praznim nizem. 8
palindrom // Namen: // printf(), scanf(), strlen(), strcmp(), string in char // Naloga: // Vpisite besedo: np. Ana // Beseda je palindrom. // // Vpisite besedo: Anamarija // Beseda ni palindrom. 9
palindrom2 // Namen: // printf(), scanf(), strlen(), direktno primerjanje chars od spredaj in od zadaj // Naloga: // Vpisite besedo: np. Ana // Beseda je palindrom. // // Vpisite besedo: Anamarija // Beseda ni palindrom. 10
palindrom3 // Namen: // printf(), fgets(), isalpha(), strcmp(), velike v male po posameznih crkah, // besedo najprej ocistimo: odstranimo vse necrke, vse crke uredimo v male crke // primerjava crk od spredaj in od zadaj // Naloga: // Vpisite besedilo: npr. Ana // Beseda je palindrom. // // Vpisite besedo: Anamarija // Beseda ni palindrom. 11
obrni_niz // Namen: // delo z nizom. // pess ugotovljena dolzina (brez strlen()), in prestavljanje crk v nizu // vpis niza s gets() in izpis niza s puts() ali s printf() // resevanje manjsega problema po manipulaciji crk ­ manjka '\0' na koncu // in zato nakljucni znaki po koncu drugega niza. to uredimo na vsaj 3 nacine: // a) v zanki pripisemo '\0' // b) strlen() in pripisemo '\0' // c) memset inicializacija drugega niza na zacetku // d) inicializacija drugega niza na zacetku v zanki // printf(), gets(), strlen(), memset(), puts(), // Naloga: // Program naj omogoci vpis niza in naj izpise isti niz od zadaj naprej. // Vpisite niz: npr. Astra // 1. niz: Astra // 2. niz: Artsa 12
odrezi // Namen: // uporaba knjiznicne funkcije za delo z nizom. // s strchr() iscemo prvo ustrezno crko in z rezultatom manipuliramo niz // printf(), gets(), strchr() // Naloga: // Vpisite niz: npr Team % of America // Novi niz: Team 13
besede // Namen: // prestejemo besede v nizu. // printf(), gets(), strlen(), pregled po chars za ' ' // Naloga: // Napisite program, ki prebere stavek in presteje, kolik je besed v njem. // Beseda je poljubno zaporedje znakov, posamezne besede pa so locene z enim // ali vec presledki. Presledki se lahko pojavljajo tudi na zacetku ali koncu stavka. // // Vpisite niz: Mount Everest je visok 8846 metrov. // V nizu je 6 besed. 14
oklepaji // Namen: // printf(), gets(), manipulacija niza // Naloga: // Napisite program, ki bo za dani niz preveril, ali so oklepaji v njem pravilno // gnezdeni. Omejite se lahko samo na okrogle () oklepaje. // Oklepaji so pravilno gnezdeni, ce so v parih (): pomeni, // a) da je stevilo levih enako stevilu desnih oklepajev in da // b) je levi oklepaj pred desnim oklepajem. // // Vpisite niz: npr. (a)xy((14+4(t))x(32))u // Oklepaji so pravilno gnezdeni. 15
crke_sprememba // Namen: // gets(), printf(), manipulacija niza po posameznih znakih samo // s pomocjo ASCII tabele znakov // Naloga: // Napisite program, kjer bo v danem nizu vse velike crke pretvoril v // ustrezne male crke, in obratno. Vse druge znake naj pusti nespremenjene. // Vpisite niz: abc+XYZ // Spremenjen niz: ABC+xyz 16
niz_condense // Namen: // Izlet v (enostavno) komprimiranje / dekomprimiranje podatkov. // Delo z nizem na nivoju posameznih chars. // Naloga: // Napisite program, ki bo iz danega niza sestavil nov niz tako, da ga bo stisnil. // Pri stiskanju naj vec zaporednih pojavitev istega znaka nadomesti s tem znakom // in stevilom njegovih pojavitev (predpostavka: zaporednih pojavitev < 10). // Program nato dopolnite še z inverzno operacijo, ki bo iz stisnjega niza generirala prvotni niz. // Vpisite niz: aaabba cccddddd // Stisnjen niz: a3b2a c3d5 // Prvotni niz: aaabba cccddddd 17
vislice // Namen // postati mojster dela z nizi // // do check on fflush(stdin) // Naloga // Napisite program, ki bo z vami igral igro vislice. Uporabnik naj vnese besedo, // potem pa se dela, kot da te besede ne pozna. Program naj najprej sestavi // vzorec, sestavljen iz samih zvezdic, nato pa pocaka na vnos crke s tipkovnice. // Ce ta crka nastopa v besedi, potem ustrezne zvezdice v vzorcu nadomesti s to // crko, ce je ni, pa izpise primerno obvestilo. To ponavlja toliko casa, // dokler uporabnik ne odkrije vseh crk. // Vpisite besedo: banana // Uganite vpisano besedo! // ****** // Vpisite crko: a // *a*a*a // Vpisite crko: s // Crke s ni v besedi. // *a*a*a // Vpisite crko: n // *anana // Vpisite crko: b // banana // Uspeh! 8.4. string.h
18
podniz_stevk // Namen: // delo s funkcijami iz knjiznice, deklarirane v strings.h, za delo z nizi // printf(), gets(), strlen(), strcspn(), strspn(), strncpy() // Naloga: // Program naj izpise prvi numericni del [0 .. 9] vpisanega niza. // Vpisite niz: npr. Stefan ima 30 let. // Podniz: 30 19
poisci_je // Namen: // raba funkcij string.h, iskanje niza v nizu in izpis prvotnega niza od iskanega niza naprej. // printf(), gets(), strncpy() // Naloga: // v vpisanem nizu iscemo niz "je" in izpisemo niz "je" in vse za njim. // Vpisite niz: npr. Vozilo je drago. // Iskani podniz je "je drago". // ali // Vpisite niz: npr. Danes nic novega. // Podniza "je ..." ni 20
poisci_je_ni // Namen: // string.h funkcije // printf(), gets(), strstr(), strncpy() // Naloga: // vpisani niz naj se izpise od "je" ali "ni" naprej. // ce takega podniza ni, naj program izpise ­ Ustrezajocega niza ni. // Vpisite niz: npr. Vreme je lepo tudi danes. // Iskani podniz je: je lepo tudi danes. 21
prestej // Namen: // funkcije iz string.h, ctype.h, // printf(), gets(), isalpha(), isdigit(), isalpha(), isdigit() // Naloga: // Vpisite niz: npr. Danone ima reklamo za 1000 eur. // Dolzina niza: 31 // Stevilo crk: 21 // Stevilo stevk: 4 22
primerjanje // Namen: // funkcije iz string.h // printf(), gets(), strlen(), strcmp(), strncmp() // Naloga: // Vpisite prvi niz: npr. franc // Vpisite drugi niz: npr. klanc // Urejeno po casu vnosa: "franc", "klanc" // Urejeno po dolzini: "franc", "klanc" // Urejeno leksikografsko: "franc", "klanc" // Urejeno leksikografsko (po prvih 3 znakih): "franc", "klanc" 23
primerjanje2 // Namen: // funkcije iz string.h // printf(), strcpy(), memcmp() // Naloga: // dva niza, niz1 = Peter, niz2 = Petra. // primerjava z memcmp(): // izpis: niz1 < niz2 ali niz1 > niz2 ali niz1 = niz2 // niza spremenjena v Petronas, Petronas // izpis: niz1 < niz2 ali niz1 > niz2 ali niz1 = niz2 24
zdruzevanje // Namen: // funkcije iz string.h // gets(), strlen(), strcpy(), strcat() // Naloga: // Vpisite 1. niz: npr. Danes // Vpisite 2. niz: npr. sije sonce. // Sestavljeni niz: Danessije sonce. 25
zdruzevanje2 // Namen: // funkcije iz string.h // printf(), gets(), strlen(), strcpy(), strNcat() // Naloga: // Vpisite 1. niz: npr. Danes // Vpisite 2. niz: npr. sije sonce. // Sestavljeni niz: Danessije sonce. 26
zdruzevanje3 // Namen: // funkcije iz string.h // printf(), gets(), strlen(), strcpy() // Naloga: // Vpisite 1. niz: npr. Danes // Vpisite 2. niz: npr. sije sonce. // Sestavljeni niz: Danessije sonce. 9.
Kazalci
1
kazalci1 // Namen: // koncept kazalca. razlikovanje med vrednostjo na lokaciji in lokacijo. // Naloga: // Kaj izpise spodnja koda? pojasnite. 2
kazalci2 // Namen: // dereferenced kazalec in naslov spremenljivke, operatorja * in & // Naloga: // Kaj izpise spodnja koda? Pojasnite. 3
kazalci3 // Namen: // dereferenced pointer, uporabljamo ga lahko tudi samo kot obicajno spremenljivko // pointer imamo, nimamo pa alocirane memorije. // izgleda, da se postavi pointer na lokacijo, ki jo lahko prepisem z int, // ni mi pa to v skladu z razumevanjem kazalcev ­ lokacija, na katero kazalec // kaze, mora biti alocirana (memset), preden jo uporabim. // mnenje: slucajno dela. // dodatek for zanke spodaj potrjuje mnenje o slucajnem delovanju, ze *p=42 // postane access violation. // Naloga: // Pojasnite delovanje spodnje kode. 4
kazalci4 // Namen: // dereferenced pointer, uporabljamo ga lahko tudi samo kot obicajno spremenljivko, // ce tam imamo alocirano memorijo. // Naloga: // Pojasnite delovanje spodnje kode. 5
kazalci5 // Namen: // operator * // Naloga: // Za spodnjo kodo najprej ugotovite, kaj se izpisuje, in nato preverite. 6
11_xrcss_2 // Namen: // Obvladanje Linkane liste. Delo s kazalci. // Naloga: // Napisite funkcijo z deklaracijo: // void insertEntry (struct ListEntry *pleDoInsert, struct ListEntry *pleAfter); // Funkcija naj v linkano listo vstavi nov element. Elementi liste so tipa: // struct ListEntry { // int iValue; // struct ListEntry *pleNext; }; // Naloga se navezuje pojme iz poglavja 11, Kazalci. // Program zacne s tremi linkanimi strukturami, izpis iValue: 100, 200, 300 // Na 3. mesto vstavimo strukturo z iValue=250. // Program konca s stirimi linkanimi strukturami, izpis iValue: 100, 200, 250, 300 7
11_xrcss_5 // Namen: // Dvojno linkana lista, koncept in implementacija. // Naloga: // Dvojno linkana lista je lista, kjer ima vsak element kazalec na element pred // in za njim. Dolocite ustrezno strukturo elementa, napisite kratek program, // ki implementira dvojno linkano listo in izpise vrednosti v elementih liste // od prvega do zadnjega in od zadnjega do prvega. 8
seznam // Namen: // Sestaviti linkano listo s sprotnim jemanjem spomina. // Naloga: // Naredite nazaj linkano listo desetih // struct list_el { // int val; // struct list_el *next; // }; // in jo izpisite. 9
seznamk // Namen: // Sestaviti linkano listo s sprotnim jemanjem spomina. // Naloga: // Naredite naprej linkano listo desetih // struct list_el { // int val; // struct list_el *next; // }; // in jo izpisite. 10
11_xrcss_8 // Namen: // Uporaba funkcij preko kazalcev. // Naloga: // Napisite funkcijo z deklaracijo // void sort3(int *piA, int *piB, int *piC); // ki sortira tri int stevila b varascajoce zaporedje. // Ne uporabite niza kot podatkovne strukture! // Z main() preverite delovanje funkcije. 11
kazfun // Namen: // kazalec na funkcijo // redko videno, generalizacija koncepta kazalca // Naloga: // deklaracije 3 funkcij: // int vsota(int x, int y) // int zmnozek(int x, int y) // int razlika(int x, int y) // definicija kazalca na funkcijo: // int (*pF) (int x, int y); // zgornje 3 funkcije klicite s klicem gornjega kazalca in preverite // uspesnost klica in delovanje funkcij 12
zamenjaj2 // Namen: // 101 of the return funkcije skozi argumente. // argumenti so adrese spremenljivk (so nespremenljivi, tako kot koncept // funkcije zahteva). lahko pa spreminjamo podatke na teh adresah. // Naloga: // Napisite funkcijo in preverite njeno delovanje: // void zamenjaj(int *a, int *b); 13
zamenjaj2static // Namen: // 101 of the return funkcije skozi argumente. // argumenti so adrese spremenljivk (so nespremenljivi, tako kot koncept // funkcije zahteva). lahko pa spreminjamo podatke na teh adresah. // Ilustracija static spremenljivke, njene inicializacije in spreminjanja. // Naloga: // Napisite funkcijo in preverite njeno delovanje: // void zamenjaj(int *a, int *b); // Ob preverjanju delovanja izpisujte sprotni stevec rabe funkcije. 14
uredi // Namen: // strukturiranje v funkcije, delo s kazalci da produktivnost. // Naloga: // Generirajte 20 znakov dolgo tabelo z nakljucnimi vrednostmi med 5 in 35 // in jo uredite. // Najenostavnejse urejanje: vsak element primerjamo z vsakim od njega naprej // in zamenjamo poziciji, ce je potrebno. 15
kopiranje // Namen // pointers and strings // ce string A[0..6], potem je A address od zacetka, je address od A[0]. // int M,N; M = *&N; DELUJE! // Naloga // niz A kopiramo v niz B: // clen po clen // pointer p izenacimo z address A[]. // clene A[] beremo kot *p+i, i od 0 do 6. // // A[i] deluje tudi kot i[A], ne tega zlorabljati, da ne bo zmede. 16
malloc // Namen: // malloc // scanf() in gets() v povezavi // Naloga: // Vpisite stevilo lokacij za malloc in vpisite niz: // obratno izpisan niz dobite nazaj. // // po mojem razumevanju deluje pomanjkljivo: na address alocirane // memorije lahko vpisem daljsi niz kot je alocirane memorije 17
pomik // Namen: // gets(), strlen(), memmove(), memset() // Naloga: // Vpisite niz, krajsi od 12 znakov: // npr. krava // Novi niz *******krava 18
primerjajnize // Namen: // isupper(), islower(), atoi() // izzivljanje pisanja int v string char[i] in obdelavi stevila tam // POMEMBNO: // int numstrcmp(char *str1, char *str2) // ISTO KOT: // int numstrcmp(char str1[], char str2[]) // umetniski namen: pisanje vnesenega stevila v char string, prenos stringa // v funkcijo, tam kompozicija char[] nazaj v int ali obdelava po individualnih char{} // Naloga: // Demo naloga. // atoi(): cifre v nizu char, atoi pobere vse do '\0' // obstoja tudi nestandardna funkcija itoa() (jo znam narediti) // http://www.cplusplus.com/reference/clibrary/cstdlib/itoa/ 19
realloc // Namen: // realloc v funkciji dinamicno povecevane dimenzije niza // Naloga: // Vnesi stevilo (0 za konec): // vnasanje .........0 // Vnesena stevila: 0......... // po vsakem vpisu stevila uporabite // stevila = (int*) realloc (stevila, m * sizeof(int)); // Opomba: // pobrano s http://www.cplusplus.com/reference/clibrary/cstdlib/realloc/ 20
11_xrcss_12 // Namen: // adrese in printf() // Naloga: // Ugotovite izpise, ki jih producira spodnja koda. Preverite ugotovitve // z izvajanjem programa. 21
qsort // Namen: // zivljenjska situacija, kjer se zaradi zahtevnosti PRODUKTIVNE uporabe C knjiznice // ne mores izogniti kazalcem. ODLICNO! // Raba funkcije qsort(), stdlib.h: // void qsort ( void * base, size_t num, size_t size, int ( * comparator ) ( const void *, const void * ) ); // http://www.cplusplus.com/reference/clibrary/cstdlib/qsort/ // qsort, stdlib.h, odlicna sortirna funkcija, skoraj NEVERJETNO! // rand() % 100 + 2 [2 .. 101] // Naloga: // Imate array 10 nakljucnih int stevil. // Sortirajte jih (kratko, jedrnato, torej s qsort() in napisite vaso primerjalno funkcijo, // katero qsort() potrebuje. 22
qsortnizi // Namen: // zivljenjska situacija, kjer se zaradi zahtevnosti PRODUKTIVNE uporabe C knjiznice // ne mores izogniti kazalcem. ODLICNO! // Raba funkcije qsort(), stdlib.h: // void qsort ( void * base, size_t num, size_t size, int ( * comparator ) ( const void *, const void * ) ); // http://www.cplusplus.com/reference/clibrary/cstdlib/qsort/ // qsort, stdlib.h, odlicna sortirna funkcija, skoraj NEVERJETNO! // Naloga: // Napisite array 6 desetmestnih nizov, npr. imen razlicnih vrst sadja. // Sortirajte jih (kratko, jedrnato, torej s qsort() in napisite vaso primerjalno funkcijo, // katero qsort() potrebuje. 23
structk // Namen: // malloc za structure // raba elementov iz struct preko pointerja na struct // Naloga: // Preglejte kodo in pojasnite detajle. 24
mergesort // Namen: // rekurzivno manjsanje tabele // primerjanje parov zmanjsanih tabel, postopno urejanje // BISTVO: // zacetni niz rekurzivno prepolavljas do posameznikov // uredis posameznike v urejene pare, urejas urejene pare ... dobis urejen niz // urejanje UREJENIH parov ­ bistvo je, in tukaj nujno, da je vsak od parov // za sestavit sam zase ZE UREJEN. // Naloga: // Opisite delovanje spodnje kode: 25
kazalci // Namen: // Pazi, to je iz skripte ­ Matjaz Zaversnik: Programski jezik C // http://zaversnik.fmf.uni­lj.si/Gradiva/C/osnove/kazalci.php // Naloga: // Pri vsaki nalogi je potrebno sestaviti eno ali vec funkcij. Vse zapisite // v isto datoteko. S funkcijo main preverite delovanje posameznih funkcij, // da bodo delovale kot na primerih. // // 1.
Napisite funkcijo, ki bo sestavila in vrnila tabelo prvih n clenov Fibonaccijevega zaporedja. // Vpisite stevilo clenov: 10 // Zaporedje: 1 1 2 3 5 8 13 21 34 55 // // 2.
Napisite funkcijo, ki iz danega niza izdela in vrne nov niz, ki bo vsak znak // prvotnega niza vseboval dvakrat zaporedoma. // Vpisite niz: racunalnistvo // Nov niz: rraaccuunnaallnniissttvvoo // // 3.
Napisite funkcijo, ki bo iz dane tabele sestavila in vrnila novo tabelo, // v kateri bodo zapisane vsote po k zaporednih elementov (tudi k je parameter). // Vpisite dolzino tabele: 7 // Vpisite 1. element: 1 // Vpisite 2. element: 3 // Vpisite 3. element: 1 // Vpisite 4. element: 2 // Vpisite 5. element: 3 // Vpisite 6. element: 1 // Vpisite 7. element: 5 // Vpisite k: 3 // Vsote: 5 6 6 6 9 // // 4.
Napisite funkcijo, ki bo iz dane tabele sestavila in vrnila novo tabelo, // v kateri bodo samo sodi elementi prvotne tabele. Najprej preštejte // koliko je sodih elementov v tabeli, nato ustvarite tabelo in vanjo prepišite vse sode elemente. // Vpisite dolzino tabele: 7 // Vpisite 1. element: 1 // Vpisite 2. element: 4 // Vpisite 3. element: 1 // Vpisite 4. element: 2 // Vpisite 5. element: 8 // Vpisite 6. element: 1 // Vpisite 7. element: 5 // Sodi elementi: 4 2 8 10.
Bitne operacije
1
bitni_operatorji // Namen: // delovanje AND, OR, XOR, >>, <<, ~ // Naloga: // unsigned char dve stevili, preverba delovanja // gornjih operatorjev, izpis rezultata 2
prireditveni_stavki // Namen: // operatorji: sestavljeni aritmeticni in logicno prireditveni // Naloga: // dve stevili, =, +=, ­=. *=, /=, %=, &=, |=, ^=, <<=, >>= 3
12_xrcss_3 // Namen: // Ugotoviti velikost spremenljivke tipa int s pomocjo binarnih operatorjev // na vasem sistemu (velikosti spremenljivk na vseh platformah niso enake). // Naloga: // Napisite funkcijo ki vrne stevilo bitov za int na // vasem sistemu: // int int_size(void) // Nasvet: ~0 rezultira v vseh bitih na 1. Z bitnim shiftom lahko ugotovite njihovo stevilo. 4
12_xrcss_6 // Namen: // Delo z bitnimi funkcijami na nivoju obvladanja. // Naloga: // Naredimo funkcijo // int bitpat_search (unsigned int Vir, unsigned int Vzorec, unsigned int n); // Funkcija naj vrne mesto bita, kjer se v Viru zacne n bitov Vzorca. Ce iskanega zaporedja ni, // funkcija vrne ­1. // Primer: // index = bitpat_search (0xe1f4, 0xF5, 3); // iscemo v 1110 0001 1111 0100 // iscemo vzorec prvih 3 bitov Z LEVE, bit 1 je LSB, od 1111 0101, torej 101 // vzorec iscemo zacensi pri MSB. torej iscemo 101, zacensi Z DESNE. // funkcija vrne stevilko 11: 101 se zacne na 11em mestu: 1110 0001 1111 0100 // Ne spekulirajte glede dolzine stevila Vir! Torej, // najprej ugotovite, koliko bitov zaseda spremenljivka Vir! 11.
Input/output
1
pisanje // Namen: // pisanje stringov v file // fopen(), fputs(), fclose() // Naloga: // Kreirajte "besedilo.txt" // vpisite: // To je prvi stavek. // To je DRUGI stavek. // zaprite file, ponovno ga odprite v mode = append, vpisite // To je tretji stavek. // zaprite file. // Z Notepad.exe preverite vsebino "besedilo.txt". 2
pisioseba // Namen: // Vpis elementarnega podatka v file // fopen(), fwrite(), fclose() // Naloga: // Vpisite ime: // Vpisite visino: // vpisano v osebe.dat ali "Datoteke ne morem odpreti." 3
berioseba // Namen: // Izpis elementarnega podatka iz datoteke. // fopen(), fread(), feof(), fclose() // Naloga: // Najprej potrebujete "osebe.dat", kar naredite z p_9_8__pisioseba. // Ce nimate, potem"Datoteke ne morem odpreti." // Sicer izpis imen in visin kot v struct oseba. Najvisji osebi pripisite, // da je najvisja. // Najenostavneje: prevrtite "osebe.dat", najdete najvecjo visine, rewind(), // sekvencno izpisujete, v pravo vrstico dodaste " najvisji". 4
filecopy // Namen: // kopiranje binarne datoteke // vpisovanje in uporaba parametrov v ukazni vrstici // fopen(), feof(), getc(), perror(), clearerr(), fclose() // Naloga: // c:\Project1 osebe.dat osebe_kopija.dat // prva datoteka je prepisana v drugo preko getc in putc, torej po vsakih 8 bitov. // ce ne deluje: // Uporaba: ProgramName <izvor> <cilj>\n // Izvorne datoteke ne morem odpreti. // Ciljne datoteke ne morem ustvariti. // Napaka pri branju. // Napaka pri pisanju. 5
filecopyB // Namen: // kopiranje binarne datoteke po blokih // vpisovanje in uporaba parametrov v ukazni vrstici // fopen(), fread(), fwrite(), clearerr(), fclose() // Naloga: // c:\Project1 osebe.dat osebe_kopija.dat // prva datoteka je prepisana v drugo preko fread in fwrite, nastavljeno na bloke po 1024 bytes // ce ne deluje: // Uporaba: ProgramName <izvor> <cilj>\n // Izvorne datoteke ne morem odpreti. // Ciljne datoteke ne morem ustvariti. // Napaka pri branju. // Napaka pri pisanju. 6
16_xrcss_3 // Namen: // ASCII char table, printf(), scanf(), fprintf(), fopen(). getc(), putc(), fclose() // Naloga: // Napisite program, ki bo skopiral prvo datoteko v drugo in pri tem vse // male crke spremenil v velike crke. 7
filesize // Namen: // velikost datoteke // gets(), fopen(), feof(), fgetc(), fclose() // Naloga: // Ugotovite velikost datoteke na najbolj osnoven nacin ­ // berite po en znak do EOF in izpisite stevilo prebranih znakov. // Vpisite ime datoteke, za katero ugotavljamo velikost: // Dolzina datoteke je X bytes. // ali, ce tezava: Napaka pri odpiranju datoteke. 8
fseek // Namen: // fopen(), p. 475, fputs(), p. 475, fseek(), p. 476, fclose(), p. 474 // Naloga: // Odpremo datoteko, iscemo iskani string v tej datoteki, // na ustrezno mesto v datoteki zapisemo nekaj drugega, zapremo datoteko 9
zdruziX // branje stringov iz datotek, in pisanje stringov v datoteke // funkcije: fopen(), fgets(), fprintf(), fclose() // Naloga: // Na roke napisite DatA.txt, DatB.txt. Program naj v DatSest.txt // alternirajoce prepisuje vrsto iz prve in vrsto iz druge datoteke. // Ko vrst v krajsi datoteki zmanjka, vpise samo se preostale vrstice iz daljse datoteke. // Koda spodaj skoraj izvaja, kar je potrebno. Uredite jo do konca. 10
zdruzi // Namen: // branje stringov iz datotek, in pisanje stringov v datoteke // funkcije: fopen(), fgets(), fprintf(), fclose() // Naloga: // Na roke napisite DatA.txt, DatB.txt. Program naj v DatSest.txt // alternirajoce prepisuje vrsto iz prve in vrsto iz druge datoteke. // Ko vrst v krajsi datoteki zmanjka, jih nadomesca s praznimi vrstami. 11
stevila_razdeli // Namen: // fopen(), fscanf(), fprintf(), fclose() // Naloga: // v "stevila_vsa.txt" imamo zapisanih nekaj naravnih števil. Napisite funkcijo, // ki bo ta števila prepisala v dve datoteki: // "stevila_liha.txt", in // "stevila_soda.txt". // Vsako število naj bo zapisano v svojo vrstico. Funkcija naj za parametre dobi // imena vseh treh datotek, vrne pa naj uspešnost (0 pomeni, da je bilo vse v redu, // vrednosti 1, 2 ali 3 pa povedo, pri kateri datoteki smo naleteli na težave: // int sodiLihi(const char *FileIn, const char *FileLiha, const char *FileSoda); // S funkcijo main() preverite delovanje funkcije. 12
stetje_vrstic // Namen: // int VrsticJe(char *FileName); // fopen(), fgets(), fgetc(), fclose(); // Naloga: // Napisite funkcijo, ki prešteje, koliko je vrstic v vhodni datoteki. // Predpostavite da je vsaka vrstica krajša od 100 znakov. // Kako bi nalogo rešili brez omejitve dolžine vrstice? Funkcija naj za // parameter dobi ime vhodne datoteke, vrne pa naj število vrstic oziroma ­1, // ce datoteke ni mozno odpreti. // S programom main() preverite delovanje funkcije. // Deklaracija: int VrsticJe(char *FileName); 13
rewind // Namen: // fopen(), fputc(), rewind(), fread(), fclose() // Naloga: // V "abeceda.txt" vpisite 26 znakov velike abecede, potem to preberite in // izpisite. 14
meritev // Namen: // fopen(), fscanf(), fclose() // Naloga: // "meritve.txt" predstavljajo log meritve. V vsaki vrstici je zapisan najprej // datum meritve v obliki dd.mm.yyyy. Sledi presledek, sledi realno število. // Napisite funkcijo, ki ugotovi, kdaj je bila izmerjena vrednost najmanjša. // Funkcija naj za parametre dobi ime vhodne datoteke in tri kazalce na cela števila, // preko katerih vrne datum najmanjše meritve. // Return vrednost naj bo uspešnost: // 0: OK, // 1: datoteke ni moc odpreti, // 2: datoteka je prazna in najmanjše vrednosti ni mozno najti. // S programom main() preverite delovanje funkcije. // Deklaracija: int DatumMinimuma(char *imeDat, int *dan, int *mesec, int *leto);