Vežbe iz Programiranja 1

18.NCP koji na standardni izlaz ispisuje broj bajtova koji zauzimaju određeni tipovi podataka.

#include <stdio.h>
main()
{  printf("char:   %d  bajt\n", sizeof(char));


    printf("short: %d bajta\n", sizeof(short));
    printf("int : %d bajta\n", sizeof(int));
    printf("long=%d bajta\n", sizeof(long));
    printf("unsigned=%d bajta\n", sizeof(unsigned));
    printf("float=%d bajta\n", sizeof(float));
    printf("double=%d bajta\n", sizeof(double));
}




 

19. NCP koji na standardni izlaz ispisuje vrednosti predefinisanih konstanti (zaglavlja: limits.h, float.h).

#include <stdio.h>
#include <limits.h>
#include <float.h>
main()
{
  printf("CHAR_BIT:\t%d\n", CHAR_BIT);
  printf("UCHAR_MAX:\t%u\n", UCHAR_MAX);


  printf("INT_MIN:\t%d\n", INT_MIN);
  printf("INT_MAX:\t%d\n", INT_MAX);
               printf("LONG_MAX:\t%ld\n", LONG_MAX);
  return 0;
}

20.

a) NCP koji ispisuje na standardni izlaz prvih 20 parnih brojeva. Upotrebiti for petlju (ciklus).

For-ciklus se zapisuje tako da se iza ključne reči for, zapišu u zagradama tri izraza međusobno odvojena tačka-zarezom, a iza njih naredba koja čini telo petlje:
for ( izrazopt ; izrazopt ; izrazopt ) naredba

Beskonačna petlja se može realizovati pomoću for petlje:
for(;;)
{
/* beskonačna petlja */
}

I način

Prvih 20 parnih brojeva su elementi serije brojeva koja počinje brojem 2, potom slede 4, 6, 8,..., tj. to je serija od 20 brojeva u kojoj je svaki element veći od prethodnog za +2

#include <stdio.h>
#define MAX 20

main ()
{
int broj; /* paran broj, clan serije koji se ispisuje na stdout*/
int i; /*brojac trenutno ispisanih brojeva */

for (broj=2, i=1; i<=MAX; broj=broj+2, i=i+1) printf("\n%d", broj);

printf("\nKRAJ\n");
}

II način

#include <stdio.h>
#define MAX 20

main ()
{
int broj; /* paran broj, clan serije koji se ispisuje na stdout*/
int i; /*brojac trenutno ispisanih brojeva */

broj=2;i=1;
for (; i<=MAX; i=i+1) { printf("\n%d", broj); broj=broj+2; }
/*BLOK sa vise od 1 naredne ogradjuje se zagradama, uociti da one nisu bile nuzne u I nacinu, tj. nisu ogradile poziv funkcije printf*/

printf("\nKRAJ\n");
}

III način

Kao u I nacinu, prvih 20 parnih brojeva su elementi serije brojeva koja počinje brojem 2, potom slede 4, 6, 8,..., tj. to je serija od 20 brojeva u kojoj je svaki element veći od prethodnog za +2

No, iskoristicemo izraz i+=2; /* i=i+2;*/

Izraz oblika
i = i + 2
u kom se ista promenljiva i pojavljuje s obe strane znaka dodele vrednosti, može se zapisati u obliku:
i += 2
Operator += se naziva složeni operator dodele vrednosti.
Ovaj oblik se može primeniti na većinu binarnih operatora: +=, -=, *=, /=, %=, <<=,>>=, &=, ^= i |=, koristeći opste pravilo:
Ako su izraz1 i izraz2 neki izrazi, tada izraz1 op= izraz2 je ekvivalentan sa izraz1 = (izraz1) op (izraz2)
pri tome izraz1 mora biti izraz koji označava položaj u memoriji (ime promenljive ili dereferencirani pokazivač).
NAPOMENA: Ovi operatori, kao i operator dodele vrednosti, imaju niži prioritet od aritmetičkih, relacijskih i logičkih operatora. Zato iskaz
i *= j + 1;
se interpretira kao
i = i * (j + 1);
a ne kao
i = i * j + 1;

