You are currently browsing the monthly archive for Listopad 2008.
Witam. Rozwiązania zadań nie pojawią się ponieważ w xero są juz zrobione all wiec nie ma potrzeby.
pozdrawiam
1. Zadeklarować jednowymiarową tablicę tab[TAB_SIZE] typu int. Zainicjować ją w deklaracji.
a) Obliczyć sumę elementów tablicy stosując różne konstrukcje: tab[i], tab+i, ptr+i, ptr++, gdzie ptr jest wskaźnikiem do typu int,
b) zliczyć elementy tablicy spełniające określony warunek (równy n, mniejszy/większy od n, w przedziale <n,m>,
c) zastąpić każdy element tablicy jego sumą z elementem następnym. Dla ostatniego elementu tablicy jako następny przyjąć pierwszy element tablicy.
int cos[tab_size]={0,0,0,3,4,5};
lub
int cos[]={0,0,0,3,4,5};
int suma = 0;
int *ptr = NULL;
a)
for(int i=0; i < tab_size; i++)suma += cos[i];
for(int i=0; i < tab_size; i++)suma += *(tab+i);
ptr = cos;
for(int i=0; i < tab_size; i++)suma += *(ptr+i);
ptr = cos;
while(ptr < ptr+tab_size)suma += *(ptr++);
b)
int a,b,c;
for(int i=0; i < tab_size; i++){
wiekszy) if( n > cos[i])suma += cos[i];
mniejszy) if( n < cos[i])suma += cos[i];
zalezny) if(n > cos[i] && cos[i] < m )suma += cos[i];
}
c)
for(int i=0; i < tab_size; i++){
cos[i] += cos[(i+1)%tab_size];
}
2. Napisać funkcję, która dla tablicy jednowymiarowej wykona następującą operację:
a) określenie wartości elementu maksymalnego,
b) określenie wartości elementu maksymalnego i jego pozycji,
c) odwrócenie kolejności elementów w tablicy,
d) uporządkowanie tablicy rosnąco,
e) uporządkowanie tablicy rosnąco lub malejąco (wybór – parametr funkcji).
Uwaga: Funkcja powinna być tak zaprojektowana, aby można było ją było wykorzystać dla różnych tablic o różnej liczbie elementów.
a+b)
int foo_max(int tab[], int rozmiar, int *index){
int max = 0;
int index = 0;
for(int i=0; i < tab_size; i++){
if( tab[i] >max){
max = tab[i];
(*index) = i;
}
}
return max;
}
c)
void swap(int tab[], int rozmiar){
int temp;
for(int i=0; i < tab_size/2; i++){
temp = cos[tab_size-1-i];
cos[tab_size-1-i] = cos[i];
cos[i] = temp;
}
}
d) bombelkowo zapisac:
int BubbleSort(int num[], int numel)
{
int i, j, grade, moves = 0;
for ( i = 0; i < (numel – 1); i++)
{
for(j = 1; j < numel; j++)
{
if (num[j] < num[j-1])
{
grade = num[j];
num[j] = num[j-1];
num[j-1] = grade;
moves++;
}
}
}
return moves;
}
Podobnie e) tylko że:
function sort(int num[], int numel, bool direction){
if(direction){
}else{
}
}
3. Napisać funkcję, która dla dwóch tablic jednowymiarowych wykona ich sumowanie, umieszczając wynik w pierwszej tablicy
function sort(int num[], int num[], int numel){
for(int i=0; i < tab_size; i++)num[i]+=num2[i];
}
4. Napisać funkcję, która dla podanego (jako parametr) łańcucha znakowego (stringu) wykona następującą operację:
a) obliczenie długości stringu,
b) znalezienie pierwszego wystąpienia zadanego znaku,
c) policzenie liczby wystąpień zadanego znaku w stringu,
d) odwrócenie kolejności znaków (czyli zamiana typu: napis ® sipan).
Uwaga: Nie używać żadnych funkcji bibliotecznych, np. strlen().
a)
int lenght(char* str){
char *temp = str;
while((*temp) != ”)temp++;
return temp – str;
}
b)
int count_char(char* str, char sign){
int counter = 0;
while( (*temp++) != sign))counter++;
return counter;
}
c)
// J
int count_char(char* str, char sign){
int i = 0;
for( ; *(temp+i) != sign; i++);
reurnt i;
}
5. Napisać funkcję, której przekazujemy wartość typu unsigned char. Funkcja powinna zwrócić:
a) liczbę bitów niezerowych,
b) pozycję pierwszego niezerowego bitu (przeglądamy od najmłodszej pozycji),
c) przekazaną wartość po odwróceniu bitów (np. 1001 0111 ® 1110 1001),
d) przekazaną wartość po zamianie połówek bajtu (np. 1001 0111 ® 0111 1001).
a)
int foo(unsigned char cos){
int counter = 0;
for(int i = 0; i < 8*sizeof(unsigned char); i++){
if(cos<<1)counter++;
}
reutrn counter;
}
b)
int foo(unsigned char cos){
int counter = 0;
for(int i = 0; i < 8*sizeof(unsigned char); i++){
if(cos<<1)reutrn counter++;
}
reutrn counter;
}
c)
unsigned char foo(unsigned char cos){
unsigned char temp=0;
for(int i = 0; i < 8*sizeof(unsigned char); i++){
if(cos<<1){
temp = temp | 00000001;
}
temp << 1;
}
return temp;
}
d)
unsigned char foo(unsigned char cos){
unsigned char temp=0;
temp = cos;
cos << 4;
temp >> 4;
// temp = temp | cos;
temp |= cos;
}
ROZWIĄZANIA BY “JONES” 27.11.2008R.
Zad.1
Napisz program klasyfikujący klawisze naciskane na klawiaturze i wyświetlający jeden z napisów:
- mała litera (97-122)
- duża litera (65-90)
- cyfra (49-57)
- klawisz ENTER (13)
- klawisz ESC (27)
- inny klawisz
do pobierania kodu klawisza wykorzystaj funkcję _getch(), bądź _getche(), z biblioteki <conio.h>
Opis powyższych funkcji z helpa Visual Studio 2005
The _getche and _getwche functions read a single character from the console with echo, meaning that the character is displayed at the console. None of these functions can be used to read CTRL+C. When reading a function key or an arrow key, each function must be called twice; the first call returns 0 or 0xE0, and the second call returns the actual key code.
The _getch and _getwch functions read a single character from the console without echoing the character. None of these functions can be used to read CTRL+C. When reading a function key or an arrow key, each function must be called twice; the first call returns 0 or 0xE0, and the second call returns the actual key code.
PROGRAM 1:
#include <iostream>
#include <conio.h>
using namespace std;
int main()
{
int klawisz=0;
char znak;
cout<< "prosze wprowadzic znak z klawiatury\n";
while (1)
{
klawisz = getch();
if ((klawisz >= 97) && (klawisz <= 122))
cout << "Mala litera" << endl;
else if ((klawisz >= 48) && (klawisz <= 57))
cout << "cyfra" << endl;
else if ((klawisz >= 65) && (klawisz <= 90))
cout << "Duza litera" << endl;
else if (klawisz == 13)
cout << "ENTER" << endl;
else if (klawisz == 27)
cout << "ESC" << endl;
else cout << "Inny znak" << endl;
}
}
Zad.2 Proszę napisać program, który:
podaną ilość razy (n) losuje dwie liczby (a i b), z podanego przedziału (0, max), pyta o wybranie operacji (dodawanie, odejmowanie, mnożenie, dzielenie ‘/’ oraz dzielenie modulo). Następnie wyświetla użytkownikowi zadanie np. „Podaj wynik: a oper b”, w miejscu oper powinien pojawić się znak działania, zaś w miejscu a i b wylosowane liczby (całkowite). Należy podać wynik, a zadaniem programu jest sprawdzenie poprawności wyniku i po wykonaniu wszystkich iteracji wyświetlenie liczby poprawnych i błędnych odpowiedzi.
Generowanie liczb pseudolosowych przy wykorzystaniu funkcji rand_s :
#define _CRT_RAND_S – nad plikami nagłówkowymi (pierwsze co pojawia się w pliku z programem)
unsigned int number; //tak musi być, bo tego wymaga funkcja
double a; //zmienne muszą typu double ponieważ należy wykonać operację dzielenia
double b;
double max; // deklaracja zmiennej określającej górną granicę przedziału z jakiego są losowane liczby
a=(rand_s (&number));
a=(double) number/(double) UINT_MAX * max;
b=(rand_s( &number ));
b=(double) number/(double) UINT_MAX * max;
W celu otrzymania zmiennych a i b typu całkowitego należy dokonać tzw. rzutowania
a=(int)a; b=(int)b; Funkcja rand_s() wymaga nagłówka “stdlib.h”
Opis funkcji rand_s z helpa Visual Studio 2008
The rand_s function writes a pseudorandom integer in the range 0 to UINT_MAX to the input pointer. The rand_s function uses the operating system to generate cryptographically secure random numbers. It does not use the seed generated by the srand function nor does it affect the random number sequence used by rand.
The rand_s function requires that constant _CRT_RAND_S be defined prior to the inclusion statement in order for the function to be declared, such as in the example below:
#define _CRT_RAND_S
PROGRAM 2:
#include <conio.h>
#include <iostream>
#include <stdlib.h>
#include <time.h>
using namespace std;
int main()
{
int max,a,x,b,c,dobre,zle,wynik;
dobre=0;
zle=0;
char y;
srand(time(NULL));
cout<<"Podaj koniec przedzialu"<<endl;
cin>>max;
cout<<"Ile razy ma sie wykonac petla."<<endl;
cin>>x;
for(int i=0;i<x;i++)
{
cout<<"Jakie dzialanie chcesz wykonac?"<<endl;
cout<<"Dodawanie- wcisnij [+]."<<endl;
cout<<"Odejmowanie- wcisnij [-]."<<endl;
cout<<"Mnozenie- wcisnij[*]."<<endl;
cout<<"Dzielenie - wcisnij [/]."<<endl;
cout<<"Jesli chcesz wykonac dzielenie modulo - wcisnij [%]."<<endl;
cin>>y;
switch(y)
{
case '+':
a=rand()%(max+1);
b=rand()%(max+1);
cout<<"Ile wynosi suma liczb: "<<a<<" i "<<b<<".";
cin>>wynik;
if (wynik==a+b)
{
cout<<"Podales dobra odpowiedz."<<endl;
dobre=dobre+1;
}
else
{
cout<<"Podales zla odpowiedz."<<endl;
zle=zle+1;
}
break;
case '-':
a=rand()%(max+1);
b=rand()%(max+1);
cout<<"Ile wynosi roznica liczb: "<<a<<" i "<<b<<".";
cin>>wynik;
if (wynik==a-b)
{
cout<<"Podales dobra odpowiedz."<<endl;
dobre=dobre+1;
}
else
{
cout<<"Podales zla odpowiedz."<<endl;
zle=zle+1;
}
break;
case '*':
a=rand()%(max+1);
b=rand()%(max+1);
cout<<"Ile wynosi iloczyn liczb: "<<a<<" i "<<b<<".";
cin>>wynik;
if (wynik==a*b)
{
cout<<"Podales dobra odpowiedz."<<endl;
dobre=dobre+1;
}
else
{
cout<<"Podales zla odpowiedz."<<endl;
zle=zle+1;
}
break;
case '/':
do
{
a=rand()%(max+1);
b=rand()%(max+1);
}
while((a<b) && (b==0) && (a%b!=0));
cout<<"Ile wynosi iloraz liczb: "<<a<<" i "<<b<<".";
cin>>wynik;
if (wynik==a/b)
{
cout<<"Podales dobra odpowiedz."<<endl;
dobre=dobre+1;
}
else
{
cout<<"Podales zla odpowiedz."<<endl;
zle=zle+1;
}
break;
case '%':
do
{
a=rand()%(max+1);
b=rand()%(max+1);
}
while((b==0)&&(a<b));
cout<<"Ile wynosi reszta z dzielenia liczb: "<<a<<" i "<<b<<".";
cin>>wynik;
if (wynik==a%b)
{
cout<<"Podales dobra odpowiedz."<<endl;
dobre=dobre+1;
}
else
{
cout<<"Podales zla odpowiedz."<<endl;
zle=zle+1;
}
break;
}
}
cout<<"Podales: "<<dobre<<" dobrych odpowiedzi i "<<zle<<" zlych odpowiedzi."<<endl;
_getch();
_getch();
return(0);
}
Zagadnienia:
deklarowanie struktur; inicjowanie struktur wartościami początkowymi; operacje z
wykorzystaniem tablic struktur i tablic wskaźników na struktury.
1. Zadeklarować strukturę typu tosoba postaci struct { char naz[20]; unsigned rok, mies,
dzien; long id; }. Zdefiniować zmienną s typu tosoba, zainicjowaną w programie
wartościami początkowymi, oraz wskaźnik x na strukturę typu tosoba. W programie
głównym utworzyć dynamicznie zmienną typu tosoba i zapamiętać jej adres w zmiennej
x. Zainicjować zmienną wskazywaną przez x zawartością zmiennej s. Opracować funkcje
wyprowadzające na ekran zawartość zmiennej strukturalnej typu tosoba. Dane są
następujące prototypy:
a) void pisz1(tosoba s); b) void pisz2(tosoba *x).
Wyprowadzić na ekran zawartość zmiennej statycznej s za pomocą funkcji pisz1 i pisz2
oraz zawartość zmiennej dynamicznej wskazywanej przez x również za pomocą każdej z
opracowanych funkcji. Zwolnić pamięć wskazywaną przez x.
2. Opracować funkcje umożliwiające wczytanie danych z klawiatury lub wstawienie
wartości losowych do zmiennej strukturalnej typu tosoba (deklaracja typu tosoba zobacz
zadanie 1). Dane są następujące prototypy:
a) tosoba w1(void) – wczytywanie z klawiatury, struktura zwracana przez nazwę;
b) void w2(tosoba *s) – wczytywanie z klawiatury, struktura zwracana przez wskaźnik;
c) void w3(tosoba& s) – wczytywanie z klawiatury, struktura zwracana przez referencję;
d) void losuj(tosoba *s) – losowanie danych do struktury wskazywanej przez s;
do pola naz[20] wstawiany jest łańcuch ”naz” zakończony losową liczbą należącą do
przedziału [1, 100), np. ”naz21”, ”naz3”, itd.; do pozostałych pól wstawiane są losowe
liczby należące, odpowiednio, do przedziałów [1900, 1981), [1, 13), [1, 32), [1, 100).
W programie głównym zainicjować zmienną typu tosoba za pomocą każdej z funkcji.
3. Zdefiniować tablicę struktur typu struct twsp { int x, y; } o rozmiarze N, gdzie N jest
stałą. Przyjąć, że struktury służącą do przechowywania współrzędnych punktów.
Zainicjować tablicę danymi w taki sposób, aby kolejne struktury w tablicy zawierały
współrzędne losowych punktów (x,y), gdzie x należy do przedziału [0,79), natomiast y
należy do przedziału [0,24). Wczytać z klawiatury współrzędne badanego punktu (a,b).
Wyznaczyć punkty najbliższe punktowi (a,b) w sensie odległości kartezjańskiej
(odległość pomiędzy punktami (x,y) i (a,b) jest obliczana ze wzoru d = sqrt[(x-a)(x-a) +
(y-b)(y-b)]). Wyprowadzić współrzędne wszystkich znalezionych punktów na ekran.
Może być kilka punktów równoodległych od punktu (a,b).
4. Zdefiniować tablicę struktur typu tosoba, o rozmiarze N, oraz tablicę indeksów unsigned
ind[N], gdzie N – stała. W programie głównym:
a) zainicjować tablicę struktur losowymi danymi wykorzystując funkcję losuj
przedstawioną w zadaniu 2;
b) zainicjować tablicę indeksów kolejnymi liczbami od 0 do N-1, zgodnie z regułą
ind[i] = i, dla i=0, … , N-1.
Nie zmieniając zawartości tablicy struktur i nie kopiując jej do innej tablicy zmodyfikować
tablicę indeksów w taki sposób, aby kolejne pozycje w tablicy ind określały
położenie struktur posortowanych według nazwisk (np. wykorzystać funkcję qsort).
5. Zdefiniować N – elementową tablicę wskaźników na struktury typu struct tosoba { char
naz[20]; unsigned rok, mies, dzien; long id; }, gdzie N jest stałą w programie.
Zdefiniować zmienną unsigned ile=0, która ma służyć do przechowywania liczby
wskaźników wprowadzonych do tablicy. Opracować następujące funkcje:
a) tworzącą zmienną dynamiczną typu tosoba oraz inicjującą zmienną losowymi
wartościami w sposób następujący: do pola naz[20] wstawiany jest łańcuch ”naz”
zakończony losową liczbą należącą do przedziału [1, 1000), np. ”naz21”, ”naz300”,
itd.; do pozostałych pól wstawiane są losowe liczby należące, odpowiednio, do
przedziałów [1900, 1981), [1, 13), [1, 32), [1, 10000); wstawiającą adres utworzonej
zmiennej na pierwszej wolnej pozycji w tablicy (jest to pozycja końca tablicy o
indeksie ile < N).
b) wyprowadzającą zawartość struktury typu tosoba na ekran;
c) znajdującą w tablicy pierwszą daną o podanych wartościach pól (jeśli podano
nazwisko, to wyszukiwanie według nazwisk; jeśli podano nazwisko i datę - rok, mies,
dzien, to wyszukiwanie według nazwisk i dat; jeżeli podano nazwisko, datę oraz
identyfikator, to wyszukiwanie według trzech pól równocześnie);
d) usuwającą z tablicy pierwszą daną o podanych wartościach wszystkich pól; funkcja
znajduje element, zwalnia pamięć przydzieloną elementowi i dokonuje kompresji
tablicy (przesunięcia elementów i zmniejszenia wartości ile);
e) sortującą elementy tablicy wskaźników w taki sposób, aby wskazywane struktury
tworzyły ciąg uporządkowany według nazwisk (należy zamieniać wskaźniki bez
modyfikacji położenia struktur w pamięci); wykorzystać funkcję qsort;
f) usuwającą wszystkie dane z pamięci i zerującą tablicę wskaźników.
W programie głównym utworzyć dynamicznie m<N struktur typu tosoba (po utworzeniu
ile=m), zainicjować struktury losowymi wartościami i zapamiętać ich adresy w tablicy.
Przetestować działanie opracowanych funkcji. Przed zakończeniem programu zwolnić
przydzieloną pamięć.
6. Utworzyć dynamiczną tablicę N wskaźników na struktury typu struct tdana {int a; char
t[20];}, gdzie a jest liczbą arabską należącą do przedziału od 0 do 3999, natomiast t służy
do przechowywania tekstu reprezentującego liczbę w zapisie rzymskim. Opracować program,
który dla każdej struktury losuje liczbę arabską i zapisuje odpowiadającą jej liczbę
rzymską w polu t. Wykorzystać zainicjowaną tablicę struktur typu struct RZYM {int w;
char *s; }R[ ] = { {1, ”I”}, {5, ”V”}, {10, ”X”}, {50, ”L”}, {100, ”C”}, {500, ”D”},
{1000, ”M”}}. Przykładowe liczby: 4-IV, 6-VI, 9-IX, 14-XIV, 19-XIX, 40-XL, 90-XC,
400-CD, 900-CM, 3999-MMMCMXCIX. Wyprowadzić struktury typu tdana na ekran.
Pr1
#include<stdio.h>
#include<conio.h>
struct tosoba
{
char naz[20];
unsigned rok,mies,dzien;
long id;
} s={“Powalski”,1967,12,8,340};
void pisz1(tosoba s);
void pisz2(tosoba *x);
//ppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp
void main()
{
tosoba *x=new tosoba;
*x=s;
printf(“zmienna statyczna:\n”);
pisz1(s);
pisz2(&s);
printf(“zmienna dynamiczna:\n”);
pisz1(*x);
pisz2(x);
delete x;
getch();
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++1
void pisz1(tosoba s)
{
printf(“%s %u %u %u %ld\n”,s.naz,s.rok,s.mies,s.dzien,s.id);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void pisz2(tosoba *x)
{
printf(“%s %u %u %u %ld\n”,s.naz,s.rok,s.mies,s.dzien,s.id);
}
Pr2
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
struct tosoba
{
char naz[20];
unsigned rok,mies,dzien;
long id;
} s={“Naz”,1967,12,8,340};
tosoba w1(void);
void w2(tosoba*k);
void w3(tosoba&k);
void losuj(tosoba *s);
void wyswietl(tosoba k);
//mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm
mmmmmmmmmmmmmmmmmmmmmmmmmmmm
void main()
{
char p;
srand(time(0));
printf(“Wybierz podpunkt:\n”);
printf(“1-a\n”);
printf(“2-b\n”);
printf(“3-c\n”);
printf(“4-d\n”);
flushall;
p=getchar();
switch(p)
{
case’1′: w1();break;
case’2′: w2(&s);break;
case’3′: w3(s);break;
case’4′: losuj(&s);break;
default: printf(“error”);
}
getch();
}
//lllllllllllllllllllllllllllllllllllllllllllllllll
llllllllllllllllllllllllllll
tosoba w1(void)
{
tosoba k;
printf(“nazwisko:”);
scanf(“%s”,&k.naz);
printf(“rok:”);
scanf(“%u”,&k.rok);
printf(“miesiac:”);
scanf(“%u”,&k.mies);
printf(“dzien:”);
scanf(“%u”,&k.dzien);
printf(“id:”);
scanf(“%ld”,&k.id);
wyswietl(k);
return k;
}
//2222222222222222222222222222222222222222222222222
2222222222222222222222222222
void w2(tosoba*k)
{
tosoba p;
k=&p;
printf(“nazwisko:”);
scanf(“%s”,&p.naz);
printf(“rok:”);
scanf(“%u”,&p.rok);
printf(“miesiac:”);
scanf(“%u”,&p.mies);
printf(“dzien:”);
scanf(“%u”,&p.dzien);
printf(“id:”);
scanf(“%ld”,&p.id);
wyswietl(p);
}
//3333333333333333333333333333333333333333333333333
33333333333333333333333333
void w3(tosoba &k)
{
printf(“nazwisko:”);
scanf(“%s”,&k.naz);
printf(“rok:”);
scanf(“%u”,&k.rok);
printf(“miesiac:”);
scanf(“%u”,&k.mies);
printf(“dzien:”);
scanf(“%u”,&k.dzien);
printf(“id:”);
scanf(“%ld”,&k.naz);
wyswietl(k);
}
//4444444444444444444444444444444444444444444444444
444444444444444444444444444
void losuj(tosoba *s)
{
tosoba p;
s=&p;
p.naz[0]=’n';
p.naz[1]=’a';
p.naz[2]=’z';
p.naz[4]=random(100)+1;
p.rok=random(81)+1900;
p.mies=random(12)+1;
p.dzien=random(31)+1;
p.id=random(100)+1;
wyswietl(p);
}
//3333333333333333333333333333333333333333333333333
3333322222222222222222222222
void wyswietl(tosoba i)
{
printf(“naz:”);
printf(“%s\n”,i.naz);
printf(“rok:”);
printf(“%u\n”,i.rok);
printf(“mies:”);
printf(“%u\n”,i.mies);
printf(“dzien:”);
printf(“%u\n”,i.dzien);
printf(“id:”);
printf(“%ld”,i.id);
}
Pr2+
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<string.h>
struct tosoba
{
char naz[20];
unsigned rok,mies,dzien;
long id;
} s={“Naz”,1967,12,8,340};
tosoba w1(void);
void w2(tosoba*k);
void w3(tosoba&k);
void losuj(tosoba *s);
void wyswietl(tosoba k);
//mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm
void main()
{
char p;
srand(time(0));
printf(“Wybierz podpunkt:\n”);
printf(“1-a\n”);
printf(“2-b\n”);
printf(“3-c\n”);
printf(“4-d\n”);
flushall;
p=getchar();
switch(p)
{
case’1′: w1();break;
case’2′: w2(&s);break;
case’3′: w3(s);break;
case’4′: losuj(&s);break;
default: printf(“error”);
}
getch();
}
//lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll
tosoba w1(void)
{
tosoba k;
printf(“nazwisko:”);
scanf(“%s”,&k.naz);
printf(“rok:”);
scanf(“%u”,&k.rok);
printf(“miesiac:”);
scanf(“%u”,&k.mies);
printf(“dzien:”);
scanf(“%u”,&k.dzien);
printf(“id:”);
scanf(“%ld”,&k.id);
wyswietl(k);
return k;
}
//22222222222222222222222222222222222222222222222222222222222222222222222222222
void w2(tosoba*k)
{
tosoba p;
k=&p;
printf(“nazwisko:”);
scanf(“%s”,&p.naz);
printf(“rok:”);
scanf(“%u”,&p.rok);
printf(“miesiac:”);
scanf(“%u”,&p.mies);
printf(“dzien:”);
scanf(“%u”,&p.dzien);
printf(“id:”);
scanf(“%ld”,&p.id);
wyswietl(p);
}
//333333333333333333333333333333333333333333333333333333333333333333333333333
void w3(tosoba &k)
{
printf(“nazwisko:”);
scanf(“%s”,&k.naz);
printf(“rok:”);
scanf(“%u”,&k.rok);
printf(“miesiac:”);
scanf(“%u”,&k.mies);
printf(“dzien:”);
scanf(“%u”,&k.dzien);
printf(“id:”);
scanf(“%ld”,&k.naz);
wyswietl(k);
}
//4444444444444444444444444444444444444444444444444444444444444444444444444444
void losuj(tosoba *s)
{
strcpy((*s).naz,”naz”);
printf(“naz:”);
printf(“%s”,(*s).naz);
(*s).naz[4]=random(100)+1;
printf(“%d\n”,(*s).naz[4]);
(*s).rok=random(81)+1900;
(*s).mies=random(12)+1;
(*s).dzien=random(31)+1;
(*s).id=random(100)+1;
printf(“rok:”);
printf(“%u\n”,(*s).rok);
printf(“mies:”);
printf(“%u\n”,(*s).mies);
printf(“dzien:”);
printf(“%u\n”,(*s).dzien);
printf(“id:”);
printf(“%ld”,(*s).id);
}
//33333333333333333333333333333333333333333333333333333322222222222222222222222
void wyswietl(tosoba i)
{
printf(“naz:”);
printf(“%s\n”,i.naz);
printf(“rok:”);
printf(“%u\n”,i.rok);
printf(“mies:”);
printf(“%u\n”,i.mies);
printf(“dzien:”);
printf(“%u\n”,i.dzien);
printf(“id:”);
printf(“%ld”,i.id);
}
Pr3
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<math.h>
const int n=10;
struct twsp {
int x,y;
} p={1,2};
void main()
{
int i=0,a,b;
double d,k=0;
twsp tab[n],p[n];
srand(time(0));
for(i=0;i<n;i++)
{
tab[i].x=random(79);
tab[i].y=random(24);
//printf(“%d,%d\n”,tab[i].x,tab[i].y);
}
printf(“a=”);
scanf(“%d”,&a);
printf(“b=”);
scanf(“%d”,&b);
for(i=0;i<n;i++)
{
d=sqrt(double((tab[i].x-a)*(tab[i].x-a)+(tab[i].y-b)*(tab[i].y-b)));
//printf(“%lf\n”,d);
//szukanie najmniejszej
if(i==0) {k=d;}
if(k>=d) {k=d;}
}
for(i=0;i<n;i++)
{
d=sqrt(double((tab[i].x-a)*(tab[i].x-a)+(tab[i].y-b)*(tab[i].y-b)));
if(k==d) {printf(“x=%d,y=%d\n”,tab[i].x,tab[i].y);}
}
getch();
}
Pr4
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<string.h>
const n=10;
struct tosoba
{
char naz[20];
unsigned rok,mies,dzien;
long id;
} s={“Naz”,1967,12,8,340};
tosoba w1(void);
void losuj(tosoba *s);
void wyswietl(tosoba k);
int nazwa(const void*wsk,const void *wsk2);
void kot (void *tab);
//mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm
void main()
{
int i;
srand(time(0));
tosoba k[n],p;
unsigned ind[n];
for(i=0;i<n;i++)
{
losuj(&k[i]);
// wyswietl(k[i]);
}
for(i=0;i<n;i++)
{
ind[i]=i;
}
//qsort(ind,n,sizeof(unsigned),nazwa);
kot(k);
for(i=0;i<n;i++)
{
printf(“%u\n”,ind[i]);
wyswietl(k[i]);
}
getch();
}
//lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll
void losuj(tosoba *s)
{
strcpy((*s).naz,”naz”);
(*s).naz[4]=random(100)+1;
(*s).rok=random(81)+1900;
(*s).mies=random(12)+1;
(*s).dzien=random(31)+1;
(*s).id=random(100)+1;
}
//33333333333333333333333333333333333333333333333333333322222222222222222222222
void wyswietl(tosoba i)
{
printf(“naz:”);
printf(“%s”,i.naz);
printf(“%d\n”,i.naz[4]);
printf(“rok:”);
printf(“%u\n”,i.rok);
printf(“mies:”);
printf(“%u\n”,i.mies);
printf(“dzien:”);
printf(“%u\n”,i.dzien);
printf(“id:”);
printf(“%ld\n”,i.id);
}
//nazwa……………………………………………………………
int nazwa(const void*wsk,const void *wsk2)
{
struct tosoba *os_1=(tosoba*)wsk;
struct tosoba *os_2=(tosoba*)wsk2;
return(os_1->naz[4]-os_2->naz[4]);
}
//KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKkkkkk
void kot (void *tab)
{
qsort(tab,n,sizeof(tosoba),nazwa);
}
Pr5
#include<conio.h>
#include<stdio.h>
#include<stdlib.h>
#include <iostream.h>
struct tdana
{
int a; //liczba arabsks
char t[20]; //liczba rzymska
};
struct RZYM
{
int w;
char *s;
} R[]={{1,”I”},{5,”V”},{10,”X”},{100,”C”},{500,”D”},{1000,”M”}};
void main()
{
int n,a,i;
srand(time(0));
printf(“podaj wielkosc tablicy: “);
//scanf(“%d”,&n);
tdana* *N=new tdana*[n];
//for(i=0;i<n;i++)
//{
//(*N[i]).a=random(3999);
//N[i]->a=random(3999);
//}
N[0]->a=10;
cout << N[0]->a;
N[1]->a = 11;
getch();
}
Pr6
#include<conio.h>
#include<stdio.h>
#include<stdlib.h>
#include <iostream.h>
struct tdana
{
int a; //liczba arabsks
char t[20]; //liczba rzymska
};
struct RZYM
{
int w;
char *s;
} R[]={{1,”I”},{5,”V”},{10,”X”},{100,”C”},{500,”D”},{1000,”M”}};
void main()
{
int n,a,i;
srand(time(0));
printf(“podaj wielkosc tablicy: “);
//scanf(“%d”,&n);
tdana* *N=new tdana*[n];
//for(i=0;i<n;i++)
//{
//(*N[i]).a=random(3999);
//N[i]->a=random(3999);
//}
N[0]->a=10;
cout << N[0]->a;
N[1]->a = 11;
getch();
}
Zagadnienia:
definiowanie wskaźników funkcji; operacje z wykorzystaniem tablic i wskaźników funkcji;
sortowanie tablic z wykorzystaniem funkcji qsort.
1. Zdefiniować wskaźnik do funkcji o jednym parametrze typu double i zwracającej wynik
typu double. Opracować funkcję o prototypie double W(double x), która oblicza wartości
wielomianu W(x) = x3 + 1. Zainicjować wskaźnik funkcji adresem funkcji W, a następnie
wyliczyć za jego pomocą wartości funkcji dla i=0,1,2,…,N, gdzie N – stała. Wyprowadzić
obliczone wartości na ekran. Porównać wyniki wywołując bezpośrednio funkcję W(i).
2. Zdefiniować wskaźnik funkcji double f(double). Zainicjować wskaźnik adresem standardowej
funkcji sin. Za pomocą wskaźnika wyznaczyć wartości funkcji sin w N losowych
punktach x, należących do przedziału [-pi/2, pi/2], gdzie N – stała. Wyprowadzić wartości
x, f(x) na ekran.
3. W programie głównym utworzyć dynamiczną tablicę złożoną z N elementów typu double.
Zainicjować tablicę losowymi liczbami rzeczywistymi należącymi do przedziału
[-10.2, 15.3). Wykorzystując standardową funkcję qsort opracować funkcję, która sortuje
elementy tablicy rosnąco. Wyprowadzić zawartość tablicy na ekran. Przed zakończeniem
programu zwolnić pamięć.
4. Zdefiniować tablicę złożoną z N elementów typu char. Zainicjować tablicę losowymi
znakami o kodach należących do przedziału [65,127). Wykorzystując standardową
funkcję qsort opracować funkcję, która sortuje elementy tablicy według kodów ASCII.
Wyprowadzić zawartość tablicy na ekran.
5. Zadeklarować typ tablicowy typedef double tx[N][2]. Opracować funkcję, która wyznacza
wartości funkcji double f(double) w przedziale [min, max] dla N punktów postaci
xi = min + i*d, gdzie d=(max-min) / (N-1) oraz i=0,1,…,N-1 (N – stała). Obliczone
elementy xi, f(xi) powinny być zapamiętane w tablicy T typu tx w sposób następujący:
T[i][0] = xi oraz T[i][1] = f(xi). Prototyp funkcji: void oblicz(double min, double max,
int n, tx T, wskaźnik_funkcji). W programie głównym wykonać obliczenia dla funkcji sin
w przedziale [-pi/2, pi/2].
6. Zdefiniować dwuwymiarową tablicę liczb typu int złożoną z nw wierszy i nk
kolumn, gdzie nw i nk są stałymi w programie. Zainicjować tablicę losowymi liczbami
całkowitymi należącymi do przedziału [-10,10]. Wykorzystując standardową funkcję
qsort opracować funkcję sortującą elementy tablicy A należące do wiersza o numerze i,
gdzie 0<= i < nw. W programie głównym posortować każdy wiersz tablicy. Wyprowadzić
zawartość tablicy wierszami na ekran.
Pr1
#include<stdio.h>
#include<conio.h>
const double N=10;
double W(double x)
{
double p;
p=x*x*x+1;
return p;
}
void main()
{
double(*f)(double),i;
f=W;
for(i=0;i<N;i++)
{
printf(“f(i)=%lf w(i)=%lf\n”,f(i),W(i));
}
getch();
}
Pr2
#include<stdio.h>
#include<conio.h>
#include<math.h>
#include<stdlib.h>
const int N=10;
const double pi=3.14;
void main()
{
srand(time(0));
double(*f)(double),i,x;
f=sin;
for(i=0;i<N;i++)
{
x=pi/2-double(random(314))/100;
printf(“%lf x=%.2lf\n”,f(x),x);
}
getch();
}
Pr3
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
int l_ros(const void*wsk,const void*wsk2);
void wyswietl(double tablica[],int rozmiar);
//ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
void main()
{
int n,i=0;
printf(“podaj wielkosc tablicy: “);
scanf(“%d”,&n);
srand(time(0));
double *td= new double[n],a;
for(i=0;i<n;i++)
{
td[i]=(15.3 – ((double(random(256))/10)));
}
qsort(td,n,sizeof(double),l_ros);
wyswietl(td,n);
delete [] td;
getch();
}
//ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
int l_ros(const void*wsk,const void*wsk2)
{
double *wsk_1,*wsk_2;
wsk_1=(double*)wsk;
wsk_2=(double*)wsk2;
return(*wsk_1-*wsk_2);
}
//ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
void wyswietl(double tablica[],int rozmiar)
{
int i;
for(i=0;i<rozmiar;i++)
{
printf(“%lf\n “,tablica[i]);
}
}
Pr4
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
void inicializacja(char*wsk,int N);
int ASCII(const void*wsk1,const void*wsk2);
void wyswietl(char*wsk,int N);
void main()
{
int N;
srand(time(0));
printf(“podaj rozmiar tablicy: “);
scanf(“%d”,&N);
char *tab = new char[N];
inicializacja(tab,N);
qsort(tab,N,sizeof(char),ASCII);
wyswietl(tab,N);
getch();
}
//000000000000000000000000000000000000000000000000000000000000000000000
void inicializacja(char*wsk,int N)
{
int i;
for(i=0;i<N;i++)
{
wsk[i]=65+random(62);
}
}
//0000000000000000000000000000000000000000000000000000000000000000000000
int ASCII(const void*wsk1,const void*wsk2)
{
char *wsk_1,*wsk_2;
wsk_1=(char*)wsk1;
wsk_2=(char*)wsk2;
return(*wsk_1-*wsk_2);
}
//00000000000000000000000000000000000000000000000000000000000000000000000
void wyswietl(char*wsk,int N)
{
int i;
for(i=0;i<N;i++)
{
printf(“%d \t %c \n”,wsk[i],wsk[i]);
}
}
Pr5
#include<conio.h>
#include<stdio.h>
#include<math.h>
const double pi=3.14;
const int N=20;
typedef double tx[N][2];
void oblicz(double min,double max,int n,tx T,double(*wsk)(double));
void main()
{
tx tab;
oblicz(-pi/2,pi/2,N,tab,sin);
getch();
}
//0000000000000000000000000000000000000000000000000000000000000000000000000
void oblicz(double min,double max,int n,tx T,double (*wsk)(double))
{
int i;
double x=0,d=0,y=0;
d=(max-min)/double(n-1);
for(i=0;i<=(n-1);i++)
{
x=min + i*d;
T[i][0]=x;
y=wsk(x);
T[i][1]=y;
printf(“T[%d][0]=%lf\tT[%d][1]=%lf\n”,i,x,i,y);
}
}
Pr6
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
const nk=4;
const nw=10;
int sort(const void *wsk1,const void *wsk2);
void sortuj(int tab[][nk]);
void main()
{
int tab[nw][nk],i,k;
srand(time(0));
for(i=0;i<nw;i++)
{
for(k=0;k<nk;k++)
{
tab[i][k]=(random(11)-10);
}
}
sortuj(tab);
for(i=0;i<nw;i++)
{
for(k=0;k<nk;k++)
{
printf(“tab[%d][%d]=%d\t”,i,k,tab[i][k]);
}
printf(“\n”);
}
getch();
}
//oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
int f_sort(const void *wsk1,const void *wsk2)
{
int *wsk_1,*wsk_2;
wsk_1=(int*)wsk1;
wsk_2=(int*)wsk2;
return(*wsk_1-*wsk_2);
}
//oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
void sortuj(int tab[][nk])
{
int i,(*p)[nk];
p=tab;
for(i=0;i<nw;i++)
{
qsort(p+i,nk,sizeof(int),f_sort);
}
}
Zagadnienia:
definiowanie i deklarowanie (typedef) tablic; inicjowanie tablic; wykonywanie operacji na
tablicach; wyprowadzanie zawartości tablic na ekran; dostęp do tablic za pomocą wskaźników;
przekazywanie tablic do funkcji; sortowanie tablic.
1. Wykorzystując specyfikator typu typedef zdefiniować typ ttab reprezentujący tablicę liczb
złożoną z 10 elementów typu long. Zainicjować tablicę typu ttab losowymi liczbami
całkowitymi należącymi do przedziału [-90000,90000). Wyprowadzić zawartość tablicy
na ekran. Znaleźć element minimalny i maksymalny. Wyprowadzić elementy tablicy na
ekran.
2. Dana jest tablica jednowymiarowa double tab[n], gdzie n jest stałą w programie, oraz
wskaźnik double *wsk = tab. Zainicjować tablicę losowymi zerami i jedynkami.
Wyprowadzić tablicę na ekran. Obliczyć sumę elementów tablicy wykorzystując następujące
fragmenty kodu:
a) tab[i]; b) tab+i; c) wsk+i; d) wsk++.
3. Opracować funkcje umożliwiające inicjację tablicy int tab[n] (n-stała) losowymi liczbami
całkowitymi należącymi do przedziału [0, 100) oraz funkcję wyprowadzającą zawartość
tablicy na ekran. Dane są następujące prototypy:
a) void init1(int tab[n], int ile_zain);
b) void init2(int *tab, int ile_zain);
c) void init3(int tab[], int ile_zain);
d) void pisz(int tab[], int ile_pisz).
Przetestować działanie funkcji w programie głównym.
4. Zainicjować tablicę int tab[N] losowymi danymi należącymi do przedziału [0, 50) (np.
wykorzystać funkcję rand; N - stała). Opracować funkcję sortującą rosnąco elementy
tablicy za pomocą algorytmu prostego wybierania. Zasada działania algorytmu:
a) niech int i=0;
b) w zbiorze elementów od tab[i] do tab[n-1] znaleźć element minimalny;
c) wymienić element minimalny z elementem tab[i];
d) podstawić i=i+1;
e) powtórzyć kroki od b) do e) dla i=1,2,…,n-1.
Wyprowadzić zawartość tablicy na ekran przed i po sortowaniu.
5. Dana jest tablica znaków unsigned char t[20]. Zainicjować tablicę losowymi znakami
należącymi do przedziału [32,255]. Wyprowadzić zawartość tablicy na ekran w postaci
kod – znak (np. 65 – ‘A’).
6. Wczytać z klawiatury dwie liczby naturalne x i y. Wpisać do tablicy A kolejne cyfry
liczby x oraz do tablicy B kolejne cyfry liczby y w taki sposób, aby mniej znaczące cyfry
liczb zajmowały pozycje tablicy o mniejszych indeksach, np. dla x = 352 tablica A
powinna zawierać: A[0]=2; A[1]=5; A[2]=3. Opracować funkcję pisemnego dodawania
liczb zapisanych w tablicach A i B. Wynik umieścić w tablicy C. Wyprowadzić, jedna
pod drugą, liczby zapisane w tablicach A, B i C na ekran (zapis dodawania pisemnego).
Pr1
#include<conio.h>
#include<stdio.h>
#include<stdlib.h>
void main()
{
int i,p,s,m,k;
typedef long ttab;
ttab tab[10],min,max;
srand(time(0));
for(i=0;i<10;i++)
{
tab[i]=random(90000)-random(90000);
printf(“tab[%d]= %ld\n”, i,tab[i]);
}
for(i=0,s=0,m=0;i<10;i++)
{
for(k=0,p=0;k<10;k++)
{
if(tab[i]<tab[k]) {p–;} else
if(tab[i]>tab[k]) {p++;} else
if(tab[i]=tab[k]) {p+=0;}
}
if(s<p || s==p) {max=tab[i];s=p;}
if(m>p || m==p) {min=tab[i];m=p;}
}
printf(“max=%ld\nmin=%ld”,max,min);
getch();
}
Pr2
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
const int n=20;
void main()
{
int i;
char opcja;
double tab[n],suma,*wsk=tab;
srand(time(0));
for(i=0;i<n;i++)
{
tab[i]=random(2);
printf(“tab[%d]= %lf\n”,i,tab[i]);
}
printf(“\n 1-a\n”);
printf(” 2-b\n”);
printf(” 3-c\n”);
printf(” 4-d\n”);
opcja=getchar();
switch (opcja)
{
case’1′: for(i=0,suma=0;i<20;i++)
{
suma+=tab[i];
}
printf(“suma= %lf”, suma);
break;
case’2′: for(i=0,suma=0;i<20;i++)
{
suma+=*(tab+i);
}
printf(“\nsuma= %lf”, suma);
break;
case’3′: for(i=0,suma=0;i<20;i++)
{
suma+=*(wsk+i);
}
printf(“\nsuma= %lf”, suma);
break;
case’4′: for(i=0,suma=0;i<20;i++)
{
suma+=*(wsk++);
}
printf(“\nsuma= %lf”, suma);
break;
default: printf(“brak opcij”);
break;
}
getch();
}
Pr3
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define n 100
void Init1(int tab[n],int ile_zain)
{
int i;
srand(time(0));
for(i=0;i<ile_zain;i++)
{
tab[i]=random(100);
}
}
void Init2(int *tab,int ile_zain)
{
int i;
srand(time(0));
for(i=0;i<ile_zain;i++)
{
*(tab+i)=random(100);
}
}
void Init3(int tab[],int ile_zain)
{
int i;
srand(time(0));
for(i=0;i<ile_zain;i++)
{
tab[i]=random(100);
}
}
void Pisz(int tab[],int ile_pisz)
{
int i;
for(i=0;i<ile_pisz;i++)
{
printf(“tab[%d]= %d \n”,i,tab[i]);
}
}
void main()
{
char q;
int k,tab[n];
printf(“podaj ilu elementom chcesz nadac wartosc “);
scanf(“%d”,&k);
printf(“1-a\n”);
printf(“2-b\n”);
printf(“3-c\n”);
flushall();
q=getchar();
switch(q)
{
case’1′: Init1(tab,k);
Pisz(tab,k);
break;
case’2′: Init2(tab,k);
Pisz(tab,k);
break;
case’3′: Init3(tab,k);
Pisz(tab,k);
break;
default: printf(“brak opcij”);break;
}
getch();
}
Pr4
#include<conio.h>
#include<stdio.h>
#include<stdlib.h>
int const N=100;
void Sort(int tab[])
{
int p=0,k,i,t;
for(i=0;i<N;i++)
{
for(k=i,t=50;k<N;k++)
{
if(t>tab[k]) {t=tab[k];p=k;}
}
tab[p]=tab[i];
tab[i]=t;
printf(“tab[%d]= %d\n”,i,tab[i]);
}
}
void main()
{
int tab[N],i;
srand(time(0));
printf(“Przed Sortowaniem:\n”);
for(i=0;i<N;i++)
{
tab[i]=random(50);
printf(“tab[%d]= %d\n”,i,tab[i]);
}
printf(“\nPo Sortowaniu:\n”);
Sort(tab);
getch();
}
Pr5
#include<conio.h>
#include<stdio.h>
#include<stdlib.h>
void main()
{
int i;
unsigned char t[20];
srand(time(0));
for(i=0;i<20;i++)
{
t[i]=abs(rand()%256)+32;
printf(“%d – ‘%c’\n\n”,t[i],t[i]);
}
getch();
}
Pr6
#include<stdio.h>
#include<conio.h>
void J(int x,int tab[])
{
int k,i,s,r,l=0;
printf(” “);
for(k=x,i=0,s=1,r=0;s!=0;i++)
{
s=int(k/10);
r=k%10;
k=s;
tab[i]=r;
l++;
}
}
void Suma(int tab1[],int tab2[])
{
int C[11],i;
for(i=0;i<10;i++)
{
C[i]=tab1[i]+tab2[i];
if(C[i]>=10) {tab1[i+1]+int(C[i]/10);C[i]=C[i]%10;}
printf(“%d”,C[i]);
}
}
void main()
{
int x,y,A[10],B[10];
printf(“podaj x\n”);
scanf(“%d”,&x);
printf(“podaj y\n”);
scanf(“%d”,&y);
J(x,A);
printf(“\n”);
J(y,B);
gotoxy(1,6);
printf(“+\n”);
printf(“=\n”);
Suma(A,B);
getch();
}
Niestety nie posiadam informacji o zagadnieniach na tych zajeciach.
Pr 1
#include <stdio.h>
#include <conio.h>
void main()
{
const long x = 123;
const double y=125.7;
long *a;
double *b;
*a=x;
*b=y;
printf (“%ld \n”, x);
printf (“%ld \n”, *a);
printf (“%lf \n”, y);
printf (“%d \n”, *b);
getch();
}
pr2
#include <stdio.h>
#include <conio.h>
void main()
{
const long x = 123;
const double y=125.7;
long *a;
const double *const b =&y;
*a=x;
printf (“%ld \n”, x);
printf (“%ld \n”, *a);
printf (“%lf \n”, y);
printf (“%lf \n”, *b);
getch();
}
Zagadnienia:
wykorzystanie instrukcji iteracyjnych w programach; obliczanie prostych sum szeregów;
wyprowadzanie informacji na ekran w trybie znakowym.
1. Opracować program wyprowadzający na ekran wierszami znaki o kodach ASCII od a do
b, gdzie a, b są wczytywane z klawiatury oraz spełniają zależność 33 <= a <= b <=255.
Wyprowadzać po 12 znaków w wierszu w formacie: znak na dwóch polach, myślnik (-),
kod znaku na trzech polach, np. A- 65, e-101.
2. Wykorzystując instrukcję pętli (for) obliczyć sumę S = 1 + 2 + … + n, gdzie n jest liczbą
naturalną wczytywaną z klawiatury.
3. Obliczyć trzema sposobami za pomocą (for, while, do) sumę S = 1 – 2 + 3 – 4 + … ± n,
gdzie n jest liczbą naturalną wczytywaną z klawiatury.
4. Opracować program, który dla naturalnego n i rzeczywistego x, wczytywanych z
klawiatury, oblicza:
a) P = 1∗2∗ … ∗n;
b) W = x∗x∗ … ∗x = xn (x do potęgi n).
Wykorzystać instrukcje iteracyjne.
5. Opracować program, który oblicza sumę S = 1/2 – 2/4 + 3/8 – 4/16 +… ± n/(2n), gdzie n
jest liczbą naturalną wczytywaną z klawiatury.
6. Wczytać zmienną całkowitą n z klawiatury. Dla i=0,1,2,3,… obliczać sumę S = 1/1 – 1/4 +
1/7 – 1/10 +… ± 1/(3i+1) tak długo, aż pojawi się i, dla którego wartość (3i+1) > n.
7. Wczytać zmienną całkowitą n z klawiatury. Opracować program, który oblicza sumę
szeregu S(n) = (1/1 + 1/2 + 1/3) – (1/7 + 1/8 + 1/9) + (1/13 + 1/14 + 1/15) – … ± 1/i, gdzie
wartość i spełnia zależność i <= n. Przykładowe sumy dla n=5,6,7,8 mają następującą
postać:
S(5) = S(6) = (1/1 + 1/2 + 1/3),
S(7) = (1/1 + 1/2 + 1/3) – (1/7),
S(8) = (1/1 + 1/2 + 1/3) – (1/7 + 1/8).
8. Opracować program, który wyprowadza na ekran następujące figury:
X X X
XX XX XXX
h XXX XXX h XXXXX h
XXXX XXXX XXXXXXX
Zmienna całkowita h, określająca wysokość figury, jest wczytywana z klawiatury.
P1
#include<stdio.h>
#include<conio.h>
void main()
{
char a,b;
int licznik = 0;
printf(“Podaj a: “);
a = getchar();
flushall();
printf(“Podaj b: “);
b = getchar();
if(a >= 33 && b <= 255 && a <= b)
while(a <= b)
{
printf(“%2c-%3d”, a, a); licznik++;
if(licznik == 12) { printf(“\n”); licznik = 0; }
a++;
}
getch();
}
P2
#include <stdio.h>
#include <conio.h>
void main()
{ int a,s,i,n;
printf (“n= “);
scanf (“%d”, &n);
a=0;
if (n>=0)
{for (i=1; i<=n; i++)
{a=a+i;
} printf (“suma wynosi %d”, a);
}
else {printf (“blad”);
}
getch();
}
P3 do while
#include <stdio.h>
#include <conio.h>
void main()
{int n,r,a,b,i,k;
printf (“podaj n= “);
scanf (“%d”, &n);
a=0;
b=0;
if (n>=0)
{
i=1;
do
{a+=i; i+=2;
}
while (i<=n);
k=2;
do
{b+=k; k+=2;
} while (k<=n);
r=a-b;
printf (“suma wynosi %d”, r);
}
else {printf (“blad”);
}
getch();
}
P3 for
#include <stdio.h>
#include <conio.h>
void main()
{int n,r,a,b,i,k;
printf (“podaj n= “);
scanf (“%d”, &n);
a=0;
b=0;
if (n>=0)
{ for (i=1; i<=n; i+=2)
{a=a+i;
}
for (k=2; k<=n; k+=2)
{b=b+k;
}
r=a-b;
printf (“suma wynosi %d”, r);
}
else {printf (“blad”);
}
getch();
}
P3 while
#include <stdio.h>
#include <conio.h>
void main()
{int n,r,a,b,i,k;
printf (“podaj n= “);
scanf (“%d”, &n);
a=0;
b=0;
if (n>=0)
{
i=1;
while (i<=n)
{a+=i; i+=2;
}
k=2;
while (k<=n)
{b+=k; k+=2;
}
r=a-b;
printf (“suma wynosi %d”, r);
}
else {printf (“blad”);
}
getch();
}
P4
#include <stdio.h>
#include <conio.h>
#include <math.h>
void main()
{
int n,i,k,p;
double s;
float x;
char znak;
printf (“podaj n= “);
scanf (“%d”, &n);
printf (“podaj x= “);
scanf (“%f”, &x);
p=1;
s=1;
if (n>=0)
{
printf (“1 – silnia \n2 – potega\n”);
flushall();
znak=getchar();
switch (znak)
{
case’1′:
if (n<=20)
{
for (i=1; i<=n; i++)
{ s*=i;}
printf (” %d ! = %lf \7″, n,s);
}
else { printf(“blad \7″);} break;
case’2′:
for (k=1,p=x;k<n;k++)
{
x=x*p;
}
printf(“potega wynosi: %f \7″,x);break;
default: printf(“brak opcij”); }
}
getch();
}
P5
#include<stdio.h>
#include<conio.h>
#include<math.h>
void main()
{
int n,k,l,i;
float m,c,s,r;
printf(“n= “);
scanf(“%d” , &n);
s=0;
c=0;
printf(“n= %d”,n);
for(i=0,l=-1,m=0.5;i<n*0.5;i++)
{c+=(l+=2)/(m*=4);}
for(i=1,l=0,m=1;i<=n*0.5;i++)
{ s+=(l+=2)/(m*=4);}
r=c-s;
printf(“\nr= %f”, r);
printf(“\nc= %f \ns= %f \nn= %d”, c,s,n);
getch();
}
P6
#include<stdio.h>
#include<conio.h>
#include<math.h>
void main()
{
int n,i,m;
float s;
printf(“n= “);
scanf(“%d”, &n);
s=0;
for (i=0;((3*i)+1)<=n;i++)
{
if (i%2==0) {s+=(1/float(1+(3*i)));}
else {s-=(1/float(1+(i*3)));}
}
printf(“suma wynosi= %f”,s);
getch();
}
P8
#include <stdio.h>
#include <conio.h>
void main()
{
int i,h,a,l,s,t,p,m,f,k,b;
printf(“H= “);
scanf(“%d”,&h);
//definiowanie zmiennych
p=h-1;
a=0;
l=1;
s=1;
k=1;
f=1;
b=1;
//menu
printf(“\n 1-opcja pierwsza \n 2-opcja druga \n 3-opcja trzecia \n”);
flushall();
t=getch();
switch(t) {
case ’1′: //piramida wyrownana do lewej
for(i=1;i<=h;i++)
{
a+=i;
}
for(i=1;i<=a;i++)
{
printf(“x”);
if(i==s)
{
printf(“\n”);
l+=1;
s+=l;
} else
{
l+=0;
}
}
break;
case ’2′: //piramida wyrownana do prawej
for(i=1;i<=h;i++)
{
a+=i;
}
for(i=1;i<=a;i++)
{
if(i==k)
{
for(m=1;m<=p;m++)
{
printf(” “);
}
k+=f;
f+=1;
p–;
}
printf(“x”);
if(i==s)
{
printf(“\n”);
l+=1;
s+=l;
} else
{
l+=0;
}
}
break;
case ’3′: //piramida wysrodkowana
for(i=1;i<=h;i++)
{
a+=b;
b+=2;
}
for(i=1;i<=a;i++)
{
if(i==k)
{
for(m=1;m<=p;m++)
{
printf(” “);
}
k+=f;
f+=2;
p–;
}
printf(“x”);
if(i==s)
{
printf(“\n”);
l+=2;
s+=l;
} else
{
l+=0;
}
};
break;
default:
printf(“\n brak opcij\7\7\7\7″);
break;
}
getch();
}
Zagadnienia:
projektowanie algorytmów z wykorzystaniem funkcji; przekazywanie parametrów do funkcji
przez wartości; obliczanie sum szeregów; wykres funkcji w trybie tekstowym.
1. Opracować funkcję, która oblicza średnią arytmetyczną dwóch liczb rzeczywistych
przekazywanych do funkcji przez wartości za pomocą argumentów x i y. W programie
głównym wywołać funkcję dla danych wejściowych wczytywanych z klawiatury.
Prototyp funkcji: double SR(double x, double y).
2. Opracować funkcję, która dla x rzeczywistego oblicza sumę szeregu
E(x) = 1 + x1 / 1! + x2 / 2! + x3 / 3! + … + xi / i! + … .
Obliczenia należy zakończyć dla wyrazu o numerze i, dla którego | xi / i! | < EPS, gdzie
EPS=1E-8 jest stałą w programie (obliczanie ex z dokładnością EPS=10-8).
Zrealizować dwa warianty funkcji:
a) obliczającą sumę szeregu w oparciu o standardową funkcję podnoszenia do potęgi pow;
b) obliczającą sumę szeregu bez użycia funkcji pow.
Porównać wyniki z wartościami otrzymanymi za pomocą standardowej funkcji exp(x).
Prototyp funkcji: double E(double x, double eps);
3. Opracować funkcję, która oblicza sumę n pierwszych wyrazów szeregu przybliżającego
wartość sin(x) dla x typu rzeczywistego. Przyjąć, że x oraz n są argumentami funkcji.
S(x,n) = x1 / 1! – x3 / 3! + x5 / 5! – x7 / 7! + … ± x(2i-1) / (2i-1)! + …
Wartości zmiennej i są liczbami naturalnymi (i=1, 2, 3, …). Porównać wartość funkcji
S(x,n) dla wybranych x i n (np. x=2; n=8) z wartością standardowej funkcji sin(x). Dla
dużych n powinno być sin(x) ≈ S(x,n). Prototyp funkcji: double S(double x, int n).
4. Opracować funkcję, która oblicza sumę n pierwszych wyrazów szeregu przybliżającego
wartość arcsin(x) dla x typu rzeczywistego. Przyjąć, że x oraz n są argumentami funkcji.
A(x,n) = x + 1∗x3 / (2∗3) + 1∗3∗x5 / (2∗4∗5) +
+ 1∗3∗5∗x7 / (2∗4∗6∗7) + 1∗3∗5∗7∗x9 / (2∗4∗6∗8∗9) + …
Porównać wartość funkcji A(x,n) dla wybranych x i n (np. x=0.9; n=8) z wartością
standardowej funkcji asin(x). Dla dużych n powinno być asin(x) ≈ A(x,n). Prototyp
funkcji: double A(double x, int n).
5. Opracować funkcję, która rysuje w trybie znakowym wykres funkcji sin(x) w przedziale
od 0 do k*M_PI, gdzie M_PI jest stałą pi, natomiast k jest liczbą naturalną wczytywaną z
klawiatury. Przyjąć, że: oś Y przechodzi przez początek ekranu i jest skierowana w dół
ekranu, natomiast oś X przechodzi przez środek ekranu i jest skierowana w prawo.
Prototyp funkcji: void Rysuj(int k).
6. Opracować funkcję, która wyznacza sumę cyfr liczby naturalnej x, np. dla x=237 suma
cyfr wynosi 12. W programie głównym wywołać funkcję dla x wczytywanego z
klawiatury. Prototyp funkcji: int SC(int x).
pr1
#include<stdio.h>
#include<conio.h>
double SR(double x,double y)
{
double w=(x+y)/2;
return w;
}
double WCZYTANIE(double& a,double& b)
{
printf(“a= “);
scanf(“%lf”, &a);
printf(“b= “);
scanf(“%lf”, &b);
return 0;
}
void main()
{
double a,b;
WCZYTANIE(a,b);
printf(“srednia= %lf”,SR(a,b));
getch();
}
Pr2a
#include<stdio.h>
#include<conio.h>
#include<math.h>
double E(double x,double eps)
{
int i=1;
double s=1,k=1,m=0;
do
{
k*=i;
m=((pow(x,i))/k);
s+=m;
i++;
}
while(m>eps);
printf(“e= %.8lf \n”, s);
return s;
}
void main()
{
double e=0.00000001;
double a,s;
printf(“podaj x: \n”);
scanf(“%lf”, &a);
E(a,e);
s=exp(a);
printf(“e= %.8lf”,s);
getch();
}
Pr2b
#include<stdio.h>
#include<conio.h>
#include<math.h>
double E(double x,double eps)
{
int i=1;
double s=1,k=1,m,t=x;
do
{
k*=i;
t*=x;
m=((pow(x,i))/k);
s+=m;
i++;
}
while(m>eps);
printf(“e= %.8lf \n”, s);
return s;
}
void main()
{
double e=0.00000001;
double a,s;
printf(“podaj x: \n”);
scanf(“%lf”, &a);
E(a,e);
s=exp(a);
printf(“e= %.8lf”,s);
getch();
}
Pr3
#include<stdio.h>
#include<conio.h>
#include<math.h>
double S(double x,int n)
{int i,k;
double p,t,m,s,w,a,wynik;
for(i=1,m=1,a=1,t=1,s=0;i<=n;i+=4)
{
for(k=1;k<=i;k++)
{
m*=a;
t*=x;
p=t/m;
a++;
}
s+=p;
}
for(i=3,m=1,a=1,t=1,w=0;i<=n;i+=4)
{
for(k=1;k<=i;k++)
{
m*=a;
t*=x;
p=t/m;
a++;
}
w+=p;
}
wynik=(s-w);
printf(“sin= %lf”, wynik);
return wynik;
}
void main()
{
double x,l;
int n;
printf(“x= “);
scanf(“%lf”,&x);
printf(“n= “);
scanf(“%d”,&n);
S(x,n);
l=sin(x);
printf(“\n sin= %lf”,l);
getch();
}
Pr3+
#include<stdio.h>
#include<conio.h>
#include<math.h>
double S(double x,int n)
{int i,k;
double p,t,m,s,w,a,wynik,o,f;
for(i=1,o=1,s=0;i<=n;i+=2)
{
for(k=1,m=1,a=1,t=1;k<=o;k++)
{
m*=a;
t*=x;
p=t/m;
a++;
}
o+=4;
s+=p;
}
for(f=2,w=0,o=3;f<=n;f+=2)
{
for(k=1,m=1,a=1,t=1;k<=o;k++)
{
m*=a;
t*=x;
p=(t/m);
a++;
}
o+=4;
w+=p;
}
wynik=(s-w);
printf(“sin= %lf”, wynik);
return wynik;
}
void main()
{
double x,l;
int n;
printf(“x= “);
scanf(“%lf”,&x);
printf(“n= “);
scanf(“%d”,&n);
S(x,n);
l=sin(x);
printf(“\n sin= %lf”,l);
getch();
}
Pr4
#include<conio.h>
#include<stdio.h>
#include<math.h>
double A(double x,int n)
{
int i;
double l,k,s,t,m;
for(i=0,k=1,s=1,t=1,l=0,m=1;i<n;i++)
{
l+=(s*pow(x,k))/(t*k);
s*=k;
k+=2;
m*=2;
t*=m;
}
return l;
}
void main()
{
double x,k;
int n;
printf(“podaj x \n”);
scanf(“%lf”,&x);
printf(“podaj n \n”);
scanf(“%d”,&n);
printf(“\n %lf”,A(x,n));
getch();
}
Pr5
#include<stdio.h> //80,31
#include<conio.h>
#include<math>
const double M_Pi=3.14;
void OS()
{
int i;
printf(“\n\n y ^”);
printf(“\n\n 1″);
gotoxy(1,14);
printf(“0,5″);
gotoxy(2,24);
printf(“0″);
gotoxy(2,34);
printf(“-0,5″);
gotoxy(2,43);
printf(“-1″);
for(i=4;i<45;i++)
{
gotoxy(4,i);
printf(“\1″);
}
for(i=4;i<80;i++)
{
gotoxy(i,24);
printf(“\1″);
}
printf(“>”);
}
void Rysuj(int k)
{
int i,t;
double y,x,a;
for(i=0,x=0,a=-1;i<76;i+=1)
{
for(t=0;t<10000000;t++){}
y=(int(sin(x)*20));
if(y<0) {gotoxy(i+4,fabs(y)+24);printf(“\5″);} else
if(y==0) {gotoxy(i+4,y+24);printf(“\5″);a++;}
else if(y>0) {gotoxy(i+4,fabs(-y+24));printf(“\5″);}
x+=M_Pi/6;
if(a==k) {gotoxy(i+4,y+25);printf(“%d pi”,k);i=80;};
}
}
void main()
{
int n;
OS();
gotoxy(1,1);
printf(“podaj przedzial: “);
scanf(“%d”,&n);
Rysuj(n);
getch();
}
Pr5super
#include<stdio.h> //80,31
#include<conio.h>
#include<math.h>
const double M_Pi=3.14;
void OS()
{
int i,t;
printf(“\n y ^”);
printf(“\n\n 1″);
gotoxy(1,14);
printf(“0,5″);
gotoxy(2,24);
printf(“0″);
gotoxy(2,34);
printf(“-0,5″);
gotoxy(2,43);
printf(“-1″);
for(i=4;i<45;i++)
{for(t=0;t<1000000;t++) {}
gotoxy(4,i);
printf(“\1″);
}
for(i=4;i<80;i++)
{for(t=0;t<1000000;t++) {}
gotoxy(i,24);
printf(“\1″);
}
printf(“>”);
}
void Rysuj(int k)
{
int i,t;
double y,x,a,s;
//warunki rozciągnięcia sinusa
if(k==1) {s=62;} else if(k==2) {s=36;} else if (k<5) {s=18;} else if(k<7) {s=12;}
if(k>=7 && k<13) {s=6;} else if(k>=13 && k<16) {s=5;} else if(k>=16 && k<19) {s=4;}
else if(k>=19) {s=2;};
//koniec
for(i=0,x=0,a=-1;i<76;i+=1)
{
for(t=0;t<10000000;t++) {}
y=(int(sin(x)*20));
if(y<0) {gotoxy(i+4,fabs(y)+24);printf(“\5″);} else
if(y==0) {gotoxy(i+4,y+24);printf(“\5\7″);a++;}
else if(y>0) {gotoxy(i+4,fabs(-y+24));printf(“\5″);}
x+=M_Pi/s;
if(a==k) {gotoxy(i+4,y+25);printf(“%d\7\7 pi”,k);i=80;};
}
}
Pr6
void main()
{
int n;
gotoxy(1,1);
printf(“podaj przedzial: “);
scanf(“%d”,&n);
OS();
Rysuj(n);
getch();
}
#include<stdio.h>
#include<conio.h>
int SC(int x)
{
int i,k,s,w,r;
for(k=x,i=0,s=1,w=0,r=0;s!=0;i++)
{
s=int(k/10);
r=k%10;
k=s;
w+=(r);
}
return w;
}
void main()
{
int a;
printf(“a= “);
scanf(“%d”,&a);
if(a>0)
{
printf(“%d”,SC(a));
} else
{
printf(“to nie liczba naturalna”);
}
getch();
}
Zagadnienia:
poznanie zastosowań instrukcji warunkowych if, if-else oraz instrukcji wyboru switch;
programy rozgałęzione; typy proste definiowane przez użytkownika – typ wyliczeniowy
(enum).
1. Wczytać z klawiatury 3 zmienne typu double. Wyznaczyć liczbę minimalną stosując:
a) tylko operator warunkowy (?).
b) tylko instrukcje warunkowe (if lub if-else).
2. Opracować program rozwiązujący równanie kwadratowe ax2 + bx + c = 0. Rozpatrzyć
przypadki szczególne: a=0 & b=0 & c=0, a=0 & b=0 & c<>0, a=0 & b<>0 & c<>0,
a=0 & b<>0 & c=0, a<>0 & b=0 & c=0, a<>0 & b=0 & c<>0, a<>0 & b<>0 & c<>0,
a<>0 & b<>0 & c=0.
3. Określić przez, które ćwiartki układu współrzędnych (lub oś X) przechodzi prosta postaci
y=ax+b, gdzie a i b są danymi wczytywanymi z klawiatury. Na przykład, dla a=2; b=2;
prosta y=2x+2 przechodzi przez 1, 2 i 3 ćwiartkę; dla a=b=0; prosta y=0 pokrywa się z
osią X.
4. Opracować program, który zamienia współrzędne kartezjańskie (x,y) na współrzędne
biegunowe (d,k), gdzie d i k są zadane wzorami:
d = sqrt(x2 + y2),
I ćwiartka: k = arctg(y/x) dla x>0 & y>=0; k = pi/2 dla x=0 & y>=0;
II, III: k = pi + arctg(y/x) dla x<0 & y – dowolny;
IV: k = 2∗pi + arctg(y/x) dla x>0 & y<0; k = 3∗pi/2 dla x=0 & y<0.
5. Wprowadzić z klawiatury rok, miesiąc i dzień. Jeżeli data jest poprawna, tj. dzień < 32,
miesiąc < 13, styczeń < 32, luty < 30 w roku przestępnym oraz luty < 29 w roku
zwykłym, marzec < 32, itd., to wyprowadzić na ekran datę (miesiąc słownie). Uwzględnić
lata przestępne. Przyjąć, że rok nie jest przestępny (rok zwykły) jeśli: nie dzieli się przez 4
lub dzieli się przez 100, ale nie przez 400 (np. lata zwykłe: 1700, 1800, 2100; lata
przestępne: 4, 1600, 1996, 2000, 2400). W szczególności data 29-02-1800 r. nie jest datą
poprawną.
6. Zadeklarować zmienną dzien typu wyliczeniowego Tdni reprezentującą dni tygodnia
{pon, wt, sr, czw, pt, sob, niedz}. Zainicjować zmienną dzien w programie. Przyjmując,
że zmienna dzien jest selektorem instrukcji wyboru switch wyprowadzić pełną nazwę dnia
tygodnia.
7. Opracować program kalkulatora uwzględniającego działania (+, -, /, *) oraz funkcje: sin,
cos, tan, asin, acos, atan, log, log10, exp, pow, ldexp(x,n)=x∗2n, sqrt, fabs, fmod, ceil,
floor, abs.
8. Opracować program, który wyprowadza na ekran kod wciśniętego klawisza. Uwzględnić
klawisze specjalne, np. F1, F2, strzałki. Podać kody klawiaturowe strzałek i F1-F10.
P1a
#include<stdio.h>
#include<conio.h>
void main()
{double a,b,c;
printf(“a= “);
scanf(“%lf”, &a);
printf(“b= “);
scanf(“%lf”, &b);
printf(“c= “);
scanf(“%lf”, &c);
(a<b && a<c) ? printf(“liczba min: %lf”, a) : (a>b && b<c) ? printf(“liczba min: %lf”, b) :
(c<b && c<a) ? printf(“liczba min: %lf”, c) : printf(“liczby sa rowne”);
getch();
}
P1b
#include<stdio.h>
#include<conio.h>
void main()
{double a,b,c;
printf(“a= “);
scanf(“%lf”, &a);
printf(“b= “);
scanf(“%lf”, &b);
printf(“c= “);
scanf(“%lf”, &c);
if(a<b && a<c) {printf(“liczba min: %lf”, a);}
else if(a>b && b<c){printf(“liczba min: %lf”, b);}
else if(c<b && c<a) {printf(“liczba min: %lf”, c);}else
{printf(“liczby sa rowne”);}
getch();
}
P2
#include<math.h>
#include<stdio.h>
#include<conio.h>
void main()
{
float a,b,c,del,x1,x2;
printf(“A= “);
scanf(“%f”, &a);
printf(“B= “);
scanf(“%f”, &b);
printf(“C= “);
scanf(“%f”, &c);
del=b*b-4*a*c;
if(a!=0) {
if(del<0) {printf(“pierwistki nie isnieja”);} else
if(del==0) {x1=(-b/(2*a)); printf(“x1=x2= %.2f”, x1);}
else{x1=(-b-sqrt(del))/(2*a); x2=(-b+sqrt(del))/(2*a); printf(“x1= %.2f x2= %.2f”, x1,x2);
}} else {printf(“funkcja liniowa”);}
getch();
}
P3
#include<stdio.h>
#include<conio.h>
void main()
{float a,b;
printf(“a= “);
scanf(“%f”, &a);
printf(“b= “);
scanf(“%f”, &b);
(a>0 && b>0) ? printf(“cwiartka: 1,2 i 3″) :
(a>0 && b<0) ? printf(“cwiartka: 1,3 i 4″) :
(a>0 && b==0) ? printf(“cwiartka: 1 i 3″) :
(a==0 && b>0) ? printf(“cwiartka: 1 i 2″) :
(a==0 && b==0) ? printf(“prosta pokrywa sie z osia OX”) :
(a==0 && b<0) ? printf(“cwiartka: 3 i 4″):
(a<0 && b>0) ? printf(“cwiartka: 1,2 i 4″):
(a<0 && b==0) ? printf(“cwiartka: 2 i 4″):
printf(“cwiartka: 2,3 i 4″);
getch();
}
P4
#include<stdio.h>
#include<conio.h>
#include<math.h>
void main()
{float x,y,d,k,pi=3.14;
printf(“x= “);
scanf(“%f”, &x);
printf(“y= “);
scanf(“%f”, &y);
d = sqrt(x*x + y*y);
if(x>0 && y>=0) {
k=atan(y/x);} else if (x==0 && y>=0) {
k=pi/2;} else if (x<0) {
k=pi + atan(y/x);} else if(x>0 && y<0) {
k=2*pi+atan(y/x);} else if(x==0 && y<0) {k=3*pi/2;} else {printf(“bledne k”);}
printf(“wspolrzedne biegunowe= (%.2f, %.2f)”, d,k);
getch();
}
P5
#include<stdio.h>
#include<conio.h>
void main()
{
int r,m,d;
printf(“rok: “);
scanf(“%d”, &r);
printf(“miesiac: “);
scanf(“%d”, &m);
printf(“dzien: “);
scanf(“%d”, &d);
if(m==1 && d<32 && d>0) { printf(“data: %d styczen %d”, d,r); } else if
(m==3 && d<32 && d>0) { printf(“data: %d marzec %d”, d,r); } else if
(m==4 && d<31 && d>0) { printf(“data: %d kwiecien %d”, d,r); } else if
(m==5 && d<32 && d>0) { printf(“data: %d maj %d”, d,r); } else if
(m==6 && d<31 && d>0) { printf(“data: %d czerwiec %d”, d,r); } else if
(m==7 && d<32 && d>0) { printf(“data: %d lipiec %d”, d,r); } else if
(m==8 && d<32 && d>0) { printf(“data: %d sierpien %d”, d,r); } else if
(m==9 && d<31 && d>0) { printf(“data: %d wrzesien %d”, d,r); } else if
(m==10 && d<32 && d>0) { printf(“data: %d pazdziernik %d”, d,r); } else if
(m==11 && d<31 && d>0) { printf(“data: %d listopad %d”, d,r); } else if
(m==12 && d<32 && d>0) { printf(“data: %d grudzien %d”, d,r); } else if(m==2)
{if(r%4!=0 ||(r%100==0 && r%400!=0)) {(d<29) ? printf(“data: %d luty %d”, d,r) : printf(“blad”); }
else {(d<30) ? printf(“data: %d luty %d”, d,r) : printf(“blad2″); }}
else {printf(“Nieprawidlowa data”);}
getch();
}
P6
#include<stdio.h>
#include<conio.h>
#include<math.h>
void main()
{int tdni, i;
printf(“podaj 3 pierwsze litery dnia \n”);
scanf(“%i”, i);
enum tdni{pon, wto, sro, czw, pia, sob, nie};
tdni dni;
switch(tdni) {
case pon: printf(“poniedzialek”); break;
case wto: printf(“wtorek”); break;
case sro: printf(“sroda”); break;
case czw: printf(“czwartek”); break;
case pia: printf(“piatek”); break;
case sob: printf(“sobota”); break;
case nie: printf(“niedziela”); break;
default: printf(“nie ma takiego dnia”);}
getch();
}
P6+
#include <stdio.h>
#include <conio.h>
void main()
{
enum Tdni
{ pon,wt,sr,czw,pt,sob,niedz
} ;
Tdni dzien ;
dzien = sr ;
switch (dzien)
{
case pon : printf(“Poniedzialek”) ; break ;
case wt : printf(“Wtorek”) ; break ;
case sr : printf(“Sroda”) ; break ;
case czw : printf(“Czwartek”) ; break ;
case pt : printf(“Piatek”) ; break ;
case sob : printf(“Sobota”) ; break ;
case niedz : printf(“Niedziel”) ; break ;
}
getch();
P7
#include <stdio.h>
#include <conio.h>
#include <math.h>
void main ()
{
float a,b,w;
char znak;
printf (“a= “);
scanf (“%f”, &a);
printf (“b= “);
scanf (“%f”, &b);
flushall();
znak=getchar();
switch (znak)
{
case ‘+’: w=a+b; printf(“wynik: %f”, w); break;
case ‘-’: w=a-b; printf (“wynik: %f”, w); break;
case ‘/’: w=a/b; printf (“wynik: %f”, w); break;
case ‘*’: w=a*b; printf (“wynik: %f”, w); break;
case ‘s’: w=sin(a); printf (“wynik: %f”, w); break;
case ‘c’: w=cos(a); printf (“wynik: %f”, w); break;
case ‘t’: w=tan(a); printf (“wynik: %f”, w); break;
case ’1′: w=asin(a); printf (“wynik: %f”, w); break;
case ’2′: w=acos(a); printf (“wynik: %f”, w); break;
case ’3′: w=atan(a); printf (“wynik: %f”, w); break;
case ’4′: w=log(a); printf (“wynik: %f”, w); break;
case ’5′: w=log10(a); printf (“wynik: %f”, w); break;
case ’6′: w=log(b)/log(a); printf (“wynik: %f”, w); break;
case ’7′: w=exp(a); printf (“wynik: %f”, w); break;
case ’8′: w=pow(a,b); printf (“wynik: %f”, w); break;
case ’9′: w=fabs(a); printf (“wynik: %f”, w); break;
case ’0′: w=fmod(a,b); printf (“wynik: %f”, w); break;
case ‘q’: w=ceil(a); printf (“wynik: %f”, w); break;
case ‘f’: w=floor(a); printf (“wynik: %f”, w); break;
case ‘a’: w=abs(a); printf (“wynik: %f”, w); break;
}
getch();
}
P8
#include<stdio.h>
#include<conio.h>
void main()
{float a;
printf (“Press any key \n”);
a=getch();
if (a==0) {
getch();
}
printf(“kod Ascii= %f”, a);
getch();
}
