elektrotehniČki fakultet univerziteta u...
TRANSCRIPT
ELEKTROTEHNIČKI FAKULTET UNIVERZITETA U BEOGRADU
PROGRAMIRANJE 2
MATERIJAL ZA PRIPREMU KOLOKVIJUMA
verzija: 26.03.2018.
Sadržaj:
OO1P2, popravni kolokvijum, jul 2008. (I način) ........................................................................ 2
OO1P2, popravni kolokvijum, jul 2008. (II način) ....................................................................... 3
OO1P2, kolokvijum, april 2009. ................................................................................................. 4
OO1P2, kolokvijum, april 2010. ................................................................................................. 5
OO1P2, popravni kolokvijum, jun 2010. ..................................................................................... 6
OO1P2, kolokvijum, april 2011. ................................................................................................. 7
OO1P2, kolokvijum, april 2012. ................................................................................................. 8
OO1P2, kolokvijum, april 2013. ................................................................................................. 9
OO1P2, popravni kolokvijum, jun 2013. ................................................................................... 10
OO1P2, kolokvijum, april 2014. ............................................................................................... 11
SI1P2, K1, mart 2011. ............................................................................................................ 12
SI1P2, K1, mart 2011. ............................................................................................................ 13
SI1P2, K1, mart 2012. ............................................................................................................ 14
SI1P2, K1, mart 2013. ............................................................................................................ 15
SI1P2, K1, mart 2014. ............................................................................................................ 16
SI1P2, K1, mart 2014. ............................................................................................................ 17
SI1P2, K1, mart 2015. ............................................................................................................ 18
SI1P2, popravni K1, jun 2015. ................................................................................................ 19
SI1P2, K1, mart, 2017. ........................................................................................................... 20
SI1P2, K1, mart 2018. ............................................................................................................ 21
Studentima se savetuje da programski kod ne uče napamet.
Za pisanje i testiranje rešenja zadataka se predlaže upotreba nekog od razvojnih okruženja.
OO1P2, popravni kolokvijum, jul 2008. (I način)
Zadatak
Napisati program na programskom jeziku C koji određuje da li su dva skupa celih brojeva, u opsegu od 0 do 15,
jednaka. Program treba da učita sa standardnog ulaza elemente skupova, najpre prvog a zatim drugog. Elementi skupova se unose u proizvoljnom redosledu, a dodavanje elementa koji već postoji u skupu se ignoriše. Nakon
završenog unosa elemenata skupova, program ispiše "Skupovi su jednaki" ili "Skupovi nisu jednaki" u zavisnosti od
ishoda poređenja. Program ponavlja prethodne korake (unos skupova i poređenje) sve dok korisnik ne naznači da želi da prekine program.
#include <stdio.h>
#define MAX_SKUP 16
main () {
int skup1[MAX_SKUP], skup2[MAX_SKUP];
int i, end=1, jednaki, b;
while (end) {
for(i=0;i<MAX_SKUP;i++) skup1[i]=skup2[i]=0;
printf("Unesite elemente prvog skupa: ");
while(1) {
scanf("%d",&b);
if ((b<0) || (b>=MAX_SKUP)) break;
skup1[b]=1;
}
printf("Unesite elemente drugog skupa: ");
while(1) {
scanf("%d",&b);
if ((b<0) || (b>=MAX_SKUP)) break;
skup2[b]=1;
}
jednaki=1;
for(i=0;i<MAX_SKUP;i++)
if (skup1[i]!=skup2[i]) {
jednaki=0;
break;
}
if (jednaki) printf("Skupovi su jednaki!\n");
else printf("Skupovi nisu jednaki!\n");
printf("0 za kraj, 1 za nastavak: ");
scanf("%d",&end);
}
}
OO1P2, popravni kolokvijum, jul 2008. (II način)
Zadatak
Napisati program na programskom jeziku C koji određuje da li su dva skupa celih brojeva, u opsegu od 0 do 15,
jednaka. Program treba da učita sa standardnog ulaza elemente skupova, najpre prvog a zatim drugog. Elementi skupova se unose u proizvoljnom redosledu, a dodavanje elementa koji već postoji u skupu se ignoriše. Nakon
završenog unosa elemenata skupova, program ispiše "Skupovi su jednaki" ili "Skupovi nisu jednaki" u zavisnosti od
ishoda poređenja. Program ponavlja prethodne korake (unos skupova i poređenje) sve dok korisnik ne naznači da želi da prekine program.
#include <stdio.h>
#define MAX_SKUP 16
void main () {
unsigned short skup1 = 0, skup2 = 0;
int i, end=1, b;
while (end) {
printf("Unesite elemente prvog skupa: ");
while(1) {
scanf("%d",&b);
if ((b<0) || (b>=MAX_SKUP)) break;
skup1 |= 1 << b;
}
printf("Unesite elemente drugog skupa: ");
while(1) {
scanf("%d",&b);
if ((b<0) || (b>=MAX_SKUP)) break;
skup2 |= 1 << b;
}
if (skup1 == skup2) printf("Skupovi su jednaki!\n");
else printf("Skupovi nisu jednaki!\n");
printf("0 za kraj, 1 za nastavak: ");
scanf("%d",&end);
}
} Napomena: Primetiti da je drugi način predstavljanja skupova znatno efikasniji sa stanovišta iskorišćenja memorije.
OO1P2, kolokvijum, april 2009.
Zadatak
Napisati program na programskom jeziku C kojim se u prazan jednodimenzioni niz celih brojeva umeću pozitivni celi
brojevi u nerastućem poretku. U niz ne treba umetati broj ako on već postoji. Brojevi se čitaju sa standardnog ulaza, a
unos se prekida kada korisnik unese vrednost koja nije pozitivna. Nakon unosa, program treba da ispiše sadržaj niza.
#include <stdio.h>
#define MAX 20
void main () {
int a[MAX], i, j, b, n, ind;
n = 0;
while (n < MAX) {
printf("\nUnesite broj: ");
scanf("%d",&b);
if (b<0) break;
for(i=ind=0;i<n || a[i]>b;i++) if (a[i]==b) ind=1;
if (ind) continue;
for (i=n-1; i>=0 && a[i]<b; i--) a[i+1] = a[i];
a[i+1] = b;
n++;
}
printf("\nUnesti niz: ");
for(i=0;i<n;i++) printf("%d ",a[i]);
}
OO1P2, kolokvijum, april 2010.
Zadatak
Neka se poruka sastoji od N (N ≤ 100) celobrojnih, osmobitnih reči, tipa unsigned char. Svaka reč poruke se sastoji od
jednog 7-bitnog broja koji zauzima najniže bitove reči, dok najviši bit (bit najveće težine) predstavlja bit parnosti. Bit parnosti se postavlja na vrednost 0 ukoliko je broj binarnih jedinica u preostalih 7 bita paran, a u suprotnom se
postavlja na vrednost 1. Napisati program na programskom jeziku C koji sa glavnog ulaza pročita dužinu poruke n,
zatim učitava n celih brojeva čije vrednosti mogu biti od 0 do 127 , a zatim za svaki od učitanih brojeva računa i u njegov najviši bit upisuje bit parnosti, da bi formirao ispravnu reč. Nakon toga, program ispiše dobijenu poruku.
Program ponavlja postupak sve dok se za dužinu niza n ne unese negativna vrednost.
#include <stdio.h>
#define N 100
void main () {
unsigned char a[N];
int i, j, n, odd;
while (1) {
printf("\nN? ");
scanf("%d", &n);
if (n <= 0 || n > N) break;
printf("Unesite poruku:\n");
for(i = 0; i < n; i++) scanf("%d", &a[i]);
for(i = 0; i < n; i++) {
odd = 0;
for(j = 0; j < 7; j++) odd += (a[i] >> j) & 1;
a[i] |= odd % 2 ? 0x80 : 0; //alternativno: odd & 1
}
printf("Poruka za slanje:\n");
for(i = 0; i < n; i++) printf("%u", a[i]);
}
}
Napomena: primetiti da zbog ograničenog opsega vrednosti od 0 do 127, binarna reprezentacija elemenata niza zauzima samo najnižih 7 bita broja. Primer računanja bita parnosti na dužini od 8 bita Broj: 7910 = 010011112 Broj sadrži 5 aktivnih bitova (jedinica) u binarnoj predstavi. Da bi se zadovoljilo pravilo za računanje bita parnosti, najviši bit je potrebno postaviti na vrednost 1. Broj nakon dodavanja bita parnosti: 110011112 = 20710 Broj: 7810 = 010011102 Broj sadrži 4 aktivna bita (jedinice) u binarnoj predstavi. Broj ne treba menjati, jer već ima paran broj jedinica i pravilo za računanje bita parnosti je zadovoljeno.
OO1P2, popravni kolokvijum, jun 2010.
Zadatak
Napisati program na programskom jeziku C koji odredi i ispiše najmanji neoznačeni ceo broj koji se može zapisati
proizvoljnim kombinovanjem heksadecimalnih cifara koje se pročitaju sa glavnog ulaza. Broj je potrebno ispisati u decimalnom i heksadecimalnom obliku. Pretpostaviti da se cifre od A do F predstavljaju isključivo velikim slovima
(ASCII kodovi cifara su manji od ASCII kodova velikih slova). Na primer, za unete cifre 5, C, 8, 5 i 2, najmanji ceo broj
je 2558C. Smatrati da se celi brojevi sastoje od najviše 6 cifara. Validnost unetih podataka ne treba proveravati.
#include <stdio.h>
#include <ctype.h>
#define N 6
void main () {
char broj[N+1], c;
int n = 0, vred, i, j;
while(((c = getchar()) != '\n') && (n < N)) {
if (!(isdigit(c) ||
(c >= 'A' && c <= 'F') ||
(c >= 'a' && c <= 'f'))) continue;
broj[n++] = c;
}
broj[n] = '\0';
for(i = 0; i < n-1; i++)
for(j = i+1; j < n; j++)
if (broj[i] > broj[j]) {
c = broj[i];
broj[i] = broj[j];
broj[j] = c;
}
sscanf(broj, "%x", &vred);
printf("Minimalna vrednost: %d %s", vred, broj);
}
OO1P2, kolokvijum, april 2011.
Zadatak
Napisati program na programskom jeziku C koji na slučajan način generiše dva niza realnih brojeva X i Y zadate
dužine koji predstavljaju koordinate tačaka u ravni. Prvo se unese dužina nizova, a zatim se generišu koordinate tačaka u opsegu[0.0, 1.0]. Nakon generisanja tačaka, iz nizova treba ukloniti sve one tačke koje ne pripadaju krugu
jediničnog poluprečnika čiji se centar nalazi u koordinatnom početku. Na kraju programa ispisati rezultujuće nizove,
tačku po tačku. Postupak ponavljati sve dok se za dužinu nizova ne unese nedozvoljena vrednost.
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#define N 100
void main () {
float x[N], y[N];
int i, j, n;
srand(time(NULL));
while (1) {
printf("\nUnesite broj tacaka: ");
scanf("%d", &n);
if (n <= 0 || n > N) break;
for(i=0; i<n; i++) {
x[i] = rand()/((float)RAND_MAX);
y[i] = rand()/((float)RAND_MAX);
}
for (i=j=0; i<n; i++)
if (x[i]*x[i] + y[i]*y[i] <= 1) {
x[j] = x[i];
y[j] = y[i];
j++;
}
n = j;
printf("\nTacke koje pripadaju krugu:\n");
for(i=0; i<n; i++) printf("(%f,%f) ", x[i], y[i]);
}
}
OO1P2, kolokvijum, april 2012.
Zadatak
Napisati program na programskom jeziku C koji vrši određenu obradu nad dva niza celih brojeva jednake dužine
(najviše 100 elemenata). Program treba da utvrdi i ispiše da li je prvi učitani niz moguće dobiti rotacijom drugog učitanog niza za odgovarajući broj mesta udesno, kao i broj mesta za koji ga je potrebno rotirati. Program najpre
treba da učita dimenziju nizova, zatim i same nizove. Na kraju, program treba da ispiše na standardnom izlazu ulazne
nizove i rezultat provere. Postupak ponavljati sve dok se za dužinu nizova ne unese nedozvoljena vrednost.
#include <stdio.h>
#define MAX 100
void main () {
int a[100], b[100], pom[100];
int i, j, n, rot = 0, jednaki = 0, temp;
while (1) {
printf("Unesite duzinu nizova: ");
scanf("%d", &n);
if (n <= 0 || n > MAX) break;
printf("Unesite prvi niz: ");
for(i = 0; i < n; i++) scanf("%d", &a[i]);
printf("Unesite drugi niz: ");
for(i = 0; i < n; i++) {
scanf("%d", &b[i]);
pom[i] = b[i];
}
rot = 0;
for(i = 0; i < n; i++) {
jednaki = 1;
for(j = 0; j < n; j++)
if (a[j] != pom[j]) {
jednaki = 0;
break;
}
if (jednaki) break;
rot++;
temp = pom[n-1];
for (j = n-1; j > 0; j--) pom[j] = pom[j-1];
pom[0] = temp;
}
printf("Niz A: ");
for(i = 0; i < n; i++) printf("%d ", a[i]);
printf("\nNiz B: ");
for(i = 0; i < n; i++) printf("%d ", b[i]);
if (jednaki)
printf("\nNiz A se dobija rotacijom niza B za %d mesta udesno!\n",
rot);
else
printf("\nNiz A se ne moze dobiti rotacijom niza B!\n");
}
} Napomena: Zadatak se jednostavno može rešiti i bez upotrebe pomoćnog niza.
OO1P2, kolokvijum, april 2013.
Zadatak
Napisati program na programskom jeziku C koji vrši određenu obradu nad nizom celih brojeva. Niz može sadržati
najviše 100 elemenata. Program najpre treba da učita dužinu niza i same elemente niza, a zatim na standardnom izlazu ispiše svaki element niza kao zbir stepena dvojke od kojih se on sastoji. Obezbediti da se u niz mogu uneti samo
pozitivni celi brojevi. Ukoliko korisnik unese negativan broj ili nulu ponovo zatražiti unos. Prilikom ispisa usvojiti format
izlaza kao što je u primeru. Postupak ponavljati sve dok se za dužinu niza ne unese nekorektna vrednost.
Primer ulaza Primer izlaza
n = 4
Niz: 13 6 21 4
13 = 2^3 + 2^2 + 2^0
6 = 2^2 + 2^1 21 = 2^4 + 2^2 + 2^0
4 = 2^2
#include <stdio.h>
#define MAX 100
void main(){
int n, a[MAX], i, j;
while(1){
scanf("%d", &n);
if(n<=0 || n>MAX) break;
for (i = 0; i < n; ++i){
a[i] = 0;
while(a[i] <= 0) scanf("%d", &a[i]);
}
for (i = 0; i < n; ++i){
int isFirst = 1;
printf("\n%d = ", a[i]);
for(j = sizeof(int)*8 - 1; j >= 0; j--)
if(a[i] & 1 << j){
if(!isFirst) printf(" + "); // print the plus if not first
else isFirst = 0; // clear the flag
printf("2^%d", j);
}
putchar('\n');
}
}
Napomene: Obratiti pažnju da je broj potrebno kao sumu stepena dvojke počevši od člana najveće težine ka članu najmanje težine. Takođe, nakon poslednjeg člana sume ne treba ispisati znak +. Bitsko maskiranje i provera se mogu izvršiti i na drugačiji način:
unsigned int mask = 1 << (sizeof(int)*8-1), j = sizeof(int)*8-1;
for(; mask; mask >>=1, j--)
if(a[i] & mask){
printf("%c 2^%d", isFirst ? '' : '+', j);
if(isFirst) isFirst = 0; // clear the flag
}
OO1P2, popravni kolokvijum, jun 2013.
Zadatak
Napisati program na programskom jeziku C koji obrađuje poene studenata osvojene na ispitu. Rezultati studenata na
ispitu su predstavljeni pomoću dva niza celih brojeva, gde prvi niz predstavlja niz osmocifrenih brojeva indeksa studenata u formi ggggiiii (npr. 20130001 predstavlja broj indeksa 2013/0001), a drugi niz sadrži poene koje je
student, čiji je broj indeksa u prvom nizu na odgovarajućoj poziciji, osvojio na ispitu. Niz poena se na početku
inicijalizuje nulama. Program učitava prvo broj studenata, a zatim i niz sa brojevima indeksa studenata u kome nema ponavljanja. Korisnik potom unosi poene studentima, tako što u svakom redu unese broj indeksa željenog studenta, a
onda i broj poena koje mu želi dodati. Moguće je više puta uneti poene za istog studenta, pri čemu se poeni sabiraju. Unos poena se ponavlja sve dok se ne unese broj indeksa koji ne postoji u nizu indeksa. Nakon unosa, program treba
da odredi i ispiše prosečan broja poena na ispitu za generaciju čija se godina upisa (podatak gggg iz indeksa) unese
sa standardnog ulaza.
#include <stdio.h>
#define MAX 50
void main(){
int niz_indeksi[MAX], niz_poeni[MAX];
int indeks, poeni, n, godina, suma, broj, i, j, poz;
for(i = 0; i < MAX; i++) // ili inicijalizacija niz_poeni[MAX]={0};
niz_poeni[i] = 0;
printf("Broj studenata? "); scanf("%d", &n);
// provera prekoracenja
if(n>MAX || n<=0){
printf("Nekorektan broj studenata.\n");
return;
}
// ucitavanje indeksa
for(i=0; i<n; i++) scanf("%d", &niz_indeksi[i]);
// ucitavanje poena
while(1){
printf("indeks poeni? ");
scanf("%d %d", &indeks, &poeni); // dozvoljene negativne vrednosti
// pretraga pozicije indeksa
for(j=0; j < n; j++)
if(niz_indeksi[j]==indeks) break;
// prekid unosa poena
if(j==n) break;
// dodavanje poena
niz_poeni[j]+=poeni;
}
printf("Godina upisa? "); scanf("%d", &godina);
suma = broj = 0;
for(i=0; i<n; i++){
// provera pripadnosti generaciji
if(niz_indeksi[i]/10000 == godina){
suma+=niz_poeni[i];
broj++;
}
}
if(broj>0)
printf("Prosecan broj poena za generaciju %d iznosi %lf", godina,
(double)suma/broj);
else
printf("Nema podataka o generaciji %d.\n", godina);
}
OO1P2, kolokvijum, april 2014.
Zadatak
Napisati program na programskom jeziku C koji vrši simulaciju promene broja stanovnika u gradovima. Program
najpre učita broj gradova koje će obrađivati (najviše 100) i broj godina za simulaciju, a zatim brojeve stanovnika za sve gradove. Simulacija se radi na sledeći način: na godišnjem nivou broj stanovnika u svakom gradu se promeni za
slučajan broj koji je u opsegu od -1% do +1% broja stanovnika u gradu na početku godine. Za svaku godinu u
simulaciji u zasebnom redu treba ispisati brojeve stanovnika koje svaki grad ima na kraju te godine. Kada se završi simulacija, ispisati broj stanovnika za najnaseljeniji grad. U slučaju da se sa standardnog ulaza unese nekorektna
vrednost za bilo koji podatak, ispisati odgovarajuću poruku i prekinuti izvršavanje programa.
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
void main() {
int godine, n, i, j, max, int gradovi[MAX];
double slucajan;
printf("Unesite broj gradova: ");
scanf("%d", &n);
if (n < 1 || n > MAX) {
printf("Greska: Broj gradova je neodgovarajuci.\n");
exit(1);
}
printf("Unesite broj stanovnika za gradove:\n");
for (i = 0; i < n; i++){
scanf("%d", &gradovi[i]);
if (gradovi[i] < 2) {
printf("Greska: Broj stanovnika grada je
neodgovarajuci.\n"); exit(1);
}
}
printf("Unesite broj godina: ");
scanf("%d", &godine);
if (godine < 1) {
printf("Greska: Broj godina je neodgovarajuci.\n"); exit(1);
}
for (i = 0; i < godine; i++) {
for (j = 0; j < n; j++) {
slucajan = rand() / (double)RAND_MAX * 2 - 1;
gradovi[j] += gradovi[j] * slucajan / 100;
if (gradovi[j] < 2) {
printf("Greska: Broj stanovnika grada je
neodgovarajuci.\n"); exit(1);
}
}
for (j = 0; j < n; j++)
printf("%d ", gradovi[j]);
printf("\n");
}
max = gradovi[0];
for (i = 0; i < n; i++)
if (max < gradovi[i])
max = gradovi[i];
printf("Grad sa najvecim brojem stanovnika je %d.\n", max);
}
SI1P2, K1, mart 2011.
Zadatak 1.
Napisati program na programskom jeziku C koji generiše pseudoslučajan broj u opsegu od 10 do 10000, a zatim vrši
proveru da li je generisani broj Fibonačijev broj. Fibonačijevi brojevi se računaju po formuli f0=1, f1=1, fn=fn-1 + fn-2, a
generisane brojeve je potrebno ispisivati na standardnom izlazu. Na kraju programa ispisati rezultat provere.
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define LOW 10
#define HIGH 10000
void main () {
int broj, f0, f1, f2;
srand(time(NULL));
broj = rand()/((double)RAND_MAX)*(HIGH - LOW) + LOW;
printf("Pseudoslucajni broj: %d\n", broj);
printf("Generisem Fibonacijeve brojeve: \n");
for(f0=f1=f2=1; f2 < broj;) {
f0 = f1;
f1 = f2;
f2 = f0 + f1;
printf("%d ", f2);
}
putchar('\n');
if (f2 == broj)
printf("Generisani broj je Fibonacijev broj.\n");
else
printf("Generisani broj nije Fibonacijev broj.\n");
}
SI1P2, K1, mart 2011.
Zadatak 2.
Napisati program na programskom jeziku C koji sa glavnog ulaza učitava niz od 12 realnih brojeva koji predstavljaju
prosečnu mesečnu temperaturu za svaki mesec u godini. Program treba da izračuna i ispiše na standardnom izlazu prosečnu temperaturu po kvartalima (tromesečjima) u toku zadate godine, kao i redni broj kvartala sa najmanjom i
najvećom prosečnom temperaturom. Program treba da ponavlja prethodni postupak sve dok korisnik ne učita sve
vrednosti 0 u ulazni niz.
#include <stdio.h>
#define BROJ_MESECI 12
#define KVARTALI 4
#define KVARTAL 3
void main () {
double temperature[BROJ_MESECI], kvartali[KVARTALI] = {0};
int i, min, max, uslov;
while(1) {
printf("Unesite prosecne mesecne temperature: ");
for(i=0; i<BROJ_MESECI; i++) scanf("%lf", &temperature[i]);
for(uslov=i=0; i<BROJ_MESECI; i++) uslov = uslov || (int)temperature[i];
if (!uslov) break;
for(i=0; i<KVARTAL; i++) {
kvartali[0] += temperature[i + 0*KVARTAL];
kvartali[1] += temperature[i + 1*KVARTAL];
kvartali[2] += temperature[i + 2*KVARTAL];
kvartali[3] += temperature[i + 3*KVARTAL];
}
printf("Prosecna temperatura po kvartalima: \n");
for(i=0; i<KVARTALI; i++) {
kvartali[i] /= KVARTAL;
printf("%d: %2.2f\n", i, kvartali[i]);
}
min = max = 0;
for(i=1; i<KVARTAL; i++) {
if (kvartali[i] < kvartali[min]) min = i;
if (kvartali[i] > kvartali[max]) max = i;
}
printf("\nKvartal sa najmanjom prosecnom temperaturom: %d\n", min);
printf("Kvartal sa najvecom prosecnom temperaturom: %d\n", max);
}
}
SI1P2, K1, mart 2012.
Zadatak 1.
Vrednost broja PI se može statistički odrediti uz pomoć generatora pseudoslučajnih
brojeva uniformne raspodele. Potrebno je generisati tačke u ravni sa obema koordinatama u realnom opsegu [0, 1]. Vrednost broja PI se tada može odrediti na
osnovu odnosa broja tačaka koje se nalaze u delu kruga poluprečnika 1 sa centrom u
koordinatnom početku (Tc) i broja tačaka koje pripadaju kvadratu stranice 1 koji obuhvata sve generisane tačke (Tu) pomoću sledeće formule:
u
c
T
T 4
Napisati program na programskom jeziku C koji izračunava vrednost broja PI. Program treba da učita ukupan broj
tačaka koji treba da budu generisan, izračuna vrednost broja PI i ispiše rezultat. Program treba da ponavlja opisane
korake sve dok se za broj tačaka unosi pozitivna vrednost..
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
void main () {
double x1, y1, d, pi;
int i, in_circle = 0, n;
srand(time(NULL));
while(1) {
printf("Unesi broj tacaka koji treba generisati: ");
scanf("%d", &n);
if (n <= 0) break;
for (i = 0; i < n ; i++) {
x1 = rand()/(double)RAND_MAX;
y1 = rand()/(double)RAND_MAX;
d = sqrt(x1*x1 + y1*y1);
in_circle += (d <= 1.0) ? 1 : 0;
}
pi = (double)4*in_circle/n;
printf("Izracunata vrednost PI: %f\n", pi);
}
}
SI1P2, K1, mart 2013.
Zadatak 2.
Napisati program na programskom jeziku C koji sa standardnog ulaza učitava niz od najviše 100 celih brojeva, a zatim
proverava da li uneti niz predstavlja bitoničku sekvencu. Bitonička sekvenca je sekvenca brojeva koja se sastoji od jedne monotono neopadajuće i jedne monotono nerastuće sekvence brojeva ili obratno (x0 ≤ ... ≤ xk ≥ ... ≥ xn-1 ili
x0 ≥ ... ≥ xk ≤ ... ≤ xn-1, gde 0 ≤ k < n). Program treba da učita dužinu i elemente niza, a zatim izvrši proveru i ispiše
odgovarajuću poruku. Obezbediti da se u niz mogu uneti samo brojevi u opsegu od 0 do 50. Ukoliko korisnik unese broj van tog opsega ponovo zatražiti unos. Program treba da ponavlja opisane korake sve dok se za dužinu niza ne
unese nekorektna vrednost.
#include <stdio.h>
#define MAX 100
void main () {
int niz[MAX], i, n, provera, tranzicija;
while(1) {
printf("Unesite duzinu niza: \n");
scanf("%d", &n);
if (n <= 0 || n > MAX) break;
printf("Unesite elemente niza u opsegu 0..50: \n");
for(i = 0; i < n; i++) {
int broj;
scanf("%d", &broj);
while (broj < 0 || broj > 50) {
printf("Broj van opsega! Unesite ponovo: \n");
scanf("%d", &broj);
}
niz[i] = broj;
}
if (n == 1) { printf("Sekvenca je bitonicka!\n"); continue; }
provera = 0;
tranzicija = 0;
for (i = 1; i < n; i++) {
if (niz[i-1] < niz[i]) {
if (provera == 0) provera = 1;
else if (provera == -1) {
tranzicija++;
provera = 1;
}
}
else if (niz[i-1] > niz[i]) {
if (provera == 0) provera = -1;
else if (provera == 1) {
tranzicija++;
provera = -1;
}
}
}
if (tranzicija == 1) printf("Sekvenca je bitonicka!\n");
else printf("Sekvenca nije bitonicka!\n");
}
}
SI1P2, K1, mart 2014.
Zadatak 1.
Napisati program na programskom jeziku C koji sa standardnog ulaza učitava ceo broj tipa unsigned int (pretpostaviti
da je za smeštanje jednog podatka tog tipa potrebno 16 bita), a potom proverava da li je bitska reprezentacija tog broja, posmatrana od bita najveće težine ka bitu najmanje težine, komplementarna u odnosu na bitsku reprezentaciju
posmatranu od bita namanje težine ka bitu najveće težine. U slučaju da jeste, na standardnom izlazu treba ispisati
poruku “DA“, u suprotnom poruku “NE“. Pimer: binarna reprezentacija broja 48322 je 1011110011000010, pa se ispisuje poruka “DA“.
#include<stdio.h>
int main(){
unsigned int broj, dmaska = 0x0001, lmaska = 0x8000, i, da = 1;
scanf("%d", &broj);
for (i = 0; i < 8 && da; i++, lmaska >>= 1, dmaska <<= 1)
if (!((broj & dmaska) ^ ((broj & lmaska) >> (15 - i * 2))))
da = 0;
if (da) printf("DA");
else printf("NE");
}
SI1P2, K1, mart 2014.
Zadatak 2.
Napisati program na programskom jeziku C koji uređuje zadati niz od najviše 100 celih brojeva tako da sadrži prvo
neparne brojeve u nerastućem po retku, a zatim parne brojeve u neopadajućemporetku. Elementi niza se inicijalizuju sekvencom pseudoslučajnih celih brojeva u opsegu [100,200]. Program najpre učita dužinu niza brojeva, zatim
gainicijalizuje sekvencom pseudoslučajnih brojeva izzadatog opsega, sortira elemente prema zadatom kriterijumu i na
kraju ispiše rezultujući niz.Navedeni koraci se ponavljaju sve dok se za dužinuniza ne unese nekorektna vrednost.
#include <stdio.h>
#include <stdlib.h>
#define DIM 100
void main() {
int a[DIM], n, i, j, tmp, xchg;
while (1) {
printf("Unesite broj elemenata:\n");
scanf("%d", &n);
if (n < 1 || n > DIM) break;
printf("Generisani niz:\n");
for (i = 0; i < n; i++){
a[i] = ((double)rand() / RAND_MAX)*100 + 100;
printf("%d%c", a[i], (i == n - 1) ? '\n' : ' ');
}
for (i = 0; i < n;i++)
for (j = i + 1; j < n; j++){
int i_paran, j_paran;
i_paran = 0 == a[i] % 2;
j_paran = 0 == a[j] % 2;
xchg = i_paran && !j_paran;
xchg = xchg || (i_paran && j_paran && a[i] < a[j]);
xchg = xchg || (!i_paran && !j_paran && a[i] > a[j]);
if (xchg) {
tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
}
printf("Obradjeni niz:\n");
for (i = 0; i < n; i++){
printf("%d%c", a[i], (i == n - 1) ? '\n' : ' ');
}
}
}
SI1P2, K1, mart 2015.
Zadatak 1.
Napisati program na programskom jeziku C koji pretražuje binarnu predstavu broja radi pronalaženja svih pojava
zadate binarne sekvence. Program treba sa standardnog ulaza da učita dva broja tipa unsigned int (pretpostaviti da je veličina tipa 16 bita). Prvo se učitava broj koji se pretražuje. Iz binarne predstave drugog učitanog broja izdvaja se
deo između binarnih jedinica najmanje i najveće težine (uključujući i njih), pa to predstavlja sekvencu koja se traži.
Pretraživanje se vrši počevši od cifre najveće težine. Program treba da ispiše sve početne pozicije u prvom broju gde je nađen zadati sadržaj (pozicija najveće težine je 15). Na primer neka je prvi broj 0x5B5A, a drugi broj 0x0168.
Pozicije koje treba ispisati su: 14, 11 i 6.
#include <stdio.h>
#define SIZE 16
void main() {
unsigned int a, b, mask, ones;
int first_one, last_one, i, find_start, iter;
printf("Unesite dva broja (drugi broj se pretrazuje u prvom)?\n");
scanf("%x%x", &a, &b);
mask = 1;
find_start = 1;
for (i = 0; i < SIZE; i++){
if (mask & b) {
if (find_start) {
first_one = i;
find_start = 0;
}
last_one = i;
}
mask <<= 1;
}
if (find_start) {
printf("Drugi broj je jednak nuli\n");
return;
}
ones = (1 << last_one – first_one + 2) – 1;
mask = b << (SIZE - 1) - last_one;
ones = ones << (SIZE – 1) – last_one;
iter = SIZE - (last_one - first_one + 1);
for (i = 0; i < iter; i++) {
if (ones & a) == mask)
printf("%d ", (SIZE - i) - 1);
mask >>= 1;
ones >>= 1;
}
}
SI1P2, popravni K1, jun 2015.
Zadatak 1.
Napisati program na programskom jeziku C koji obađuje niz celih neoznačenih brojeva. Program sa standardnog ulaza
učita broj elemenata niza i elemente niza, zatim iz niza izbaci sve elemente u čijoj binarnoj reprezentaciji ima više parova susednih jedinica od prosečnog broja parova susednih jedinica u reprezentacijama svih unetih brojeva, uredi
preostale elemente niza po nerastućoj vrednosti elemenata i na kraju ispiše sadržaj rezultujućeg niza. Prilikom
prebrojavanja parova jedna jedinica može da bude deo dva para (npr. u broju 10011101 postoje 2 para susednih jedinica). Smatrati da niz ima najviše 100 elemenata. Za svaki uneti broj dozvoljeno je najviše jednom računati broj
parova susednih jedinica, pa je izračunatu vrednost potrebno čuvati u pomoćnom nizu. Osim dva pomenuta niza nije
dozvoljeno koristiti druge pomoćne nizove.
#include <stdio.h>
#define MAX 100
void main() {
unsigned brojevi[100], parovi[100], n, i, j, mask;
double srednja_vrednost;
scanf("%u", &n);
if (n < 1 || n > MAX)
return;
for (i = 0; i < n; i++)
scanf("%u", &brojevi[i]);
srednja_vrednost = 0;
for (i = 0; i < n; i++) {
mask = 3;
parovi[i] = 0;
for (j = 0; j < sizeof(unsigned) * 8 - 1; j++) {
if ((mask & brojevi[i]) == mask)
parovi[i]++;
mask <<= 1;
}
srednja_vrednost += parovi[i];
}
srednja_vrednost /= n;
for (i = j = 0; i < n; i++)
if (parovi[i] <= srednja_vrednost)
brojevi[j++] = brojevi[i];
n = j;
for (i = 0; i < n; i++)
for (j = i + 1; j < n; j++)
if (brojevi[i] < brojevi[j]) {
unsigned tmp = brojevi[i];
brojevi[i] = brojevi[j];
brojevi[j] = tmp;
}
for (i = 0; i < n; i++)
printf("%u ", brojevi[i]);
putchar('\n');
}
SI1P2, K1, mart, 2017.
Zadatak
Napisati program na programskom jeziku C koji vrši konverziju realnog broja iz binarnog u decimalni oblik. Realan broj
u binarnom brojnom sistemu se zadaje kao niz znakova koji može sadržati samo cifre 0, 1 i eventualnu decimalnu tačku. Program treba da učita niz znakova sa standardnog ulaza do kraja tekućeg reda, izvrši konverziju zadatog broja
u odgovarajući realni tip programskog jezika C i ispiše rezultat u decimalnom brojnom sistemu. Prlikom učitavanja,
obezbediti da korisnik unosi samo dozvoljene znakove, a u slučaju unošenja nedozvoljenog znaka zahtevati ponovni unos. Smatrati da niz znakova nije duži od 50 elemenata i obezbediti prekid unosa, ukoliko korisnik pokuša da unese
više znakova. #include <stdio.h>
#define MAX 50
int main() {
char broj[MAX], znak, tacka = 0;
int i, n;
double ceo_deo = 0, realni_deo = 0, realni;
printf("Unesite broj u binarnom obliku:\n");
n = 0;
while ((znak = getchar()) != '\n' && n < MAX) {
broj[n++] = znak;
}
for (i = 0; i < n; i++) {
znak = broj[i];
while (znak != '0' && znak != '1' && znak != '.') {
printf("Uneli ste nedozvoljeni znak, ponovite unos!\n");
znak = getchar();
}
if (znak == '.') tacka++;
broj[i] = znak;
}
if (n == 0) {
printf("Niz je prazan!\n");
} else if (tacka > 1) {
printf("Broj je neispravan!\n");
} else {
i = 0;
if (broj[i] != '.') {
ceo_deo = broj[0] - '0';
while (++i < n && broj[i] != '.')
ceo_deo = ceo_deo * 2 + (broj[i] - '0');
}
if (i < n)
while (i < --n)
realni_deo = (realni_deo + broj[n] - '0') / 2;
realni = ceo_deo + realni_deo;
printf("Konvertovani broj je: %f\n", realni);
}
return 0;
}
SI1P2, K1, mart 2018.
Zadatak
Napisati program na programskom jeziku C koji računa pobednika u nekoj kartaškoj igri. Igra se igra sa 52 karte.
Karta je određena vrednošću i znakom. Vrednost može biti ceo broj od 2 do 14. Postoje četiri znaka čije su
jednoslovne oznake K, H, T i P. Korisnik u prvom redu na standardnom ulazu unosi broj igrača N koji igraju igru, kao i glavni znak u partiji. Maksimalan broj igrača je 10. Nakon toga se u N redova, za svakog igrača u posebnom redu,
unose karte koje poseduje. Broj karata koje jedan igrač ima je 5. Za svaku kartu se unosi vrednost karte i znak, odvojeni tačno jednim razmakom. Karte u redu su međusobno odvojene jednim razmakom. Broj poena koje jedan
igrač ima računa se kao zbir poena koje svaka karta koju ima nosi. Broj poena za kartu koja ima vrednost manju od
10 je isti kao i njena vrednost. Broj poena za kartu koja ima vrednost veću ili jednaku 10 je 10. Ukoliko je znak neke karte isti kao i glavni znak u partiji, broj poena se za tu kartu duplira. Program treba da ispiše redni broj igrača (od 1
do N) i broj poena koji je osvojio taj igrač, i to u posebnim redovima, u nerastućem poretku broja poena. Smatrati da
je ulaz ispravan.
#include <stdio.h>
#define MAX_NUMBER_OF_PLAYERS 10
#define NUMBER_OF_CARDS 5
#define MAX_CARD_VALUE 10
void main() {
int numberOfPlayers, players[MAX_NUMBER_OF_PLAYERS],
points[MAX_NUMBER_OF_PLAYERS], cardValue, i, j, temp;
char cardSign, mainSign;
scanf("%d %c", &numberOfPlayers, &mainSign);
for (i = 0; i < numberOfPlayers; i++) {
players[i] = i + 1; points[i] = 0;
for (j = 0; j < NUMBER_OF_CARDS; j++) {
scanf("%d %c", &cardValue, &cardSign);
if (cardValue > MAX_CARD_VALUE) {
cardValue = MAX_CARD_VALUE;
}
if (cardSign == mainSign) {
cardValue *= 2;
}
points[i] += cardValue;
}
}
for (i = 0; i < (numberOfPlayers - 1); i++)
for (j = (i + 1); j < numberOfPlayers; j++) {
if (points[i] < points[j]) {
temp = points[i];
points[i] = points[j];
points[j] = temp;
temp = players[i];
players[i] = players[j];
players[j] = temp;
}
}
for (i = 0; i < numberOfPlayers; i++)
printf("%d %d\n", players[i], points[i]);
}