#include <stdio.h>
#define MAX 20

main ()
{
int broj; /* paran broj, clan serije koji se ispisuje na stdout*/
int i; /*brojac trenutno ispisanih brojeva */

for (broj=2, i=1; i<=MAX; broj+=2, i+=1) printf("\n%d", broj);

printf("\nKRAJ\n");
}

IV način - Prefiks i postfiks unarni operatori ++, --

#include <stdio.h>
#define MAX 20

main ()
{
int broj; /* paran broj, clan serije koji se ispisuje na stdout*/
int i; /*brojac trenutno ispisanih brojeva */

for (broj=2, i=1; i<=MAX; broj=broj+2, i++) printf("\n%d", broj);

printf("\nKRAJ\n");
}

Prefiks i postfiks operatori: ++ i --, uvećavaju, odnosno umanjuju, vrednost numeričkih promenljivih za 1. Mogu se primeniti ispred ili iza naziva promenljive,
++n; /* uvećava n za 1 */
--n; /* umanjuje n za 1 */
Prefiks operator deluje na operand pre nego se koristi njegova nova vrednost.
n = 5;
x = ++n; /* x je jednak 6, n je jednak 6 */
Postfiks operator deluje na operand nakon korišcenja njegove trenutne vrednosti.
n = 5;
x = n++; /* x je jednak 5, n je jednak 6 */
Operandi na koje deluju operatori ++ i -- moraju biti promenljive.

V način

Prvih 20 parnih brojeva su elementi serije brojeva koja počinje brojem 2*1, potom slede 2*2, 2*3, 2*4,..., tj. to je serija od 20 brojeva u kojoj je svaki element 2 puta veći od članova serije {1, 2, 3, ..., 20}

#include <stdio.h>
#define MAX 20

main ()
{
int i; /*brojac trenutno ispisanih brojeva */

for (i=1; i<=MAX; ++i) printf("\n%d", 2*i);

printf("\nKRAJ\n");
}

b) NCP koji ispisuje na standardni izlaz prvih 20 parnih brojeva. Upotrebiti while ciklus.

Sintaksa while naredbe glasi:
while ( izraz ) naredba

Značenje je: dok je (eng. while) izraz različit od nule, izvršava se naredba. Izraz predstavlja uslov ponavljanja while ciklusa.

#include <stdio.h>
#define MAX 20
 
main ()
 { 
         int i; /*brojac trenutno ispisanih brojeva */
        
         i=1;
         while ( i<=MAX)
         {
                 printf("\n%d", 2*i);
                 ++i;
         }
         printf("\nKRAJ\n");
 }

c) NCP koji ispisuje na standardni izlaz prvih 20 parnih brojeva. Upotrebiti do-while ciklus.

Sintakse do-while naredbe je do naredba while ( izraz ) ;

Izraz predstavlja uslov za ponavljanje ciklusa. Značenje je: izvrši naredbu, a zatim ponavljaj tu naredbu dok je izraz logički istinit. Naredbe u telu se petlje izvršavaju bar jedan put.

#include <stdio.h>
#define MAX 20
 
main ()
 { 
         int i=1; /*brojac trenutno ispisanih brojeva */
         
         do
         {
                 printf("\n%d", 2*i);
                 ++i;
         }while ( i<=MAX);
         printf("\nKRAJ\n");
 }

21. NCP koji unosi nenegativan ceo broj sa standardnog ulaza, a ispisuje na standardni izlaz faktorijel tog broja. ( 0!=1, n! = n * (n-1) * (n-2) *...*2*1 )

IDEJA: Racunanje se realizuje u n koraka. Promenljiva f uzima vrednosti sledecim redom
f=1 (za n=0 ili n=1)
f=2*f=2*1=2 (za n=2)
f=3*f=3*2=6(za n=3)
f=4*f=4*6=24(za n=4)
...
f=n*f=n* (n-1)!=n!

#include <stdio.h>
 
