| 153 |   |  | 
                      
                        | 154 |   |  | 
                      
                      
                        |   | 153 | = Vaje programiranja v jeziku Python = | 
                      
                        |   | 154 |  | 
                      
                        |   | 155 | Znanje programskega jezika Python najlažje pridobimo z vajo. Namen domačih nalog | 
                      
                        |   | 156 | predstavljenih na tej strani je predvsem utrditi določene programske konstrukte, | 
                      
                        |   | 157 | ki se lahko rešijo v krajših programih, katere pravilnost delovanja ni težko | 
                      
                        |   | 158 | preveriti. Naloge se izdelujejo z orodji (Tortoise, Idle, PythonOcc), ki so predvidene za izdelavo projekta. | 
                      
                        |   | 159 | To pomeni, da je vsako vsako vajo, ki jo izdelujemo najprej preveriti na lokalnem | 
                      
                        |   | 160 | računalniku. Ko naloga št.??? deluje, jo shranimo na strežnik z Tortoise (Add, Checkin) ter preverimo  | 
                      
                        |   | 161 | njeno delovanje. | 
                      
                        |   | 162 |  | 
                      
                        |   | 163 | = Vprašanja za utrjevanje = | 
                      
                        |   | 164 |  1. Zakaj je potrebno napisati vrstico {{{import szs}}} | 
                      
                        |   | 165 |  2. Kako uporabljamo komentarje? | 
                      
                        |   | 166 |  3. Zakaj je zamikanje stavkov pomembno? Ali interpreter Pythona upošteva zamikanje? | 
                      
                        |   | 167 |  4. Koliko decimalk hrani tip {{{integer}}} in {{{float}}}? | 
                      
                        |   | 168 |  5. Kakšna je razlika pri prireditvi konstante spremenljivkama '''c''' in '''d''' | 
                      
                        |   | 169 | {{{ | 
                      
                        |   | 170 | #!python | 
                      
                        |   | 171 |    c = 3/2; | 
                      
                        |   | 172 |    d = 3.0/2; | 
                      
                        |   | 173 | }}}   | 
                      
                        |   | 174 |  6. Kaj je funkcija dvopičja v kontrolnem stavku? Naštej kje vse ga je potrebno uporabiti. | 
                      
                        |   | 175 |  7. Koliko je numerična vrednost naslednjega izraza | 
                      
                        |   | 176 | {{{ | 
                      
                        |   | 177 | #!python | 
                      
                        |   | 178 |    i = 7 / 3; | 
                      
                        |   | 179 | }}} | 
                      
                        |   | 180 |  8. Pod katerimi pogoji naslednja koda izpiše '''voda'''? Kako bi jasneje napisali  | 
                      
                        |   | 181 | napisane pogojne stavke z uporabo zavitih oklepajev in primernejšega zamikanja? | 
                      
                        |   | 182 | {{{ | 
                      
                        |   | 183 | #!python | 
                      
                        |   | 184 |   if(temp < 0): | 
                      
                        |   | 185 |     print "led" | 
                      
                        |   | 186 |   else if (temp < 100): | 
                      
                        |   | 187 |     print  "voda" | 
                      
                        |   | 188 |   else: | 
                      
                        |   | 189 |     print "para") | 
                      
                        |   | 190 | }}}  | 
                      
                        |   | 191 |  9. Kaj izpiše naslednja koda? | 
                      
                        |   | 192 | {{{ | 
                      
                        |   | 193 | #!python | 
                      
                        |   | 194 |   x = 3; | 
                      
                        |   | 195 |   if(x): | 
                      
                        |   | 196 |      print "da" | 
                      
                        |   | 197 |   else: | 
                      
                        |   | 198 |      print "ne" | 
                      
                        |   | 199 | }}} | 
                      
                        |   | 200 |  10. Kaj bo izpisala naslednja koda? | 
                      
                        |   | 201 | {{{ | 
                      
                        |   | 202 | #!python | 
                      
                        |   | 203 |   int i; | 
                      
                        |   | 204 |   for i in range(3): | 
                      
                        |   | 205 |     print "a" | 
                      
                        |   | 206 |   print "b" | 
                      
                        |   | 207 |  | 
                      
                        |   | 208 |   print "c" | 
                      
                        |   | 209 | }}} | 
                      
                        |   | 210 |  11. Koliko elementov vsebuje polje oz. vektor '''a'''? Kateri je prvi element? Kateri je zadnji? | 
                      
                        |   | 211 | {{{ | 
                      
                        |   | 212 | #!python | 
                      
                        |   | 213 |   a = [1,2,3,4,5]; | 
                      
                        |   | 214 | }}}  | 
                      
                        |   | 215 |  12. Kaj je narobe v naslednjem izvlečku kode? | 
                      
                        |   | 216 | {{{ | 
                      
                        |   | 217 | #!python | 
                      
                        |   | 218 |   a = []; | 
                      
                        |   | 219 |   for i in range(5): | 
                      
                        |   | 220 |     a[i] = 0; | 
                      
                        |   | 221 | }}} | 
                      
                        |   | 222 |  13. Kateri so štirje pomembni deli funkcije? Katere tri mora klicoči program poznati? | 
                      
                        |   | 223 |  | 
                      
                        |   | 224 |  | 
                      
                        |   | 225 |  | 
                      
                        |   | 226 |  | 
                      
                        |   | 227 |  | 
                      
                        |   | 228 | /// TODO | 
                      
                        |   | 229 |  | 
                      
                        |   | 230 |  1. Kakšna je razlika med ''prefix'' in ''postfix'' operatorjem ++. Kakšna je razlika med naslednjima izrazoma: | 
                      
                        |   | 231 | {{{ | 
                      
                        |   | 232 | #!c | 
                      
                        |   | 233 |   r = i++; | 
                      
                        |   | 234 |   r = ++i; | 
                      
                        |   | 235 | }}} | 
                      
                        |   | 236 |  1. Kaj je narobe z naslednjim predprocesorskim izrazom? | 
                      
                        |   | 237 | {{{ | 
                      
                        |   | 238 | #!c | 
                      
                        |   | 239 | #define N 10; | 
                      
                        |   | 240 | }}} | 
                      
                        |   | 241 |  1. Če smo na primer definirali makro | 
                      
                        |   | 242 | {{{ | 
                      
                        |   | 243 | #!rst | 
                      
                        |   | 244 | .. code-block:: c | 
                      
                        |   | 245 |  | 
                      
                        |   | 246 |  #define SQR(x) x*x  | 
                      
                        |   | 247 |   | 
                      
                        |   | 248 | Zakaj nam potem izraz | 
                      
                        |   | 249 |  | 
                      
                        |   | 250 | .. code-block:: c | 
                      
                        |   | 251 |  | 
                      
                        |   | 252 |  y = 1/SQR(x); | 
                      
                        |   | 253 |  | 
                      
                        |   | 254 | ne deluje pravilno? Kako bi morali pravilno napisati makro SQR(x), da bi delal tudi za izraze | 
                      
                        |   | 255 |  | 
                      
                        |   | 256 | .. code-block:: c | 
                      
                        |   | 257 |  | 
                      
                        |   | 258 |  y = 1/SQR(1-x); | 
                      
                        |   | 259 |  | 
                      
                        |   | 260 | }}} | 
                      
                        |   | 261 |  1. Kakšna je razlika v uporabnosti med '''i''' in '''J''', ki sta napisana kot | 
                      
                        |   | 262 | {{{ | 
                      
                        |   | 263 | #!rst | 
                      
                        |   | 264 | .. code-block:: c | 
                      
                        |   | 265 |  | 
                      
                        |   | 266 |   int i = 10; | 
                      
                        |   | 267 |   #define J 10 | 
                      
                        |   | 268 |  | 
                      
                        |   | 269 | Napotek: Poskusi napisati ``J = 2`` ali ``int a[i]``. | 
                      
                        |   | 270 |  | 
                      
                        |   | 271 | }}} | 
                      
                        |   | 272 |  1. Zakaj je potrebno v {{{scanf()}}} argumente za formatnim stavkom pisati z &, pri {{{printf()}}} pa tega ne smemo? | 
                      
                        |   | 273 |  1. Koliko spomina klic  | 
                      
                        |   | 274 | {{{ | 
                      
                        |   | 275 | #!rst | 
                      
                        |   | 276 | .. code-block:: c | 
                      
                        |   | 277 |  | 
                      
                        |   | 278 |   malloc(10) | 
                      
                        |   | 279 |  | 
                      
                        |   | 280 | alocira?  | 
                      
                        |   | 281 |  | 
                      
                        |   | 282 | Kaj moramo napisati če želimo alocirati spomin za 10 spremenljivk tipa float? | 
                      
                        |   | 283 | }}} | 
                      
                        |   | 284 |  1. Kaj mislimo z ''enakostjo med polji in kazalci'' v C-ju? | 
                      
                        |   | 285 |  1. Če je {{{p}}} kazalec, kaj potem pomeni {{{p[i]}}}? | 
                      
                        |   | 286 |  1. Kako odpiramo datoteko za branje podatkov iz nje? Kaj se spremeni, če bi datoteko želeli odpreti za pisanje? | 
                      
                        |   | 287 |  | 
                      
                        |   | 288 |  | 
                      
                        |   | 289 | = Uporaba zank in izpis = | 
                      
                        |   | 290 | {{{ | 
                      
                        |   | 291 | #!comment | 
                      
                        |   | 292 | http://www.eskimo.com/~scs/cclass/asgn.beg/PS1.html | 
                      
                        |   | 293 | }}} | 
                      
                        |   | 294 |  | 
                      
                        |   | 295 |  | 
                      
                        |   | 296 | == vaja1 == | 
                      
                        |   | 297 | Napiši program, ki zahteva vnos dveh celih številk in nato izpiše njihovo vsoto. | 
                      
                        |   | 298 |  | 
                      
                        |   | 299 | == vaja2 == | 
                      
                        |   | 300 | Gaussovo kvadratura naj vpraša za meji integriranja funkcije f(x) = 2x^4^- x^3^ +1 | 
                      
                        |   | 301 | in rezultat izpiše na zaslon. | 
                      
                        |   | 302 |  | 
                      
                        |   | 303 |  | 
                      
                        |   | 304 | == vaja3 == | 
                      
                        |   | 305 | Izdelaj program ki izpiše naslednje zanke: | 
                      
                        |   | 306 | {{{ | 
                      
                        |   | 307 | #!c | 
                      
                        |   | 308 | for(i = 0; i < 10; i = i + 2) | 
                      
                        |   | 309 |         printf("%d\n", i); | 
                      
                        |   | 310 |  | 
                      
                        |   | 311 | for(i = 100; i >= 0; i = i - 7) | 
                      
                        |   | 312 |         printf("%d\n", i); | 
                      
                        |   | 313 |  | 
                      
                        |   | 314 | for(i = 1; i <= 10; i = i + 1) | 
                      
                        |   | 315 |         printf("%d\n", i); | 
                      
                        |   | 316 |  | 
                      
                        |   | 317 | for(i = 2; i < 100; i = i * 2) | 
                      
                        |   | 318 |         printf("%d\n", i); | 
                      
                        |   | 319 | }}} | 
                      
                        |   | 320 | Razjasni si, kako te zanke delujejo in program popravi tako, da | 
                      
                        |   | 321 | bodo v zanki uporabljeni operatorji +=, -=, *= | 
                      
                        |   | 322 |  | 
                      
                        |   | 323 | == vaja4 == | 
                      
                        |   | 324 | Napiši program ki izpiše ta trikotnik: | 
                      
                        |   | 325 | {{{ | 
                      
                        |   | 326 |         * | 
                      
                        |   | 327 |         ** | 
                      
                        |   | 328 |         *** | 
                      
                        |   | 329 |         **** | 
                      
                        |   | 330 |         ***** | 
                      
                        |   | 331 |         ****** | 
                      
                        |   | 332 |         ******* | 
                      
                        |   | 333 |         ******** | 
                      
                        |   | 334 |         ********* | 
                      
                        |   | 335 |         ********** | 
                      
                        |   | 336 | }}}     | 
                      
                        |   | 337 | Ne uporabi desetih printf() ampak uporabi zanko. | 
                      
                        |   | 338 | {{{ | 
                      
                        |   | 339 | #!c | 
                      
                        |   | 340 | for(i = 0; i < 10; i = i + 1) | 
                      
                        |   | 341 |  { | 
                      
                        |   | 342 |   /* Več stavkov */ | 
                      
                        |   | 343 |   /* gre lahko tukaj */ | 
                      
                        |   | 344 |  } | 
                      
                        |   | 345 | }}} | 
                      
                        |   | 346 |  | 
                      
                        |   | 347 | == vaja5 == | 
                      
                        |   | 348 | Izpiši v zanki cela števila od 1 do 10 in njihove kvadrate. | 
                      
                        |   | 349 | {{{ | 
                      
                        |   | 350 |         1       1 | 
                      
                        |   | 351 |         2       4 | 
                      
                        |   | 352 |         3       9 | 
                      
                        |   | 353 |         ... | 
                      
                        |   | 354 |         10      100 | 
                      
                        |   | 355 | }}} | 
                      
                        |   | 356 |  | 
                      
                        |   | 357 | == vaja6 == | 
                      
                        |   | 358 | Stavek '''for''' je prav zaprav, okrajšava za stavek '''while'''. | 
                      
                        |   | 359 |  | 
                      
                        |   | 360 | Predelaj program, ki izpiše naslednjo zanko: | 
                      
                        |   | 361 | {{{ | 
                      
                        |   | 362 | #!c | 
                      
                        |   | 363 |  for(i = 0; i < 10; i = i + 1) | 
                      
                        |   | 364 |    printf("i je %d\n", i); | 
                      
                        |   | 365 | }}} | 
                      
                        |   | 366 | z uporabo stavka '''while''', ki ima naslednjo obliko | 
                      
                        |   | 367 | {{{ | 
                      
                        |   | 368 | #!c | 
                      
                        |   | 369 |   while(pogoj) | 
                      
                        |   | 370 |   { | 
                      
                        |   | 371 |     /* vpiši stavek za povečanje števca in izpis */  | 
                      
                        |   | 372 |   } | 
                      
                        |   | 373 | }}} | 
                      
                        |   | 374 | Napotek: V primeru da se nam program ''obesi'' v neskončni zanki, | 
                      
                        |   | 375 | ga prekinemo s pritiskom na crtl-C | 
                      
                        |   | 376 |  | 
                      
                        |   | 377 |  | 
                      
                        |   | 378 | == vaja7 == | 
                      
                        |   | 379 | Pretipkaj in poženi naslednji program: | 
                      
                        |   | 380 | {{{ | 
                      
                        |   | 381 | #!c | 
                      
                        |   | 382 | #include <stdio.h> | 
                      
                        |   | 383 |  | 
                      
                        |   | 384 | int main() | 
                      
                        |   | 385 | { | 
                      
                        |   | 386 |   int i; | 
                      
                        |   | 387 |  | 
                      
                        |   | 388 |   printf("stavek 1\n"); | 
                      
                        |   | 389 |   printf("stavek 2\n"); | 
                      
                        |   | 390 |   for(i = 0; i < 10; i = i + 1) | 
                      
                        |   | 391 |    { | 
                      
                        |   | 392 |         printf("stavek 3\n"); | 
                      
                        |   | 393 |         printf("stavek 4\n"); | 
                      
                        |   | 394 |    } | 
                      
                        |   | 395 |   printf("stavek 5\n"); | 
                      
                        |   | 396 |    | 
                      
                        |   | 397 |   return 0; | 
                      
                        |   | 398 | } | 
                      
                        |   | 399 | }}} | 
                      
                        |   | 400 | Program ne naredi nič posebnega. Z njim želimo le pojasniti vpliv | 
                      
                        |   | 401 | zavitih oklepajev v zanki in dobiti željen ''potek programa''.  | 
                      
                        |   | 402 |  | 
                      
                        |   | 403 |  | 
                      
                        |   | 404 | == vaja8 == | 
                      
                        |   | 405 | Pretipkaj in poženi naslednji program: | 
                      
                        |   | 406 | {{{ | 
                      
                        |   | 407 | #!c | 
                      
                        |   | 408 | #include <stdio.h> | 
                      
                        |   | 409 |  | 
                      
                        |   | 410 | int main() | 
                      
                        |   | 411 | { | 
                      
                        |   | 412 |  int i, j; | 
                      
                        |   | 413 |  | 
                      
                        |   | 414 |  printf("začetek programa\n"); | 
                      
                        |   | 415 |  | 
                      
                        |   | 416 |  for(i = 0; i < 3; ++i) | 
                      
                        |   | 417 |   { | 
                      
                        |   | 418 |         printf("i je %d\n", i); | 
                      
                        |   | 419 |         for(j = 0; j < 5; j++) | 
                      
                        |   | 420 |                 printf("i je %d, j je %d\n", i, j); | 
                      
                        |   | 421 |         printf("konec v zanki i = %d\n", i); | 
                      
                        |   | 422 |   } | 
                      
                        |   | 423 |  | 
                      
                        |   | 424 |  printf("konec programa\n"); | 
                      
                        |   | 425 |  | 
                      
                        |   | 426 |  return 0; | 
                      
                        |   | 427 | } | 
                      
                        |   | 428 | }}} | 
                      
                        |   | 429 | Tudi ta program ne naredi kaj dosti koristnega. Želi pokazati, kako zanke | 
                      
                        |   | 430 | delujejo in kako jih ''gnezdimo''. V vaji 4 je potrebno uporabiti prikazani | 
                      
                        |   | 431 | način dvojne zanke. | 
                      
                        |   | 432 |  | 
                      
                        |   | 433 | == vaja9 == | 
                      
                        |   | 434 | Program naj prebere štiri cele številke in izpiše povprečno vrednost kot realno številko. | 
                      
                        |   | 435 |  | 
                      
                        |   | 436 | == vaja10 == | 
                      
                        |   | 437 | Program naj prebere vrednost x, izračuna kvadrat prebranega števila (x^2^) in  ga izpiše na zaslon. | 
                      
                        |   | 438 | Izdelaj podprogram sqr(x). | 
                      
                        |   | 439 |   | 
                      
                        |   | 440 | == vaja11 == | 
                      
                        |   | 441 | Program naj prebere vrednost x in n, kot celi števili. Izdelaj podprogram power(x, n), ki izračuna n to potenco  | 
                      
                        |   | 442 | števila x in jo izpiše na zaslon. | 
                      
                        |   | 443 |  | 
                      
                        |   | 444 | = Pogojni stavek in zahtevnejše zanke = | 
                      
                        |   | 445 |  | 
                      
                        |   | 446 | == vaja20 == | 
                      
                        |   | 447 | Napiši program, ki z zanko in pogojnim stavkom ugotovi, koliko števil od 1 do 10 je večjih od 3 in seveda | 
                      
                        |   | 448 | izpiše rezultat 7. | 
                      
                        |   | 449 |  | 
                      
                        |   | 450 | == vaja21 == | 
                      
                        |   | 451 | Program naj poleg številk od 1 do 20 izpiše še ali je liha ali soda v obliki | 
                      
                        |   | 452 | {{{ | 
                      
                        |   | 453 | #!rst | 
                      
                        |   | 454 | .. code-block:: c | 
                      
                        |   | 455 |  | 
                      
                        |   | 456 |  1 je liha | 
                      
                        |   | 457 |  2 je soda | 
                      
                        |   | 458 |  3 je liha | 
                      
                        |   | 459 |  ... | 
                      
                        |   | 460 |  | 
                      
                        |   | 461 | Napotek: Uporabi operator ``%`` | 
                      
                        |   | 462 | }}} | 
                      
                        |   | 463 |  | 
                      
                        |   | 464 | == vaja22 == | 
                      
                        |   | 465 | Izdelaj program, ki izpiše v katero smer se je 2D točka največ premaknila, glede na | 
                      
                        |   | 466 | koordinatno izhodišče. Možni odgovori so: | 
                      
                        |   | 467 |  - levo | 
                      
                        |   | 468 |  - desno | 
                      
                        |   | 469 |  - gor | 
                      
                        |   | 470 |  - dol | 
                      
                        |   | 471 | Za prebrano točko 2 1 bo program odgovoril ''desno''. | 
                      
                        |   | 472 |  | 
                      
                        |   | 473 | == vaja23 == | 
                      
                        |   | 474 | Tako kot v vaji 22 naj dodatno še izpiše v kater smer se je premaknila. S tem da  | 
                      
                        |   | 475 | se najprej izpiše večji pomik in nato manjši. Za prebrano točko 2 1 bo program odgovoril {{{desno gor}}}. | 
                      
                        |   | 476 |  | 
                      
                        |   | 477 | == vaja24 == | 
                      
                        |   | 478 | Napiši program, ki izpiše prvih 7 pozitivnih števil in njihovo faktorielo (fakulteto). (Faktoriela 1 je 1,  | 
                      
                        |   | 479 | faktoriela 2 je 1*2=2, faktoriela 3 je 1 * 2 * 3 = 6, faktoriela 4 je 1 * 2 * 3 * 4 = 24, itd.) | 
                      
                        |   | 480 |  | 
                      
                        |   | 481 | == vaja25 == | 
                      
                        |   | 482 | Program naj izračuna prvih 30 [http://sl.wikipedia.org/wiki/Fibonaccijevo_%C5%A1tevilo Fibonaccijevih števil]. | 
                      
                        |   | 483 | Vsaka Fibonaccijeva številka je vsota prejšnjih dveh števil F(n) = F(n-1) + F(n-2), F(0) = 1, F(1) = 1. | 
                      
                        |   | 484 | Izpis naj bo v obliki: | 
                      
                        |   | 485 | {{{ | 
                      
                        |   | 486 |  1 + 1 = 2 | 
                      
                        |   | 487 |  1 + 2 = 3 | 
                      
                        |   | 488 |  2 + 3 = 5 | 
                      
                        |   | 489 |  3 + 5 = 8 | 
                      
                        |   | 490 |  5 + 8 = 13 | 
                      
                        |   | 491 | ... | 
                      
                        |   | 492 | }}} | 
                      
                        |   | 493 |  | 
                      
                        |   | 494 | == vaja26 == | 
                      
                        |   | 495 | Napiši program ji za podano število izpiše {{{je praštevilo}}} ali {{{ni praštevilo}}}.  | 
                      
                        |   | 496 | [http://sl.wikipedia.org/wiki/Pra%C5%A1tevilo  Práštevílo] je naravno število n > 1, če ima natanko dva pozitivna delitelja (faktorja), število 1 in samega sebe kot edini prafaktor.  | 
                      
                        |   | 497 |  | 
                      
                        |   | 498 | == vaja27 == | 
                      
                        |   | 499 | Pohitri {{{vaja26}}} z dejstvom, da razen 2 nobeno sodo število ni praštevilo. Glej {{{vaja21}}}. | 
                      
                        |   | 500 |  | 
                      
                        |   | 501 | == vaja28 == | 
                      
                        |   | 502 | Napiši program, ki tabelira poštevanko od 1 do 10, tako da izpiše vse skupaj v 10 vrsticah v | 
                      
                        |   | 503 | obliki: | 
                      
                        |   | 504 | {{{ | 
                      
                        |   | 505 | 1*1=1 1*2=2 1*3=3 | 
                      
                        |   | 506 | ... | 
                      
                        |   | 507 | 10*1=1 10*2=20 ... | 
                      
                        |   | 508 | }}} | 
                      
                        |   | 509 |  | 
                      
                        |   | 510 | == vaja29 == | 
                      
                        |   | 511 | Za dan vektor {{{B[7]}}} uredi števila po velikosti od najmanjšega do največjega in jih zapiši v vekotor v | 
                      
                        |   | 512 | naslednji obliki -> {{{B[min]...B[max]}}}. S pomočjo for zanke izpiši vrednosti urejenega vektorja {{{B}}}  | 
                      
                        |   | 513 | na zaslon po vrsticah od najmanjšega do največjega. | 
                      
                        |   | 514 | {{{ | 
                      
                        |   | 515 |   float B[7] = {3.3, -23.2, -4.5, 56.0, 45.5, 69.9, 40.5}; | 
                      
                        |   | 516 | }}} | 
                      
                        |   | 517 |  | 
                      
                        |   | 518 | == vaja30 == | 
                      
                        |   | 519 | Za matriko {{{A[25]}}} podano v vaja46 določi mesto maksimalnega števila in vrednost elementa izpiši na zaslon. | 
                      
                        |   | 520 |  | 
                      
                        |   | 521 | == vaja31 == | 
                      
                        |   | 522 | Na zaslon izpiši [http://en.wikipedia.org/wiki/Pascal's_triangle Pascal-ov trikotnik] ([http://sl.wikipedia.org/wiki/Pascalov_trikotnik Pascal's triangle]) za 8 vrstic v spodaj prikazani obliki. | 
                      
                        |   | 523 |  | 
                      
                        |   | 524 | 1 | 
                      
                        |   | 525 |  | 
                      
                        |   | 526 | 1 1 | 
                      
                        |   | 527 |  | 
                      
                        |   | 528 | 1 2 1 | 
                      
                        |   | 529 |  | 
                      
                        |   | 530 | 1 3 3 1 | 
                      
                        |   | 531 |  | 
                      
                        |   | 532 | 1 4 6 4 1 | 
                      
                        |   | 533 |  | 
                      
                        |   | 534 | 1 5 10 10 5 1 | 
                      
                        |   | 535 |  | 
                      
                        |   | 536 | 1 6 15 20 15 6 1 | 
                      
                        |   | 537 |  | 
                      
                        |   | 538 | 1 7 21 35 35 21 7 1 | 
                      
                        |   | 539 |  | 
                      
                        |   | 540 |  | 
                      
                        |   | 541 | = Nizi, vektorji, matrike = | 
                      
                        |   | 542 |  | 
                      
                        |   | 543 | == vaja40 == | 
                      
                        |   | 544 | Program iz vaje 28 priredi tako, da bo se zmnožek najprej predizračunal v polje | 
                      
                        |   | 545 | {{{ | 
                      
                        |   | 546 | #!rst | 
                      
                        |   | 547 |  | 
                      
                        |   | 548 | .. code-block:: c | 
                      
                        |   | 549 |  | 
                      
                        |   | 550 |   int a[100]; | 
                      
                        |   | 551 |  | 
                      
                        |   | 552 | in nato naj program vpraša za dve števili, ter izpiše rezultat, ki ga vzame iz polja ``a[]``. | 
                      
                        |   | 553 | }}} | 
                      
                        |   | 554 |  | 
                      
                        |   | 555 | == vaja41 == | 
                      
                        |   | 556 | Napiši program ki bo v polje števil nadomesitil z njihovnimi kvadrati. Program naj vpraša | 
                      
                        |   | 557 | kateri indeks iz polja želimo in naj izpiše vrednost v polju. S stavkom if mora | 
                      
                        |   | 558 | tudi kontrolirati meje indeksov.  | 
                      
                        |   | 559 | {{{ | 
                      
                        |   | 560 | #!c | 
                      
                        |   | 561 |   int a[] = {1, 2, 9, 33, 22, 11, 3, 4, 3, 55,  | 
                      
                        |   | 562 |              66, 33, 22, 22, 33, 54, 5, 6, 7,  | 
                      
                        |   | 563 |              8, 223, 34}; | 
                      
                        |   | 564 | }}} | 
                      
                        |   | 565 |  | 
                      
                        |   | 566 |  | 
                      
                        |   | 567 | == vaja42 == | 
                      
                        |   | 568 | Za podano kvadratno matriko {{{a[16]}}} in vektor {{{x[4]}}}  | 
                      
                        |   | 569 | {{{ | 
                      
                        |   | 570 | #!rst | 
                      
                        |   | 571 | .. code-block:: c | 
                      
                        |   | 572 |  | 
                      
                        |   | 573 |   float a[16] = {1, 2, 3, 4,  | 
                      
                        |   | 574 |                  0, 1, 2, 3, | 
                      
                        |   | 575 |                  2, 3, 4, 5, | 
                      
                        |   | 576 |                  3, 2, 2, 1}; | 
                      
                        |   | 577 |   float x[4], b[4]; | 
                      
                        |   | 578 |  | 
                      
                        |   | 579 | napiši program, ki prebere štiri vrednosti in izpiše zmnožek matrike  | 
                      
                        |   | 580 | in vektorja s stavkom | 
                      
                        |   | 581 |  | 
                      
                        |   | 582 | .. code-block:: c | 
                      
                        |   | 583 |  | 
                      
                        |   | 584 |   printf("%.1f %.1f %.1f %.1f\n", b[0], b[1], b[2], b[3]); | 
                      
                        |   | 585 |  | 
                      
                        |   | 586 | }}} | 
                      
                        |   | 587 |  | 
                      
                        |   | 588 |  | 
                      
                        |   | 589 | == vaja43 == | 
                      
                        |   | 590 | Program naj prebere datoteko. Prvo število je n, drugo število je št. delitev div, nato pa | 
                      
                        |   | 591 | prva dva stolpca sta x in y točke p0, druga dva stolpca sta (x1, y1) točke p1, | 
                      
                        |   | 592 | ter zadnji stolpec je pretok q. | 
                      
                        |   | 593 | {{{ | 
                      
                        |   | 594 | 8 1 | 
                      
                        |   | 595 | 00 00 06 00 0 | 
                      
                        |   | 596 | 06 00 14 00 -1 | 
                      
                        |   | 597 | 14 00 20 00 0 | 
                      
                        |   | 598 | 20 00 20 10 0 | 
                      
                        |   | 599 | 20 10 14 10 0 | 
                      
                        |   | 600 | 14 10 06 10 1 | 
                      
                        |   | 601 | 06 10 00 10 0 | 
                      
                        |   | 602 | 00 10 00 00 0 | 
                      
                        |   | 603 | }}} | 
                      
                        |   | 604 |  | 
                      
                        |   | 605 | Datoteko preberite v spremenljivke | 
                      
                        |   | 606 | {{{ | 
                      
                        |   | 607 | #!c | 
                      
                        |   | 608 | #define MAXN 100 | 
                      
                        |   | 609 | float p0[MAXN*2], p1[MAXN*2], q[MAXN]; | 
                      
                        |   | 610 | int n, div; | 
                      
                        |   | 611 | }}} | 
                      
                        |   | 612 | in vsako vrstico v zanki izpišite z naslednjim formatnim stavkom: | 
                      
                        |   | 613 |  | 
                      
                        |   | 614 | {{{ | 
                      
                        |   | 615 | #!c | 
                      
                        |   | 616 |    printf("%4.1f %4.1f %4.1f %4.1f %4.1f\n", ... | 
                      
                        |   | 617 | }}} | 
                      
                        |   | 618 | prve in druge točke elementa ter q. | 
                      
                        |   | 619 |  | 
                      
                        |   | 620 | == vaja44 ==  | 
                      
                        |   | 621 | Za podano kvadratno matriko {{{A[]}}} zmanjšaj diagonalne elemente za vrednost 1 in  | 
                      
                        |   | 622 | spremenjene diagonalne elemente matrike {{{A}}} s pomočjo for zanke izpiši na zaslon .  | 
                      
                        |   | 623 | {{{  | 
                      
                        |   | 624 | #!c | 
                      
                        |   | 625 | float A[25] =   {3, 5, 90, 2 ,1,  | 
                      
                        |   | 626 |                  1, 71, 59, 5, 5,  | 
                      
                        |   | 627 |                  1, 2, 3, 54, 2,  | 
                      
                        |   | 628 |                  12, 56, 32, 11, 1,  | 
                      
                        |   | 629 |                  34, 56, 78, 45, 12 | 
                      
                        |   | 630 |                  };  | 
                      
                        |   | 631 | }}}  | 
                      
                        |   | 632 | == vaja45 == | 
                      
                        |   | 633 | Polje {{{a[]}}} iz vaje 41 prepišite v matriko {{{float b[]}}} | 
                      
                        |   | 634 | velikost 8x3. S tem sa so elementi, ki manjkajo postavljeni na 0. | 
                      
                        |   | 635 | Vrstice izpišite na eno decimalko natančno. | 
                      
                        |   | 636 |  | 
                      
                        |   | 637 | == vaja46 == | 
                      
                        |   | 638 | Za podano kvadratno matriko {{{A[25]}}} zmanjšaj diagonalne elemente za vrednost 1.1, prepiši  | 
                      
                        |   | 639 | enodimenzionalno polje A v dvodimenzionalno polje B, ki ga računamo kot matriko 5x5  | 
                      
                        |   | 640 | izpišemo z dvojno zanko na zaslon. | 
                      
                        |   | 641 | {{{ | 
                      
                        |   | 642 |   float A[25] = {3.3, 5.2, 90.5, 2.3 ,1.1, | 
                      
                        |   | 643 |                    1.9, 71.0, 59.5, 5.3, 5.5, | 
                      
                        |   | 644 |                    1.0, 2.2, 3.5, 54.3, 2.2, | 
                      
                        |   | 645 |                    12.4, 56.1, 32.2, 11.4, 1.6, | 
                      
                        |   | 646 |                    34.8, 56.4, 78.9, 45.3, 12.3 | 
                      
                        |   | 647 |                    }; | 
                      
                        |   | 648 | }}} | 
                      
                        |   | 649 |  | 
                      
                        |   | 650 | == vaja47 == | 
                      
                        |   | 651 | Za izračun Pascal-ovega trikotnika (glej vaja31) uporabi podprogram pascals_triangle(n), kjer je n=8. | 
                      
                        |   | 652 | Vsako vrstico Pascal-ovega trikotnika zapiši v vrstico matrike P[64]. Prazna mesta matrike postavi | 
                      
                        |   | 653 | na vrednost 0. Izpiši matriko na zaslon (Uporabi for zanko). | 
                      
                        |   | 654 | Primer izgleda izpisa ene vrstice: | 
                      
                        |   | 655 | {{{ | 
                      
                        |   | 656 |   printf("%d %d %d %d %d %d %d %d\n", P[0], P[1], P[2], P[3], P[4], P[5], P[6], P[7], P[8]); | 
                      
                        |   | 657 | }}} | 
                      
                        |   | 658 |  | 
                      
                        |   | 659 |  | 
                      
                        |   | 660 | = Podprogrami = | 
                      
                        |   | 661 | == vaja60 == | 
                      
                        |   | 662 | Predelajte program za množenje matrike z vektorjem iz vaje 42, tako da boste | 
                      
                        |   | 663 | pred izpisom uporabili klic podprograma s stavkom | 
                      
                        |   | 664 | {{{ | 
                      
                        |   | 665 | #!c | 
                      
                        |   | 666 |    mat_vec4(b, a, x); | 
                      
                        |   | 667 |    printf("%.1f %.1f %.1f %.1f\n", b[0], b[1], b[2], b[3]); | 
                      
                        |   | 668 | }}} | 
                      
                        |   | 669 |  | 
                      
                        |   | 670 | == vaja61 == | 
                      
                        |   | 671 | Predelajte program vaje4 tako, da boste napisali podprogram, ki ga boste klicali | 
                      
                        |   | 672 | v naslednji zanki | 
                      
                        |   | 673 | {{{ | 
                      
                        |   | 674 | #!c | 
                      
                        |   | 675 |   for(i = 0; i < 10; i++) | 
                      
                        |   | 676 |     print_stars(i); | 
                      
                        |   | 677 | }}} | 
                      
                        |   | 678 |  | 
                      
                        |   | 679 |  | 
                      
                        |   | 680 | == vaja62 == | 
                      
                        |   | 681 | Napišite podprogram {{{float celsius(float fahrenheit)}}}, ki pretvori Fahrenheitove stopinje v Celsiusove.  | 
                      
                        |   | 682 | Formula za pretvorbo je °C = 5/9 * (°F - 32). Program naj naprej vpraša za | 
                      
                        |   | 683 | stopinje F in nato na decimalko natačno izpiše vrednost v Celzija. Zapomnite si, da | 
                      
                        |   | 684 | celoštevilčni izraz 5/9 da rezultat 0, zato ne smete uporabiti celoštevilčnega deljenja. | 
                      
                        |   | 685 |  | 
                      
                        |   | 686 | == vaja63 == | 
                      
                        |   | 687 | Stavek {{{ r = rand()*N/RAND_MAX + 1 }}} vrne naključno številko med 1 in N.  | 
                      
                        |   | 688 | Izdelajte program, ki simulira metanje kocke. Izdelajte program, ki simulira zaporedno | 
                      
                        |   | 689 | metanje dveh kock in izriše histogram za 100 metov v (približno) taki obliki: | 
                      
                        |   | 690 | {{{ | 
                      
                        |   | 691 | #!rst | 
                      
                        |   | 692 | :: | 
                      
                        |   | 693 |  | 
                      
                        |   | 694 |  2: 2    ** | 
                      
                        |   | 695 |  3: 5    ***** | 
                      
                        |   | 696 |  4: 4    **** | 
                      
                        |   | 697 |  5: 10   ********** | 
                      
                        |   | 698 |  6: 15   *************** | 
                      
                        |   | 699 |  7: 28   **************************** | 
                      
                        |   | 700 |  8: 12   ************ | 
                      
                        |   | 701 |  9: 9    ********* | 
                      
                        |   | 702 |  10: 7   ******* | 
                      
                        |   | 703 |  11: 5   ***** | 
                      
                        |   | 704 |  12: 3   *** | 
                      
                        |   | 705 |  | 
                      
                        |   | 706 | Prva številka pomeni vsoto pik na obeh kockah, druga številka pa pomeni koliko | 
                      
                        |   | 707 | krat se je dogodek zgodil, kar je tudi grafično narisano z podprogramom iz vaje 23. | 
                      
                        |   | 708 |  | 
                      
                        |   | 709 | Napotek: Pogled v navodila za funkcijo rand vam bo razkril, da je  | 
                      
                        |   | 710 | potrebno vklučiti header ``<stdlib.h>`` in povezovati z ``-lc``. | 
                      
                        |   | 711 | }}} | 
                      
                        |   | 712 |  | 
                      
                        |   | 713 | == vaja64 == | 
                      
                        |   | 714 |  | 
                      
                        |   | 715 | Izdelajte podprogram za linearno interpolacijo. Program naj vpraša za dve | 
                      
                        |   | 716 | točki (x,,0,,,y,,0,,) in (x,,1,,,y,,1,,) ter mesto na osi ''x'' za katero | 
                      
                        |   | 717 | želimo vrednost ''y''. Npr. za  | 
                      
                        |   | 718 | {{{ | 
                      
                        |   | 719 | 0 0  | 
                      
                        |   | 720 | 1 1  | 
                      
                        |   | 721 | 0.5 | 
                      
                        |   | 722 | }}} | 
                      
                        |   | 723 |  mora vrniti 0.5. | 
                      
                        |   | 724 | Podprogram naj ima naslednji prototip: | 
                      
                        |   | 725 | {{{ | 
                      
                        |   | 726 | #!c | 
                      
                        |   | 727 |   float linear_interpolation(float x, float p0[2], float p1[2]) | 
                      
                        |   | 728 | }}} | 
                      
                        |   | 729 |  | 
                      
                        |   | 730 |  | 
                      
                        |   | 731 | == vaja65 == | 
                      
                        |   | 732 | Podprogram za parametrizacijo daljice naj izpiše koordinato glede na | 
                      
                        |   | 733 | parameter ''t'', ki je v mejah od 0 do 1. Podobno kot pri vaji 64 preberemo | 
                      
                        |   | 734 | točki (x,,0,,,y,,0,,) in (x,,1,,,y,,1,,) in parameter ''t''. Prototip | 
                      
                        |   | 735 | {{{ | 
                      
                        |   | 736 | #!c | 
                      
                        |   | 737 |   void linear_interpolation(float t, float p0[2], float p1[2]) | 
                      
                        |   | 738 | }}} | 
                      
                        |   | 739 | naj izpiše točko s formatom "%.1f %.1f". Prednost parametrične interpolacije | 
                      
                        |   | 740 | je v tem, da deluje tudi za navpično daljico. Npr. | 
                      
                        |   | 741 | {{{ | 
                      
                        |   | 742 | 0 0 | 
                      
                        |   | 743 | 0 2 | 
                      
                        |   | 744 | 0.5 | 
                      
                        |   | 745 | }}} | 
                      
                        |   | 746 | vrne 0.0 1.0  | 
                      
                        |   | 747 |  | 
                      
                        |   | 748 | Ko je parameter t=0 se izpiše začetna točka. Pri t=1 pa končna. | 
                      
                        |   | 749 |  | 
                      
                        |   | 750 |  | 
                      
                        |   | 751 | == vaja66 == | 
                      
                        |   | 752 | Podobno kot v vaji 65 izdelajte podprogram, ki za parameter t v mejah | 
                      
                        |   | 753 | od -1 do 1 izpiše točko med podanima točkama. | 
                      
                        |   | 754 | Ko je parameter t=-1 se izpiše začetna točka. Pri t=1 pa končna. Za t=0 se izpiše točka na sredini. | 
                      
                        |   | 755 |  | 
                      
                        |   | 756 | == vaja67 == | 
                      
                        |   | 757 | Napiši podprogram decToBin(x), ki poljubno vrednost celega števila x prebranega iz zaslona pretvori | 
                      
                        |   | 758 | v binarni zapis in vrednost izpiše na zaslon. | 
                      
                        |   | 759 | Primer: | 
                      
                        |   | 760 | ||25||:2|| | 
                      
                        |   | 761 | ||12||1|| | 
                      
                        |   | 762 | ||6||0|| | 
                      
                        |   | 763 | ||3||0|| | 
                      
                        |   | 764 | ||1||1|| | 
                      
                        |   | 765 | ||0||1|| | 
                      
                        |   | 766 |  | 
                      
                        |   | 767 | Ostanke deljenja decimalnega števila izračunanega po zgornjem primeru preberemo v nasprotnem vrstnem redu. | 
                      
                        |   | 768 | Za zgornji primer dec: 25 -> bin: 11001. | 
                      
                        |   | 769 | Uporabi operator %. (Primer: 25%2 = 1)! | 
                      
                        |   | 770 |  | 
                      
                        |   | 771 |  | 
                      
                        |   | 772 | = Dinamična alokacija spomina in delo z datotekami = | 
                      
                        |   | 773 |  | 
                      
                        |   | 774 | == vaja80 == | 
                      
                        |   | 775 | Program naj prebere datoteko '''vaja80.dat''', ki vsebuje seznam celih številk in izpiše njihovo vsoto.  | 
                      
                        |   | 776 | V prvi vrstici je število celih števil ki sledijo v naslednjih vrsticah. Primer: | 
                      
                        |   | 777 | {{{ | 
                      
                        |   | 778 | 4 | 
                      
                        |   | 779 | 13 | 
                      
                        |   | 780 | 23 | 
                      
                        |   | 781 | 21 | 
                      
                        |   | 782 | 11 | 
                      
                        |   | 783 | }}} | 
                      
                        |   | 784 | Za ta primer mora program izpisati 72. Število vrstic v datoteki {{{vaja80.dat}}} je lahko največ 100. | 
                      
                        |   | 785 |  | 
                      
                        |   | 786 |  | 
                      
                        |   | 787 | == vaja81 == | 
                      
                        |   | 788 | Podobno kot v vaji 80 preberite datoteko '''vaja81.dat''' s tem da števila niso več omejena | 
                      
                        |   | 789 | z velikostjo polja ampak ga dinamično alocirajte z {{{malloc()}}} po tem, ko bo prebrana prva vrstica. | 
                      
                        |   | 790 |  | 
                      
                        |   | 791 | == vaja82 == | 
                      
                        |   | 792 | Preberi datoteko {{{vaja82.dat}}} v kateri sta zaporedno zapisani dve 4x4 matriki. Na primer: | 
                      
                        |   | 793 | {{{ | 
                      
                        |   | 794 | 1 2 3 4 | 
                      
                        |   | 795 | 5 6 7 8 | 
                      
                        |   | 796 | 9 0 1 1 | 
                      
                        |   | 797 | 1 2 2 2 | 
                      
                        |   | 798 | 1 1 1 1 | 
                      
                        |   | 799 | 1 1 1 1 | 
                      
                        |   | 800 | 1 2 5 6 | 
                      
                        |   | 801 | 3 4 5 2 | 
                      
                        |   | 802 | }}} | 
                      
                        |   | 803 |  | 
                      
                        |   | 804 | Program naj prebere datoteko v dve matriki in nato sešteje obe matriki v novo matriko (matrike seštevamo | 
                      
                        |   | 805 | po elementih). Ko imamo novo matriko naj program vpraša kateri element matrike želimo izpisati in sicer i-to vrstico | 
                      
                        |   | 806 | in j-ti stolpec (npr. i=1 in j=3 -> 9) in element i,j izpiše na zaslon.  | 
                      
                        |   | 807 |  | 
                      
                        |   | 808 |  | 
                      
                        |   | 809 | == vaja83 == | 
                      
                        |   | 810 | Program naj prebere iz datoteke '''vaja83.dat''' matriko velikosti ixj in izpiše element {2, 3}. Format datoteke je | 
                      
                        |   | 811 | {{{ | 
                      
                        |   | 812 | 4 5 | 
                      
                        |   | 813 | 1 2 3 4 5 | 
                      
                        |   | 814 | 4 5 5 6 6 | 
                      
                        |   | 815 | 4 4 4 99 4 | 
                      
                        |   | 816 | 6 7 7 8 1 | 
                      
                        |   | 817 | }}} | 
                      
                        |   | 818 | V prvi vrstici piše število vrstic in število kolon matrike. Izpisal pa bi 99. | 
                      
                        |   | 819 |  | 
                      
                        |   | 820 |  | 
                      
                        |   | 821 | == vaja84 == | 
                      
                        |   | 822 | Matriko iz tako kot pri vaji 83 preberemo iz datoteke '''vaja84.dat''' in | 
                      
                        |   | 823 | izpišemo v transponirani obliki kot cela števila. | 
                      
                        |   | 824 | Matriko celih števil dinamično alocirajte z malloc. | 
                      
                        |   | 825 |  | 
                      
                        |   | 826 | == vaja85 == | 
                      
                        |   | 827 | Matriko iz tako kot pri vaji 83 preberemo iz datoteke '''vaja85.dat''' in  | 
                      
                        |   | 828 | Vse elemente matrike kvadriramo in zapišemo v datoteko  '''vaja85.rez''', v istem | 
                      
                        |   | 829 | formatu celih števil.  | 
                      
                        |   | 830 |  | 
                      
                        |   | 831 | = Aplikacije = | 
                      
                        |   | 832 | == vaja100 == | 
                      
                        |   | 833 | Izračunaj faktor Učinkovite Rabe Energije, tako kot ga podaja [http://www.elektro-ljubljana.si/slo/Ceniki Elektro Ljubljana].  | 
                      
                        |   | 834 | Dobavitelj v ceniku za vsak '''razred porabe''' določi '''faktor cene energije''', ki je osnova za izračun | 
                      
                        |   | 835 | faktorja URE po naslednji enačbi: | 
                      
                        |   | 836 |  | 
                      
                        |   | 837 |   URE = ∑(E,,i,, F,,CE i,,)/E,,povprečna dnevna poraba,, | 
                      
                        |   | 838 |  | 
                      
                        |   | 839 | Tabela razredov porabe in pripadajočimi faktorji cene električne energije] ima 5 razredov s progresivno stopnjo F,,CE,,  | 
                      
                        |   | 840 |  | 
                      
                        |   | 841 | ||Razred porabe||Povprečna dnevna poraba energije (E,,i,,)||Faktor cene energije (F,,CE,,)|| | 
                      
                        |   | 842 | ||1.razred||do 6 kWh dnevne porabe||1.0|| | 
                      
                        |   | 843 | ||2.razred||nad 6 do vključno 12 kWh dnevne porabe||1.1|| | 
                      
                        |   | 844 | ||3.razred||nad 12 do vključno 18 kWh dnevne porabe||1.3|| | 
                      
                        |   | 845 | ||4.razred||nad 18 do vključno 24 kWh dnevne porabe||1.5|| | 
                      
                        |   | 846 | ||5.razred||nad 24 kWh dnevne porabe||2.0|| | 
                      
                        |   | 847 |  | 
                      
                        |   | 848 | Na primer URE za 8kWh dnevne porabe izračunamo kot URE=(6*1.0-(8-6)*1.1)/8  | 
                      
                        |   | 849 |  | 
                      
                        |   | 850 | Tabela[http://www.elektro-ljubljana.si/_services/document.php?name=ure__faktorji_uinkovite_rabe_energije_za_posamezno_povpreno_dnevno_porabo.pdf&langId=Slo&pageId=89 URE Faktorjev učinkovite rabe energije za posamezno povprečno dnevno porabo], se računajo samo za  | 
                      
                        |   | 851 | celoštevilčni del povprečne dnevne porabe. Izdelaj program, ki za vnešeno realno povprečno porabo izpiše | 
                      
                        |   | 852 | faktor URE v formatu, kot je v pred izračunani tabeli. | 
                      
                        |   | 853 |  | 
                      
                        |   | 854 | Napotek: Za izračun celega dela realnega števila uporabite funkcijo '''floor'''. | 
                      
                        |   | 855 |  | 
                      
                        |   | 856 | == vaja101 == | 
                      
                        |   | 857 |  | 
                      
                        |   | 858 | Ceno za uporabo omrežij določa Akt o določitvi metodologije za obračunavanje omrežnine in metodologije za določitev omrežnine in kriterijih za ugotavljanje upravičenih stroškov za elektroenergetska omrežja, (Ur.l. RS 121/2005) in je sestavljena iz: | 
                      
                        |   | 859 |  | 
                      
                        |   | 860 |  - stalnega mesečnega prispevka za moč, ki zanaša 0,66179 €/kW/mesec  | 
                      
                        |   | 861 |  - cene za prenešeno delovno energijo, ki znaša: | 
                      
                        |   | 862 |     * v primeru dvotarifnega načina merjenja porabe električne energije:  | 
                      
                        |   | 863 | {{{ | 
                      
                        |   | 864 | VT: 0,03731 €/kWh | 
                      
                        |   | 865 | MT: 0,02924 €/kWh | 
                      
                        |   | 866 | }}} | 
                      
                        |   | 867 |     * v primeru enotarifnega načina merjenja porabe električne energije: | 
                      
                        |   | 868 | {{{ | 
                      
                        |   | 869 | ET:  0,03462 €/kWh | 
                      
                        |   | 870 | }}} | 
                      
                        |   | 871 |  | 
                      
                        |   | 872 | Izdelaj program, ki uporabnik vpraša po predvidenem mesečnem številu kWh VT in NT in izpiše ceno | 
                      
                        |   | 873 | za prenešeno delovno energijo v primeru dvotarifnega in v primeru enotarfnega načina merjenja porabe  | 
                      
                        |   | 874 | električne energije. Uporabniku naj glede na vnešena podatka program svetuje, kateri način  | 
                      
                        |   | 875 | je zanj najbolj primeren. | 
                      
                        |   | 876 |  | 
                      
                        |   | 877 |  | 
                      
                        |   | 878 | == vaja102 == | 
                      
                        |   | 879 | Če ste izdelali vajo 100 in 101, potem združite programa v vaji 102 tako, da izračunate kako bo z elektriko  | 
                      
                        |   | 880 | po novem sistemu z URE faktorjem. | 
                      
                        |   | 881 |  | 
                      
                        |   | 882 | Obračun porabljene električne energije na podlagi izračunanega faktorja URE se izvede tako, | 
                      
                        |   | 883 | da se pomnoži količina električne energije v posamezni tarifi, s ceno električne energije v  | 
                      
                        |   | 884 | tej tarifi in z izračunanim odjemalčefim faktorjem URE. Upoštevajte, da ima mesec 31 dni. | 
                      
                        |   | 885 | Program pa naj tako kot v vaji 11 vpraša za število kWh v visoki in nizki tarifi, izpiše | 
                      
                        |   | 886 | posamezne cene ter svetuje najprimernejši način tarifiranja. | 
                      
                        |   | 887 |  |