130.
NCP koji sa prve linije standardnog ulaza prihvata broj n (n<=100), a zatim sa standardnog ulaza prihvata
po jedan element n-dimenzionalnog niza celih brojeva. Ispisati na standardni izlaz elemente niza sortirane u
neopadajućem poretku.
#include <stdio.h>
void sort( int niz[], int ukupno);
/*
funkcija implementira Select sort niza sa ukupno clanova,
pogledati poglavlje 18.3 sa predavanja
*/
/* glavni program */
main()
{
int ukupno; /* dimenzija niza */
int a[100]; /* niz sa standardnog ulaza*/
int indeks; /* brojac u ciklusu */
printf("Unesite broj elemenata niza\n");
scanf("%d", &ukupno);
for( indeks=0; indeks<ukupno; indeks++)
{printf("%d. clan niza je:\t", indeks+1);
scanf("%d",&a[indeks]);
}
/* sortiranje niza */
sort(a,ukupno);
/* ispis sortiranog niza */
for( indeks=0; indeks<ukupno; indeks++)
printf("%d\t", a[indeks]);
printf("\n");
return 0;
}
/* sort: jednostavnije sortiranje */
void sort( int niz[], int ukupno)
{
int j, k; /* brojaci u ciklusima */
for(j=0; j<ukupno-1; j++)
for(k=j+1; k<ukupno; k++)
if( niz[j]>niz[k] )
{
int rezerva; /* posrednik u trampi j-tog
i k-tog clana niza */
rezerva=niz[j];
niz[j]=niz[k];
niz[k]=rezerva;
}
}
131. NCP koji sa standardnog ulaza unosi pomocu funkcije scanf dve niske sa ne vise od 20 karaktera i proverava da li su unete niske anagrami. Na primer, niske VATRA i TRAVA su anagrami, jer se sastoje od jednakog broja istih slova, dok niske TRAVA i TATAR nisu anagrami zbog viska slova T i manjka slova V u drugoj niski. NAPOMENA: uneti obe niske, sortirati ih, uporediti ih (npr. pomocu funkcije strcmp)
132. NCP koji prihvata kao argument komandne linije leksikografski uredjenu nisku sa ne vise od 20 karaktera i proverava da li niska sadrzi znak @. (ASCII(@) = 64)
/*-----------------------Binarna pretraga niza celih brojeva - iterativna verzija-------------------------------*/
#include <stdio.h>
#include <string.h>
/* Funkcija proverava da li se element x javlja unutar niske a.
Funkcija vraca poziciju na kojoj je element nadjen odnosno
-1 ako ga nema.
!!!!! VAZNO !!!!!
Pretpostavka je da je niska a sortirana
*/
int binary_search(char a[], int n, int x)
{
/* Pretrazujemo interval [l, d] */
int l = 0;
int d = n-1;
/* Sve dok interval [l, d] nije prazan */
while (l <= d)
{
/* Srednja pozicija intervala [l, d] */
int s = (l+d)/2;
/* Ispitujemo odnos x i srednjeg elementa a[s]*/
if (x == a[s])
/* Element je pronadjen */
return s;
else if (x < a[s])
{
/* Pretrazujemo interval [l, s-1] */
d = s-1;
}
else
{
/* Pretrazujemo interval [s+1, d] */
l = s+1;
}
}
/* Element nije nadjen */
return -1;
}
main(int argc, char *argv[])
{
int i; /*brojacka promenljiva*/
i = binary_search(argv[1], strlen(argv[1]), '@');
if (i==-1)
printf("Nema karaktera @\n");
else
printf("Pronadjen @ na poziciji %d\n", i);
}133. NCP koji unosi sa standardnog ulaza najpre dimenziju niza (ne vecu od 10), a potom i sam niz celih brojeva. Ukoliko niz nije uredjen u neopadajucem poretku, prekinuti dalji rad programa, a u suprotnom proveriti da li niz sadrzi broj koji se unosi kao parametar komandne linije. Funkciju za binarnu pretragu implementirati rekurzivno.
#include<stdio.h>
#define MAX 10
/* rekurzivno binarno pretrazivanje clana niza a koji je jednak sa x.
F-ja bin_pret vraca indeks (d..g) clana niza a
koji je jednak vrednosti od x ili -1 ako takav ne postoji */
int bin_pret(int a[], int d, int g, int x);
int main(int argc, char*argv[])
{
int n; /*dimenzija niza */
int a[MAX]; /*neopadajuci niz celih brojeva
sa ne vise od MAX elemenata*/
int x; /* element koji se trazi */
int poz; /* indeks onog clana niza cija je vrednost jednaka
vrednosti koja se trazi (ako postoji takav clan niza)*/
int pom; /* pomocna promenljiva pri kontroli unosa niza u odgivarajucem poretku */
int i; /* brojacka promenljiva */
do
{
printf("Unesite broj clanova niza izmedju 1 i %d\n", MAX);
scanf("%d", &n);
} while (n <1 || n >MAX) ;
printf("\ta[0]= ");
scanf("%d", &a[0]);
pom=a[0];
/* Unos clanova neopadajuceg niza celih brojeva */
for( i=1; i<n; i++)
{
printf("\ta[%d]= ", i);
scanf("%d", &pom);
if (pom < a[i-1])
{ printf("\nUNOS NE PODRZAVA NEOPADAJUCI POREDAK !!!\n");
break;
}
a[i]=pom;
}
if ( i != n) return (-1); /* PREKID RADA PROGRAMA zbog neodgovarajuceg unosa */
/* Prihvatanje elementa binarne pretrage iz komandne linije,
KONVERZIJA string argv[1]-> broj x
*/
sscanf(argv[1], "%d",&x);
/* binarna pretraga */
poz=bin_pret(a,0,n-1,x);
/* Ispis rezultata */
if(poz == -1)
printf("\nTrazeni broj se ne nalazi u nizu!\n");
else
printf("\nBroj %d se nalazi na %d poziciji unesenog sortiranig niza \n",x,poz+1);
return 0;
}
int bin_pret(int a[], int donja, int gornja, int x)
{ int sred ; /* sredina intervala pretrage*/
if (donja > gornja) /* traganje se prekida kada
duzina intervala pretrage postane < 0 */
return -1;
else
{
sred=(donja+gornja)/2; /* polovljenje intervala za pretragu */
if (x==a[sred]) return sred; /* nadjeno x u nizu a */
else
if (x < a[sred]) return bin_pret(a, donja,sred-1, x);
/*leva polovina tekuceg
intervala je kandidat
za pretragu */
else return bin_pret(a,sred+1,gornja, x);
/* desna polovina tekuceg intervala je
kandidat za novu pretragu */
}
} 134. NCP za rekurzivno racunanje faktorijela broja koji se unosi sa standardnog ulaza.
#include <stdio.h>
long factorial(int);
int main()
{
int n;
printf("Unesite broj\n");
scanf("%d", &n);
printf("%d\n", factorial(n));
return 0;
}
long factorial(int n)
{
if (n == 0) return 1;
else return n * factorial(n-1);
}
/* Iterativna verzija */
long factorial_it(int n)
{
long f = 1;
int i;
for (i = 1; i<=n; i++) f *= i;
return f;
}
135. Napisati rekurzivnu funkciju za racunanje proizvoljnog stepena celog broja x, a potom i C program koji poziva ovu funkciju, gde se broj x i zeljeni stepen unose sa standardnog ulaza.
#include <stdio.h>
float power(float x ,int n) ; /* f-ja racuna x^n */
int main()
{
float x;
int n;
printf("Unesite broj i zeljeni stepen: \n");
scanf("%f %d", &x, &n);
printf("%f\n", power(x, n));
return 0;
}
/* Iterativna verzija */
float power2(float x, int n)
{
int i;
float st = 1;
for (i = 0; i< n; i++) st *= n;
return st;
}
/* Rekurzivno, ali neefikasno */
float power1(float x, int n)
{
if (n == 0) return 1;
else return x * power1(x, n-1);
}
/* Rekurzivna funkcija */
float power(float x, int n)
{
if (n == 0) return 1;
else
{
int st = power(x, n/2);
st *= st * ((n%2)? x : 1);
return st;
}
}
136. NCP koji sa standardnog ulaza unosi najpre stepen (ceo broj manji od 10), a zatim i celobrojne koeficijente polinoma (pocevsi od koeficijenta uz najnizi stepen) a zatim stampa taj polinom u obliku:
P(x) = a[0]+a1 *x+ +a[n ]*x^n pri cemu ne stampa clanove ove sume koji su jednaki 0.
Na primer, za unete vrednosti:
2
2 1 3
program treba da ispise:
P(x) = 2 + 1 * x^1 + 3 * x^2
Na primer, za unete vrednosti:
2
2 0 3
program treba da ispisse:
P(x) = 2 + 3 * x^2
#include <stdio.h>
main()
{
int a[10]; /* koeficijenti polinoma */
int n; /* stepen polinoma */
printf("Unesite stepen polinoma:\n");
scanf("%d", &n);
printf("Unesite koeficijente polinoma pocevsi od koeficijenta uz najnizi stepen:\n);
for(i=0; i<=n; i++) scanf("%d", &a[i]);
/* Ispisivanje polinoma */
printf("P(x)= ");
if (a[0]) printf("%d", a[0]);
for(i=1; i<=n; i++)
if (a[i]) printf(" + %d*x^%d", a[i], i);
printf("\n");
}
137. NCP koji sa standardnog ulaza unosi najpre stepen (ceo broj manji od 100), a zatim i celobrojne koeficijente polinoma (pocevsi od koeficijenta uz najnizi stepen) i broj x. Na standardni izlaz stampati vrednost tog polinoma u tacki x.
#include <stdio.h>
main()
{
int n,i; /* stepen polinoma, brojac u ciklusu */
int a[100],x,P; /* niz koeficijenata polinoma, argument polinoma, vrednost polinoma u tacki x*/
printf("Unesite stepen polinoma: \n");
scanf("%d",&n);
for (i=0;i<=n;i++)
{
printf("\nUnesite a[%d]: ",i);
scanf("%d",&a[i]);
}
printf("Unesite X: ");
scanf("%d",&x);
P=0;
for (i=n;i>=0;i--) P=P*x+a[i]; /* KAKO SE ZOVE OVAJ POSTUPAK U LINEARNOJ ALGEBRI? */
printf("Vrednost polinoma je: %d\n",P);
}
Ulaz:
Unesite najveci stepen: 2
Unesite a[0]: 1
Unesite a[1]: 2
Unesite a[2]: 3
Unesite X: 4
Izlaz:
Vrednost polinoma je: 57.000000
138. KOMPAJLIRANJE PROJEKTA KOJI SE SASTOJI IZ VISE DATOTEKA
NCP
koji će učitati liniju limitirane duzine sa standardnog
ulaza i ispisati na standardni izlaz bez
a) malog slova 'x' b)
bez malih slova 'x', 'y' c) bez malog slova 'x' i slova y (bilo malo
ili veliko)
Implentaciju realizovati tako da potrebne funkcije budu implentirane u jednoj datoteci, a glavni program
u drugoj datoteci. (DEKOMPOZICIJA PROBLEMA NA POTPROBLEME)
PRIMER
|
ULAZ |
IZLAZ a) |
IZLAZ b) |
IZLAZ c) |
|---|---|---|---|
|
MAX xyzYYYZ |
MAX yzYYYZ |
MAX zYYYZ |
MAX zZ |
NAPOMENA: Slican zadatak se vec pojavljivao na vezbama (kao 86. po redu)
funkcije.c
/* datoteka u kom se nalaze potrebne funkcije projekta: squeeze i getline */
#include <string.h>
#include <stdio.h>
#include "funkcije.h"
void
squeeze( char niska[], int ch)
{
int indeks, tekuci;
/*brojacke promenljive */
for( indeks=tekuci=0; indeks <
strlen(niska); indeks++)
if(niska[indeks] != ch)
niska[tekuci++]=niska[indeks];
/*obavezno je
zavrsiti nisku na poziciji tekuci*/
niska[tekuci]='\0';
}
int getline( char lin[], int lim)
{int ch, indeks;
/* znak sa ulaza, brojac u ciklusu */
for( indeks=0;
indeks<lim-1 && (ch =getchar())!=EOF && ch!='\n';
++indeks) lin[indeks]=ch;
if( ch=='\n' ) lin[indeks++]=ch;
lin[indeks]='\0';
return indeks;
}
Interfejs ovih funkcija bice dat u datoteci funkcije.h
#ifndef funkcije_h
#define funkcije_h
/*
squeeze: uklanja znak ch iz stringa niska */
void squeeze( char
niska[], int ch) ;
/*
getline: ucitava liniju u nisku lin sa ne vise od lim karaktera i
vraca njenu duzinu */
int getline( char lin[], int lim);
#endif
U datoteci glavna.c se nalazi deo koda koji poziva i koristi funkcije implementirane u datoteci funkcije.c
#include <stdio.h>
#include "funkcije.h"
#define MAXLINE 1000
main()
{ int duz; /*
duzina ucitane linije */
char
linija[MAXLINE]; /* sadrzaj linije sa ulaza */
printf("Unesite red teksta \n");
duz=getline(linija,MAXLINE);
squeeze(linija,'x');
printf("Uneseni
tekst bez slova x \n");
printf("%s",
linija);
/* drugi po redu poziv f-je squeeze radi sa
linijom iz koje je prethodno izbaceno malo slovo 'x' */
squeeze(linija,'y');
printf("Uneseni
tekst bez slova x, y \n");
printf("%s",
linija);
squeeze(linija,'Y');
printf("Uneseni
tekst bez slova x, y, Y \n");
printf("%s",
linija);
return 0;
}
Dakle, ovaj projekat se sastoji iz tri datoteke:
funkcije.h, funkcije.c, glavna.c
KOMPAJLIRANJE:
gcc -c -o funkcije.o funkcije.c
gcc -c -o glavna.o glavna.c
gcc -o zad137 funkcije.o glavna.o
POKRETANJE programa:
zad137
OBJASNJENJE:
Iza opcija -o zadaje se ime izlazne datoteke u procesu kompilacije.
Opcija -c ukazuje da ce se pri komilaciji generisati samo objektne datoteke, tj. nece se vrsiti linkovanje. Objektne datoteke se prepoznaju po ekstenziji .o. Opcija -c se koristi za svaki projekat koji ima bar dve datoteke sa izbornim kodom:
najpre se koristeci opciju -c svaka od datoteka sa izvornim kodom prevede u odgovarajucu objektnu datoteku:
gcc -c -o funkcije.o funkcije.c
gcc -c -o glavna.o glavna.c
Potom se novim pozivom prevodioca izvrsi linkovanje tih objektnih datoteka:
gcc -o zad137 funkcije.o glavna.o
139. NCP koji ispisuje sve linije (sa ne vise od 99 karaktera) standardnog ulaza u kojima se pojavljuje niska for ili niska while.
#include <stdio.h>
/* Maksimalna duzina linije */
#define MAX_LINE 100
/* provera da li se sub sadrzi u str i vraca poziciju 1. pojave ili vraca -1 u slucaju neuspeha*/
int string_string(char str[], char sub[])
{
int i, j; /* brojaci u ciklusu */
/* Proverava da li sub pocinje na svakoj poziciji i */
for (i = 0; str[i]; i++)
/* Poredi se sub sa str pocevsi od poziciji i sve dok se ne naidje na razliku */
for (j = 0; str[i+j] == sub[j]; j++)
/* Nismo naisli na razliku a ispitali smo sve karaktere niske sub */
if (sub[j+1]=='\0') return i;
/* Nije nadjeno, neuspeh */
return -1;
}
main()
{
char line[MAX_LINE]; /* Niska karaktera koja ce da sadrzi tekucu liniju. */
/* Citamo linije sa standardnog ulaza (stdin) do nailaska na EOF */
while(fgets(line, MAX_LINE,stdin)!=NULL)
/* Ispisujemo one linije koje sadrze rec for ili rec while */
if (string_string(line, "for") != -1 || string_string(line, "while") != -1) printf("%s",line);
}
140. NCP koji pronalazi najduzu liniju sa ulaza. Nije poznat ukupan broj linija, ali svaka linija nema vise od 80 karaktera.
#include <stdio.h>
#include <string.h>
#define MAX_DUZINA_LINIJE 81
main()
{
char linija[MAX_DUZINA_LINIJE];
char najduza_linija[MAX_DUZINA_LINIJE];
int duzina_linije = 0;
int duzina_najduze_linije = 0;
najduza_linija[0] = '\0';
while( fgets(linija, MAX_DUZINA_LINIJE, stdin) != NULL)
{
duzina_linije=strlen(linija);
if (duzina_linije>duzina_najduze_linije)
{
strcpy(najduza_linija, linija);
duzina_najduze_linije = duzina_linije;
}
}
printf("Najduza linija je : %s\n",najduza_linija);
}
141.
a) Napisati f-ju prost(n) koja odredjuje da li je broj n prost.
b) NCP koji koristeci funkciju prost() stampa sve brojeve blizance do datog prirodnog broja n. Dva prirodna broja su blizanci ako su prosti i razlikuju se za 2 (npr. 3 i 5, 5 i 7, 11 i 13, itd.)
a) VIDI slicne zadatke sa vezbi
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;
}
b)
#include <stdio.h> #include <stdlib.h> int prost (int n); /*testira da li je broj n prost broj */
main()
{
int n, i;
scanf("%d", &n);
for (i = 3; i <= n-2; i+=2)
if (prost(i) && prost(i+2)) printf("%d %d ", i, i+2);
}
II nacin:
sa smanjenim brojem poziva funkcije prost()
#include <stdio.h> #include <stdlib.h> int prost (int n); /*testira da li je broj n prost broj */
main()
{
int n, i, prethodni, tekuci;
scanf("%d", &n);
prethodni = 0;
for(i = 3; i <=n; i+=2){
if (tekuci = prost(i) && prethodni) printf("%d %d", i-2, i);
prethodni = tekuci;
}
}
142. Implementirati algoritam za vracanje kusura za dati iznos n>=0 sa monetamama iz skupa {1, 5, 10, 20, 40, 50, 200, 500}. Broj n se ucitava sa standardnog ulaza.
IDEJA :
Neka u algoritmu KUSUR(n) je:
broj novcica od 1 dinara je g1
broj novcica od 5 dinara je g2
broj novcica od 10 dinara je g3
broj novcica od 20 dinara je g4
broj novcica od 40 dinara je g5
broj novcica od 50 dinara je g6
broj novcica od 200 dinara je g7
broj novcica od 500 dinara je g8
Pseudo-kod je implementacija ideje iz prethodnog zadatka. Sami implementirajte odgovarajuci C kod.
KUSUR(n)
g1 = 0; g2 = 0; g3 = 0; g4 = 0; g5 = 0;
g6 = 0; g7 = 0; g8 = 0;
while (n >= 500 )
{g8 = g8 + 1;
n = n − 500;
}
while (n >=200 ) {
g7 = g7 + 1;
n = n − 200;
}
while (n >= 50) {
g6 = g6 + 1;
n = n − 50;
}
while (n >= 40) {
g5 = g5 + 1;
n = n − 40;
}
while (n >= 20) {
g4 = g4 + 1;
n = n − 20;
}
while {n >= 10) {
g3 = g3 + 1;
n = n − 10;
}
while (n >=5) {
g2 = g2 + 1;
n = n − 1;
}
while (n >= 1)
{
g1 = g1 + 1;
n = n − 1;
}
ISPISATI NA STANDARDNI izlaz: g1, g2, g3, g4, g5, g6, g7, g8;
143. Sta je rezultat rada sledeceg programa:
#include <stdio.h>
#define max1(x,y) (x>y?x:y)
#define max2(x,y) ((x)>(y)?(x):(y))
#define swapint(x,y) { int z; z=x; x=y; y=z; }
#define swap(t,x,y) { \
t z; \
z=x; \
x=y; \
y=z; }
main()
{
int x=2,y=3;
printf( "max1(x,y) = %d\n", max1(x,y) );
/* max1(x,y) = 3 */
/* Zamena makroom se ne vrsi unutar niski pod navodnicima*/
printf( "max1(x=5,y) = %d\n", max1(x,y) );
/* max1(x=5,y) = 3 */
printf( "max1(x++,y++) = %d\n", max1(x++,y++) );
/* max1(x++,y++) = 4 */
printf( "x = %d, y = %d\n", x, y );
/* x = 3, y = 5 */
swapint(x,y);
printf( "x = %d, y = %d\n", x, y );
/* x = 5, y = 3 */
swap(int,x,y);
printf( "x = %d, y = %d\n", x, y );
/* x = 3, y = 5 */
}
Izlaz:
max1(x,y) = 3
max1(x=5,y) = 3
max1(x++,y++) = 4
x = 3, y = 5
x = 5, y = 3
x = 3, y = 5
144. NCP koji sa standardnog ulaza ucitava pozitivan ceo broj, a na standardni izlaz ispisuje vrednost tog broja sa razmenjenim vrednostima bitova na poziciji i, j. Pozicije i, j se ucitavaju kao parametri komandne linije. Smatrati da krajnji desni bit binarne reprezentacije je 0-ti bit.
Pri resavanju nije dozvoljeno koristiti pomocni niz niti aritmeticke operatore +,-,/,*,%.
#include <stdio.h>
unsigned Trampa(unsigned n, int i, int j); /* trampa i-tog, j-tog bita u broju n */
main(int argc, char **argv)
{
unsigned x; /*broj sa standardnog ulaza ciji se bitovi razmenjuju*/
int i,j; /*pozicije bitova za trampu*/
/*ocitavanje parametara komandne linije i broja sa standarnog ulaza*/
sscanf(argv[1], "%d", &i);
sscanf(argv[2], "%d", &j);
scanf("%u", &x);
printf("\nNakon trampe vrednost unetog broja je %u\n", Trampa(x,i,j));
}
unsigned Trampa(unsigned n, int i, int j)
{
/* ako se bit na poziciji i tj. bit (n>>i)&1 razlikuje od bita na poziciji j tj. bita (n>>j)&1, treba ih invertovati (operatorom ^) */
if ( ((n>>i)&1) != ((n>>j)&1) )
n^= (1<<i) | (1<<j);
return n;
}
145. NCP koji ce iz datoteke cije se ime zadaje kao argrument komandne linije ucitati
cele brojeve sve dok se ne ucita nula, i njihov zbir upisati u datoteku cije se ime takodje
zadaje kao argument komandne linije.
#include<stdio.h>
main(int argc, char* argv[])
{
int n, S=0; /* broj datoteke, suma brojeva */
FILE* ulaz, *izlaz;
/* Ukoliko su imena datoteka navedena kao argumenti...*/
if (argc>=3)
{
/* ...otvaramo datoteku i proveravamo da li smo uspeli */
if ( (ulaz = fopen(argv[1], "r")) == NULL)
printf("Greska : datoteka %s ne moze biti otvorena\n", argv[1]);
if ( (izlaz = fopen(argv[2], "w")) == NULL)
printf("Greska : datoteka %s ne moze biti otvorena\n", argv[2]);
}
fscanf(ulaz, "%d", &n);
while(n!=0)
{
S+=n;
fscanf(ulaz, "%d", &n);
}
fprintf(izlaz,"\nSuma brojeva ucitanih iz datoteke je %d.\n", S);
return 0;
}
ZADACI ZA VEZBU:
1. Napisati fukciju koja proverava da li je dati broj palindrom ako je on zadat kao: (a) ceo broj; (b) niska karaktera.
Na primer: broj 12321 jeste palindrom, broj 1231 nije palindrom (nema jednak sadrzaj ako se cita zdesna ulevo i sleva udesno).
2. Napisati funkciju koja za dati ceo broj n vraca vrednost celobrojnog dela korena od n (bez koriscenja funkcije sqrt).
3. Napisati program koji menja znak elemenata sa parnim indeksima u nizu a. Niz ima ne vise od 20 clanova i ucitava se iz datoteke ulaz.txt
4. Sa standradnog ulaza se ucitava broj n <=10 i elementi niza a[0],...a[2n]. Ispisati na standardni izlaz clanove niza b[0], ..., b[n]
tako da vazi b[i]=(a[i] + a[2n+1-i]) / 2
5. U komandnoj liniji su date vrednosti za a[0] i b[0]. Sa standardnog ulaza se unosi broj k. Ispisati na standardni izlaz clanove a[k] i b[k] ako se clanovi niza a i b formiraju na sledeci nacin:
a[i]= (a[i-1] + b[i-1]) /2, b[i]=a[i-1]*b[i-1].
6. U datoteci ulaz.txt dat je niz a sa ne vise od n clanova, n<=20. Na osnovu niza a formirati niz s tako da s[j] je srednja vrednost niza a bez j-tog elementa i niz s upisati u datoteku izlaz.txt.