main ()
 { 
         int n; /*broj sa standardnog ulaza */
         long f=1; /*vrednost n!, uocite TIP long, 0!=1 */
         int i; /*brojac u ciklusu */

         printf("Unesite broj n: "); scanf("%d",&n);
         
     for(i=2; i<=n; i++) f=f*i;
         
         printf("\n%d! = %ld\n", n, f);  /*uocite %ld za stampu long vrednosti */
 }

22. NCP koji unosi 50 realnih brojeva sa standardnog ulaza, a ispisuje na standardni izlaz njihov zbir.

IDEJA: U ovom zadatku treba sabrati do 50 vrednosti, ali je nepraktično koristiti do 50 promenljivih za čuvanje unetih vrednosti, a zatim sabrati vrednosti tih 50 promenljivih. Zato se pribegava upotrebi ciklusa: tj. 50 puta će se vršiti učitavanje vrednosti sa tastature u promenljivu x, i nakon svakog učitavanja vrednost promenljive x će se dodati zbiru. Na početku je zbir jednak 0.

#include <stdio.h>

main ()
 { 
         int i=1; /*brojac ucitanih brojeva */
         float x, zbir; /* broj sa stdin, suma unetih brojeva */
         
         
         for(zbir=0, i=1; i<=50;i++) {scanf("%f",&x); zbir=zbir +x;}
         
         printf("\nZbir = %f\n", zbir);
 }

23. Šta je rezultat rada sledećeg programa koji je blokovski orjentisan?

#include <stdio.h>
main()
{
  int pom=1;
  printf("Pre ulaska u unutrasnji blok pom=%d\n",pom);
     {  int pom=50;
         printf("Pre izlaska iz unutrasnjeg bloka  pom=%d\n",pom);
      }
   printf("Nakon izlaska iz  unutrasnjeg bloka  pom=%d\n",pom);
}

Složeni iskaz C jezika, koji je napisan unutar vitičastih zagrada, naziva se blok. Telo for ciklusa, while ciklusa, do while ciklusa, funkcije su na primer blokovi C jezika. Unutar bloka se mogu koristiti svi tipovi iskaza C jezika uključujući deklaraciju promenljivih i prototipova funkcija, jedino se ne sme vršiti definisanje neke druge funkcije. Deklaracije se moraju pisati neposredno na početku bloka (iza vitičastih zagrada).

24. NCP koji od korisnika traži da odgovori na upit:
Prvim programerom smatra se:
(a) Denis Ritchie
(b) Bill Gates
(c) Ada Byron
Otkucajte slovo ispred korektnog odgovora.
Ako korisnik pritisne malo ili veliko slovo 'c', program ispisuje poruku "Korektno". U slučaju (a) i (b) poruka treba biti "Nekorektno". Ako pritisne slovo različito od 'a','b' ili 'c', tada se ispisuje poruka "Otkucali ste pogresno slovo". /* Ovo je primer programiranja programa u kom postoji višestruk logički izbor if-else-if-...*/

#include <stdio.h>
main()
{
char c; /* slovo korisnikovog odgovora*/

/*ispis upita i ponudjenih odgovora korisniku */
printf(" Prvim programerom smatra se:\n");
printf(" (a) Denis Ritchie\n (b) Bill Gates\n (c) Ada Byron\n");
printf("\nOtkucajte slovo ispred korektnog odgovora. \n");

scanf("%c", &c);

if (c =='C' || c =='c') printf ("Korektno\n");
else if (c =='B' || c =='b') printf ("Nije korektno\n");
else if (c =='A' || c =='a') printf ("Nije korektno\n");
else printf("Otkucali ste pogresno slovo\n");

} 

25. NCP koji prethodni zadatak rešava upotrebom switch-case naredbe

#include <stdio.h>
main()
{
char c; /* slovo korisnikovog odgovor a*/

/*ispis upita i ponudjenih odgovora korisniku */
printf(" Prvim programerom smatra se:\n");
printf(" (a) Denis Ritchie\n (b) Bill Gates\n (c) Ada Byron\n");
printf("\nOtkucajte slovo ispred korektnog odgovora. \n");

scanf("%c", &c);

/* switch-case iskaz */
switch(c)
{
case 'C': case 'c': printf ("Korektno\n"); break;
case 'A': case 'a':case 'B': case 'b': printf ("Nije korektno\n"); break;
default: printf("Otkucali ste pogresno slovo\n");
}

}

ZADACI ZA VEŽBU

26. a) NCP koji unosi nenegativan ceo broj iz intervala 1..8 sa standardnog ulaza, a ispisuje na standardni izlaz faktorijel tog broja.

b) NCP koji unosi nenegativan ceo broj n sa standardnog ulaza, a ispisuje na standardni izlaz vrednost sume 1! + 2! + 3! +...+n!

27. NCP koji izračunava sumu prvih 20 neparnih brojeva i štampa na standardni izlaz.

28. NCP koji izračunava sumu kubova prvih 20 neparnih brojeva i štampa na standardni izlaz.

29. NCP koji učitava sa standardnog ulaza broj n i štampa na standardni izlaz da li je taj broj stepen broja 2.

30. NCP koji unosi nenegativan ceo broj sa standardnog ulaza, a ispisuje na standardni izlaz netrivijalne faktore (delioce) tog broja. Trivijalni faktori broja n su 1, n.

IDEJA: proveriti da li broj ima delioce među brojevima od 2 do n/2

31. (NIZOVI) NCP koji će na standardni izlaz ispisati prvih 15 Fibonačijevih brojeva u 5 kolona (po 3 broja u vrsti).

  #include <stdio.h>
    #define BROJ 15
    main()
    {
      int i; /*brojac u petlji */
      int fibonaci[BROJ]; /*niz koji cuva vrednosti iz f-lacije */

       /*inicijalizacije */
        fibonaci[0]=0;
        fibonaci[1]=1;

      /*formiranje vrednosti clana niza u zavisnosti od vrednosti prethodnika */
      for  (i=2;i<BROJ;++i)  fibonaci[i]=fibonaci[i-2]+fibonaci[i-1];

      /*ispis vrednosti clanova niza u zahtevanom formatu */
         for  (i=0;i<BROJ;++i)
                 printf("%c%5d",  (i%3==0) ? '\n' : ' ', fibonaci[i]);
}
 

32. Zadate su tri verzije C programa. Koja od njih nije korektna i zašto?

33. NCP koji će izračunati sume ∑ _i=1..5 i² i ∑ _i=1..23 i² i obe sume ispisati u zasebnim linijama.

#include <stdio.h>
void  Zbir_Kvad(int n);   /*f-ja koja vrsi zeljeno izracunavanje */
main()
{  Zbir_Kvad( 5);
    Zbir_Kvad( 23);
}
void  Zbir_Kvad(int n)
{  int br; /* lokalna promenljiva funkcije, brojac u ciklusu */
     long Zbir=0; /* lokalna promenljiva funkcije, suma kvadrata brojeva od 1..n */
    for  (br=1; br<=n;  Zbir+= (long)  br*br,  ++br)  ;
    printf(" Zbir kvadrata brojeva od 1 do %d jese %ld\n", n,Zbir);
}

Poziv funkcije: pozivajuća jedinica(main)  ->   funkcija Zbir_Kvad   ->   pozivajuća jedinica(main)

34. NCP koji će izračunati i ispisati na standardni izlaz sume: ∑ _i=1..5 i², ∑ _i=1..5 i³, ∑ _i=1..10 i⁴.

#include <stdio.h>
void Zbir_stepena (int n, int k);    /*izracunava sumu k-tih stepena za brojeve od 1 do n */
main()
{ Zbir_stepena(5,2);
    Zbir_stepena(5,3);
    Zbir_stepena(10,4);
return 0;
}

void Zbir_stepena (int n, int k)
{

    int i,j;   /*brojaci u for petljama /
    long Zbir=0  ,  stepenovan ; /* rezultujuca suma, rezultat stepenovanja scakog sabirka */

    for (i=1; i<=n; Zbir +=stepenovan, ++i) /*spoljasnji for ciklus obavlja sumiranja po i^k, i=1..n*/
         for( stepenovan=1,j=1;  j<=k;  stepenovan*= (long) i, ++j) ; /*unutrasnji for ciklus obavlja stepenovanje i^k, gde j=1..k */
     printf(" Zbir %d. stepena od 1 do %d jeste %ld\n", k,n,Zbir);
}

35. Šta je rezultat rada sledećeg programa s obzirom na svojstva automatskih i statičkih promenljivih?

#include<stdio.h>
void funkcija(void);
main()
{ int br;
    for(br=1;br<=5;++br) funkcija();
}

void funkcija(void)
{ static int a=0;
  int b=0;
  printf("static =%d auto=%d\n",a,b);
    ++a;
    ++b;
}

36. NCP koji će ispisati rezultat skalarnog množenja uređene šestorke a i uređene šestorke b. Uređenu šestorku a čini prvih šest prirodnih brojeva, a uređenu šestorku b čine brojevi 8,7,6,5,4,3.

#include <stdio.h>
long mnozi(int x[],int y[],int n);
main()
{int a[ ]={1,2,3,4,5,6}, b[  ]={8,7,6,5,4,3};

  printf("Skalarno a*b= %ld\n",mnozi(a,b,6));
}
long mnozi(int x[ ],int y[ ],int n)
{ int br;
   long suma=0;
   for(br=0;br<n;br++) suma=suma+x[br]*y[br];
   return suma;
}

37. NCP koji učitava sa standardnog ulaza broj n (n <=100), a potom elemente n-dimenzionog niza celih brojeva. Program treba da ispiše maksimum unetog niza na standardni izlaz.

#include <stdio.h>
#define DIM 100
int max( int prvi, int drugi );
main()
{
  int a[DIM], indeks, n, Max; /*niz celih brojeva sa stdin, brojac u ciklusu, dimenzija niza, maksimum niza */

  printf("\nUnesite dimenziju niza: "); scanf("%d", &n);

 printf("\nUnesite clanove niza: ");
  for(indeks=0; indeks<n; indeks++)
                      scanf("%d", &a[indeks]);

/* trazenje max clana */
Max=a[0];
for(indeks=1; indeks<n; indeks++)
     Max=max(Max, a[indeks]);
printf("\nMaksimum niza je %d \n", Max);
return 0;
}

/*  max: vraca maksimum dva argumenta */
int max( int prvi, int drugi )
{
 return ( (prvi>=drugi)?prvi:drugi );
}

38. Šta je rezultat rada sledećeg programa?
  /* bitske operacije. */
#include <stdio.h>
main()
{
   printf( "255 & 15 = %d\n", 255 & 15 );
   printf( "255 | 15 = %d\n", 255 | 15 );
   printf( "255 & 15 = %o\n", 255 & 15 );
   printf( "255 | 15 = %x\n", 255 | 15 );
   printf( "255 ^ 15 = %d\n", 255 ^ 15 );
   printf( "4 << 2   = %d\n", 4 << 2 );
   printf( "16 >> 2  = %d\n", 16 >> 2 );
   printf( "~(-3)      = %d\n", ~(-3) );
}

255 & 15 = 15                                                  255 ^ 15 = 240
255 | 15 = 255                                                   4 << 2   = 16
255 & 15 = 17                                                  16 >> 2  = 4
255 | 15 = ff                                                      ~(-3)      = 2

Protumačiti uz pomoć K&R  izraze:
 

unsigned x, n;
 

x=x & 0177;
x=x&01;
x=x|n;
x=x|01;
x=x & ~0177;
~0;
~0<<n;
~(~0<<n);
 

39. (Funkcije getchar(), putchar() ) NCP koji sadržaj standardnog ulaza štampa znak po znak na standardni izlaz sve do markera kraja ulaza.

#include <stdio.h>
main()
{
   int znak;

   znak=getchar(); /*promenljivoj znak se dodeljuje znak sa ulaza */
    while( znak !=EOF)
     {
          putchar(znak); /*dodeljeni znak se kopira na izlaz */
          znak=getchar();
     }
}

Izlaz kod baferovanog ulaza (DOS),npr;
  1<enter>
  1
  ^Z
 

Izlaz kod Linux ulaza ,npr;
  1<enter>
  1
  ^D
 

II nacin:
#include <stdio.h>
main()
{
    int znak;
       while( (znak=getchar() ) !=EOF) putchar(znak);
}

DEMONSTRACIJA upotrebe funkcija getchar-putchar - primeri

Primer 1.

#include <stdio.h>

main()

{

int c1, c2;

c1 = getchar();

printf("------------\n");

c2 = getchar();

printf("c1 = %d, c2 = %d\n",c1, c2);

printf("c1 = %c, c2 = %c\n",c1, c2);

putchar(c1); /* isto je kao i printf("%c",c1); */

putchar(c2); /* isto je kao i printf("%c",c2); */

putchar('\n');

/* Za ispisivanje karaktera a */

putchar('a');

/* dozvoljeno je : printf("abc"); printf("a"); */

/* nedozvoljeno je : printf('a'); putchar('abc'); putchar("abc"); */

}

Ulaz:

ab

Izlaz:

------------

c1 = 97, c2 = 98

c1 = a, c2 = b

ab

a

Primer 2. Program cita jedan karakter i ispisuje ga.

#include <stdio.h>

main()

{

int c; /* Karakter - obratiti paznju na int */

c = getchar(); /* cita karakter sa standardnog ulaza */

putchar(c); /* pise karakter c na standardni izlaz */

putchar('\n'); /* prelazak u novi red */

putchar('a'); /* ispisuje malo a */

putchar(97); /* ekvivalentno prethodnom */

}

Ulaz:

s

Izlaz iz programa:

s

s

aa

40. Ispisati na standardni izlaz ukupan broj karaktera standardnog ulaza do markera kraja. Pretpostaviti da je za ukupan broj karaktera dovoljan opseg double promenljive.

#include <stdio.h>
main()
{
  double br;
   for( br=0; getchar()!=EOF; ++br ) ;
   printf("Karaktera: %.0f\n",br);
}

41. NCP koji će ispisati na standardni izlaz ukupan broj karaktera standardnog ulaza do markera kraja, kao i broj prelazaka u novi red. Pretpostaviti da je za ukupan broj karaktera i ukupan broj prelazaka u novi red dovoljan opseg long promenljivih.



#include <stdio.h>
main()
{
   int znak; /*prihvata znak sa ulaza */
   long linije=0 ; /*brojac linija */
    long br_znak=0; /*brojac znakova na ulazu */

   while ( (znak=getchar() ) != EOF)
     { br_znak++;
         if (znak=='\n') linije ++;
     }

    printf("Prelazaka u novi red: %ld, karaktera: %ld \n",linije,br_znak);
}


 

42. NCP koji će ispisatiu izlaznu datoteku broj pojava blanko znaka, broj pojava horizontalnog tabulatora, broj prelazaka u novi red u tekstu koji dolazi iz ulazne datoteke. Pretpostaviti da je za evidenciju broja pojava dovoljan opseg int promenljivih, kao i da program radi sa redirekcijom standardnog ulaza i izlaza.

Ilustracija redirekcije (preusmeravanja) standardnog ulaza i izlaza iz komandne linije operativnog sistema:
Nakon kompajliranja gcc zad42.c

pokrenuti program sa :
./a.out <ulaz.txt
./a.out >izlaz.txt
./a.out <ulaz.txt >izlaz.txt

Komanda ./a.out <ulaz.txt je primer preusmeravanja standardnog ulaza. Ulaz je preusmeren tako da dodje iz datoteke ulaz.txt, umesto sa tastature.

Komanda ./a.out >izlaz.txt je primer preusmeravanja standardnog izlaza. Program svoj izlaz preusmerava sa standardnog izlaza u datoteku izlaz.txt (tj. rezultat rada programa se ne prikazuje na ekranu, vec se ispisuje u datoteci izlaz.txt).

Komanda ./a.out <ulaz.txt>izlaz.txt je primer preusmeravanja standardnog ulaza i standardnog izlaza.

#include <stdio.h>
main()
{
 int znak; /*prihvata znak sa ulaza */
 int Blanks=0; /*brojac blankova */
  int Tabs=0; /*brojac horizontalnih tabulatora */
   int NewLines=0; /*brojac linija */

 while( (znak=getchar())!=EOF ) /*ucitavanje karakter do markera kraja fajla i ...*/

        if( znak==' ' ) ++Blanks; /* ... brojanje blankova */
       else if( znak=='\t' ) ++Tabs; /* ... brojanje tab-ova */
              else if( znak=='\n' ) ++NewLines;

/*UOCITI: blok naredbi while ciklus NIJE OGRADJEN viticastim zagradama*/

/*izdavanje rezultata na standardni izlaz*/
printf("Blankova: %d. Tabulatora: %d. Prelazaka u novi red: %d\n", Blanks, Tabs, NewLines);

}

Efekat tastera TAB

43. NCP koji će tekst sa standardnog ulaza ispisati na standardni izlaz tako da se umesto horizontalnog tabulatora ispiše \t, umesto znaka prelaza u novu red ispiše \n, umesto backslah (znaka obrnute kose crte) ispiše \\.

#include <stdio.h>
main()
{
    int znak;
    znak=getchar();
    while( znak!=EOF )
      {
       if( znak=='\t' ) /*uciniti tab vidljivim */
              { putchar('\\'); putchar('t'); }
       else if( znak=='\n' ) /*uciniti new line vidljiv */
              { putchar('\\'); putchar('n'); putchar('\n'); }
          else if( znak=='\\' ) /*backslash udvojiti */
              { putchar('\\'); putchar('\\'); }
          else putchar(znak);

          znak=getchar();
        } /* while( znak!=EOF ) */

} /*main() */

Za razmišljanje

44. NCP koji će tekst sa standardnog ulaza ispisati na standardni izlaz tako da se višestruke uzastopne pojave blanko znaka zamene jednim blankom. (sažimanje).

#include <stdio.h>
#define GRANICA '0'
main()
{
   int znak; /*tekuci znak sa ulaza*/
   int preth; /*znak koji prethodi tekucem */
   preth=GRANICA;
     while ( (znak=getchar() ) !=EOF)
       {
         if (znak !=' ' || preth != ' ') putchar(znak);
            preth=znak;
        }
}
 

 45. NCP koji će u tekstu sa standardnog ulaza prebrojati koliko puta se pojavila svaka cifra dekadnog brojnog sistema, koliko puta su se pojavile beline (blanko, horizontalni tab, prelaz u novi red) i koliko puta su se pojavili ostali znaci. Rezultat ispisati na standardni izlaz.

    Tabela ASCII kôdova

#include <stdio.h>
main()
{
  int znak, br; /* znak sa ulaza, brojac u petlji*/
int  White, Ostali; /*brojac belih i ostalih znakova na ulazu */
  int cifra[10];  /* za i=0..9 i-ti clan niza cuva broj pojava cifre i */

/* inicijalizacije */
  White=Ostali=0;

for(br=0; br<10; ++br)
  cifra[br]=0;
 

/* prebrojavanje */
 while( (znak=getchar())!=EOF )

  if( znak >='0' && znak<='9' )     /*da li je cifra */

   ++cifra[znak-'0'];

  else if ( znak==' ' || znak=='\n' || znak=='\t' )
   ++White;
  else
   ++Ostali;

/* prikaz rezultata */
 for( br=0; br<10; ++br )
  printf( "Cifra %d se pojavljuje %d puta\n", br,cifra[br] );
 printf("\nBelina ima: %d Ostalih: %d\n", White, Ostali);
}

Par napomena:

#include<stdio.h>

int prost(int n);  /*Ispituje se da li je broj n prost, vraca 0 ako nije, a nenula ako jeste */
main()

{


int n; /* broj zeljenih prostih brojeva */
int i; /* brojac ispisanih prostih brojeva */
int br; /* kandidat za prost broj */


printf("Unesite koliko prostih brojeva zelite da dobijete: \n"); scanf("%d", &n);


/* Inicijalizujemo brojac i - koliko smo prostih brojeva nasli do sad */
i = 0;


/* Pocetni broj za koji proveravamo da li je prost */
br = 2;


/* Trazimo i-ti prost broj */

while(i < n) {
   /* Ako je broj prost... */
   if (prost(br)) {
      /* stampamo ga... */
     printf("Broj %d je prost.\n", br);
      /* i uvecavamo broj pronadjenih prostih brojeva. */
     i++;
 }
  /* U svakom slucaju prelazimo na proveru da li je sledeci broj prost */
br++;
}

}

int prost(int n)  /*Ispituje se da li je broj n prost tako to se proverava da li ima delioce
medju brojevima od 2 do sqrt(n).  Pri implementaciji se koristi tvrdjenje da je broj prost ako je jednak 2, ili 
ako je neparan i ako nema delitelja medju neparnim brojevima od 3 do n/2 */
{
  int prost;  /*indikator slozenosti broja n */
  int i;    /*potencijalni delitelj broja n */
  if (n==1) return 0;
  prost= (n%2!=0) || (n==2);    /*parni brojevi razliciti od  od dva nisu prosti brojevi */
  
  i=3;   /*najmanji potencijalni kandidat za delitelje medju neparnim brojevima razlicitim od jedan */
  while   ( (prost) && (i*i<=n) )
   { prost=n%i != 0;
     i=i+2; /*proveravamo kandidate za delitelje samo medju neparnim brojevma */ 
    }
 return prost;
}

56. Napisati program u C-u koji prikazuje sve proste brojeve u datom intervalu kojima je zbir cifara slozen broj. Interval se zadaje ucitavanjem gornje i donje granice (dva prirodna broja). Brojeve prikazati u opadajucem poretku.
#include <stdio.h>
#include <stdlib.h>
int prost (int n);  /*testira da li je broj n prost broj */
/*Prirodni brojevi (sem 1)imaju najmanje dva delioca:jedinicu i samog sebe.
   Brojevi koji nemaju drugih delioca,sem ova dva, nazivaju se prostim */
int zbirCifara (int n);   /*vraca zbir cifara broja n */
main()
{ int donja,gornja;  /*granice intervala */
   int i;  /*brojac u petlji */
   int pom;   /*posrednik u eventualnoj zameni */
  /*ucitavanja granice intervala */
  scanf("%d%d", &donja, &gornja);    
  if (donja > gornja)   /*obezbedjivanje relacije: donja <=gornja */
    { pom=donja;
      donja=gornja;
      gornja=pom;
    }
   for(i=gornja;i>=donja; i--)
    if (prost (i) && !prost(zbirCifara(i) )  ) printf("%d\n",i);
}
int prost(int n)  /*Ispituje se da li je broj n prost tako to se proverava da li ima delioce
medju brojevima od 2 do n/2.  Pri implementaciji se koristi tvrdjenje da je broj prost ako je jednak 2, ili 
ako je neparan i ako nema delitelja medju neparnim brojevima od 3 do n/2 */
{
  int prost;  /*indikator slozenosti broja n */
  int i;    /*potencijalni delitelj broja n */
  if (n==1) return 0;
  prost= (n%2!=0) || (n==2);    /*parni brojevi razliciti od  od dva nisu prosti brojevi */
  
  i=3;   /*najmanji potencijalni kandidat za delitelje medju neparnim brojevima razlicitim od jedan */
  while   ( (prost) && (i<=n/2) )
   { prost=n%i != 0;
     i=i+2; /*proveravamo kandidate za delitelje samo medju neparnim brojevma */ 
    }
 return prost;
}
int zbirCifara (int n)
{ int  Suma=0;  
   while (n>0)
  { Suma+= n%10;  /*dodavanje cifre tekuceg razreda,pocev od razreda jedinica ,
                   a iduci ka visim razredima cifara */
    n=n/10;      /*prelaz ka visem razredu */
  }
 return Suma;
}