Zadanie 1/L1 - Napisz program pobierający od Zadanie 1'/L1 - Napisz program wymagający do

użytkownika <imie> i wypisujący tekst "Witaj uruchomienia jednego parametru (imienia

<imie>". użytkownika) i wypisujący na ekranie tekst "Witaj
<imie>".
Przykład użycia:
Przykład użycia:
./a.out ./a.out Jan
Podaj imie: Jan Witaj Jan
Witaj Jan =====================================
======================================== #include <stdio.h>
#include <stdio.h>
int main(int argc, char *argv[]) {
int main() { if (argc < 2) {
printf("Podaj imie jako argument
char imie[20];
programu.\n");
printf("Podaj imie: "); return 1;
scanf("%s", imie); }
printf("Witaj %s\n", imie); printf("Witaj %s\n", argv[1]);
return 0; return 0;
} }

Zadanie 2/L1 PĘTLA FOR - Napisz program, który Zadanie 2/L1 PĘTLA DO-WHILE - Napisz program,
pobiera od użytkownika liczbę całkowitą n i wyświetla który pobiera od użytkownika liczbę całkowitą n i
na ekranie tekst piosenki zgodny z podanym wzorcem. wyświetla na ekranie tekst piosenki zgodny z
Przykład użycia:
podanym wzorcem.
./a.out
Przykład użycia:
Podaj n: 3
3 butelki oranzady staly na plocie, o 3 butelki! Jesli ./a.out
jedna zrzucimy zostanie 2! Podaj n: 2
2 butelki oranzady staly na plocie, o 2 2 butelki oranzady staly na plocie, o
butelki! Jesli jedna zrzucimy zostanie 2 butelki! Jesli jedna zrzucimy
1! zostanie 1!
1 butelka oranzady stala na plocie, o 1
1 butelka oranzady stala na plocie, o
butelka! Jesli jedna zrzucimy nie
zostanie zadna! 1 butelka! Jesli jedna zrzucimy nie
======================================== zostanie zadna!
#include <stdio.h> =====================================
#include <stdio.h>
int main() {
int main() {
int n;
int n, i = 0;
printf("Podaj n: "); printf("Podaj n: ");
scanf("%d", &n); scanf("%d", &n);
for (int i = n; i > 1; i--) { n--;
printf("%d butelki oranzady staly na plocie, o %d do {
butelki! Jesli jedna zrzucimy zostanie %d!\n", i, i, i-1); printf("%d butelki oranzady staly na plocie, o
} %d butelki! Jesli jedna zrzucimy zostanie %d!\n",
n-i+1, n-i+1, n-i);
i++;
printf("1 butelka oranzady stala na plocie, o 1 butelka! } while (i < n);
Jesli jedna zrzucimy nie zostanie zadna!"); printf("1 butelka oranzady stala na plocie, o
return 0; 1 butelka! Jesli jedna zrzucimy nie zostanie
} zadna!\n");
return 0;
}
Zadanie 2/L1 PĘTLA WHILE - Napisz program, który Zadanie 3/L1 - Napisz program, który pobiera od
pobiera od użytkownika liczbę całkowitą n i wyświetla użytkownika liczbę sekund i wypisuje na ekran
na ekranie tekst piosenki zgodny z podanym przeliczenie: ile to lat, miesięcy,
wzorcem. tygodni, dni, godzin, minut i sekund. Czy milion sekund
Przykład użycia: to dużo?
./a.out =======================================
Podaj n: 2 #include <stdio.h>
2 butelki oranzady staly na plocie, o
2 butelki! Jesli jedna zrzucimy int main() {
zostanie 1!
1 butelka oranzady stala na plocie, o int lata, miesiace, tygodnie, dni, godziny,
1 butelka! Jesli jedna zrzucimy nie minuty, sekundy, wejscie;
zostanie zadna! printf("Podaj liczbe sekund: ");
====================================== scanf("%d", &sekundy);
#include <stdio.h> wejscie = sekundy;
lata = sekundy / (60 * 60 * 24 * 365);
int main() { sekundy = sekundy % (60 * 60 * 24 * 365);
int n;
miesiace = sekundy / (60 * 60 * 24 * 30);
printf("Podaj n: ");
scanf("%d", &n); sekundy = sekundy % (60 * 60 * 24 * 30);
while (n > 1) { tygodnie = sekundy / (60 * 60 * 24 * 7);
printf("%d butelki oranzady staly na plocie, o sekundy = sekundy % (60 * 60 * 24 * 7);
%d butelki! Jesli jedna zrzucimy zostanie %d!\n", n, n, dni = sekundy / (60 * 60 * 24);
n-1); sekundy = sekundy % (60 * 60 * 24);
n--; godziny = sekundy / (60 * 60);
}
sekundy = sekundy % (60 * 60);
printf("1 butelka oranzady stala na plocie, o 1
butelka! Jesli jedna zrzucimy nie zostanie zadna!\n"); minuty = sekundy / 60;
return 0; sekundy = sekundy % 60;
}
====================================== printf("%d sekund to:\n", wejscie);
printf("%d lat, %d miesiecy, %d tygodni, %d
Zadanie 4/L1 - Napisz program pobierający od
dni, %d godzin, %d minut, %d sekund\n",
użytkownika napis i wyświetlający informację o ilości
liter w napisie (podpowiedz: strlen() ). Czy lata, miesiace, tygodnie, dni, godziny, minuty,
program poprawnie obsługuje polskie znaki sekundy);
diakrytyczne? (NIE)
====================================== return 0;
#include <stdio.h> }
#include <string.h> =======================================
Podaj liczbe sekund: 1000000
int main() { 1000000 sekund to:
char napis[100];
0 lat, 0 miesiecy, 1 tygodni, 4 dni, 13 godzin, 46 minut,
int dlugosc, ilosc_liter = 0;
printf("Podaj napis: "); 40 sekund
fgets(napis, 100, stdin);
dlugosc = strlen(napis);
for(int i = 0; i < dlugosc; i++) {
if(napis[i] >= 'a' && napis[i] <= 'z' || napis[i] >=
'A' && napis[i] <= 'Z') {
ilosc_liter++;
}
}
printf("Ilosc liter w napisie: %d\n", ilosc_liter);
return 0;
}
Zadanie 5/L1 - Napisz program, który pobiera od Zadanie 6/L1 - Zaimplementuj funkcję reverse(),
użytkownika liczbę całkowitą (scanf(), typ danych: która odwraca kolejność znaków w pobranym od
%d) i wypisuje na ekran sumę cyfr tej liczby. użytkownika napisie (tablicy znaków).
Np. dla liczby 2091 wynik to: 2 + 0 + 9 + 1 = 12. ======================================
#include <stdio.h>
Podpowiedź: W rozwiązaniu potraktuj liczbę jako #include <string.h>
tablicę znaków (podpowiedź: użyj funkcji
sprintf() aby wpisać liczbę do tablicy znaków).
void reverse(char *str) {
======================================
int len = strlen(str);
#include <stdio.h>
for (int i = 0; i < len / 2; i++) {
char tmp = str[i];
int main() {
str[i] = str[len - i - 1];
int liczba, cyfra, suma = 0;
str[len - i - 1] = tmp;
printf("Podaj liczbe calkowita: ");
}
scanf("%d", &liczba);
}

while (liczba > 0) {

int main() {
cyfra = liczba % 10;
char str[100];
suma += cyfra;
printf("Podaj napis: ");
liczba /= 10;
scanf("%s", str);
}
printf("Przed odwroceniem: %s\n", str);
printf("Suma cyfr tej liczby wynosi: %d\n",
reverse(str);
suma);
printf("Po odwroceniu: %s\n", str);
return 0;
return 0;
}
}

Jaka jest wielkość typu size_t?

Zadanie 7/L1 - Do czego służy operator sizeof()? Napisz
program, który wypisze na ekranie informacje o wielkości typów Wielkość typu size_t zależy od platformy
podstawowych (char, short int, int, long int, float, i kompilatora, ale zazwyczaj jest to typ bez
double). znaku o wielkości odpowiadającej liczbie
=============================================== bajtów wykorzystywanych do reprezentacji
#include <stdio.h> wskaźników i tablic. Na platformach
32-bitowych zwykle zajmuje 4 bajty, a na
platformach 64-bitowych 8 bajtów.
int main() {
printf("Typ char zajmuje %d bajtow\n", (int)sizeof(char));
printf("Typ short int zajmuje %d bajtow\n", (int)sizeof(short int));
printf("Typ int zajmuje %d bajtow\n", (int)sizeof(int));
printf("Typ long int zajmuje %d bajtow\n", (int)sizeof(long int));
printf("Typ float zajmuje %d bajtow\n", (int)sizeof(float));
printf("Typ double zajmuje %d bajtow\n", (int)sizeof(double));
return 0;
}
 #include <stdio.h>
Zadanie 8/L1 - Napisz program, który pobiera od #include <string.h>
użytkownika tekst (ciąg znaków, który może zawierać #include <ctype.h>
spację oraz znak nowego wiersza), int main()
aż do napotkania wiersza składającego się ze słowa {
STOP (wielkość liter w tym słowie ma znaczenie!). char text[50 * 200];
Następnie program wyświetla tekst w następujący char line[200];
sposób: int next_text_index;
int i;
- pomijane są białe znaki (spacje " ", znaki nowego
next_text_index = 0;
wiersza "\n", tabulacje "\t"), while (fgets(line, 200, stdin))
- każdy wyraz wypisywany jest w oddzielnym wierszu, {
- znaki interpunkcyjne, liczby, itp. traktowane są jak for (i = 0; line[i] != '\0'; i++)
wyrazy (tj. każdy wyświetlany jest w oddzielnym {
wierszu). if (line[i] == '\n')
{
Uwaga: Można założyć, że użytkownik wprowadzi co
line[i] = '\0';
najwyżej 50 linii, z których każda ma co najwyżej 200
break;
znaków.
}
}
Podpowiedź: aby wczytać pojedynczy wiersz użyj
if (strcmp(line, "STOP") == 0)
funkcji fgets().
{
break;
}
for (i = 0; line[i] != '\0'; i++)
{
if (!isspace(line[i]))
{
text[next_text_index] = line[i];
next_text_index++;
}
}
}
text[next_text_index] = '\0';
if (text[0])
{
printf("%c", text[0]);
for (i = 1; text[i] != '\0'; i++)
{
if (!isalpha(text[i]) || (isalpha(text[i]) &&
!isalpha(text[i - 1])))
{
printf("\n");
}
printf("%c", text[i]);
}
}
printf("\n");
return 0;
}
Zadanie 1/L2 (na rozgrzewkę) - ZawodyWeb #include <stdio.h>
#include <string.h>
Napisz program pobierający od użytkownika <imie> i
wypisujący tekst "Czesc <imie>!". int main() {
Przykład użycia: char imie[20];
scanf("%s", imie);
./a.out printf("Czesc %s!\n", imie);
Jan
Czesc Jan! return 0;
}

Zadanie 2/L2 - ZawodyWeb #include <stdio.h>

#include <string.h>
Napisz program, który pobiera od użytkownika jeden
napis (nie zawierający spacji) i wyświetla go na int main() {
ekranie "od końca". Przykład użycia: char napis[100];
int dlugosc, i;
./a.out
Napis scanf("%s", napis);
sipaN
dlugosc = strlen(napis);

for (i = dlugosc - 1; i >= 0; i--) {

printf("%c", napis[i]);
}
printf("\n");

return 0;
}

#include <stdio.h>
Zadanie 3/L2
void liczby_parzyste(int a, int b) {
Zaimplementuj funkcję, która jako parametr wywołania int i;
przyjmuje dwie liczby (a oraz b) i wyświetla wszystkie
liczby parzyste znajdujące się w przedziale [a...b]. for (i = a; i <= b; i++) {
if (i % 2 == 0) {
Napisz program przyjmujący dwa argumenty z linii printf("%d ", i);
komend - a oraz b, aby przetestować napisaną }
funkcję. }
printf("\n");
Podpowiedź: Użyj funkcji sscanf() do zamiany }
argumentu wywołania programu (który jest tablicą
znaków) na typ int. int main(int argc, char *argv[]) {
int a, b;
if (sscanf(argv[1], "%d", &a) != 1 ||
sscanf(argv[2], "%d", &b) != 1) {
printf("Niepoprawne argumenty\n");
return 1;
}
liczby_parzyste(a, b);
return 0;
}
Zadanie 4/L2 Zadanie 6/L2
Napisz i przetestuj funkcję, która jako parametr
przyjmuje liczbę całkowitą, oblicza i zwraca silnię. Napisz program, który przyjmuje dowolną liczbę
Przetestuj implementację iteracyjną oraz rekurencyjną. argumentów (liczby całkowite) i wyświetla
======================================= największą oraz najmniejszą z nich.
#include <stdio.h>
Podpowiedź: Użyj funkcji sscanf() do zamiany
// Implementacja iteracyjna argumentu wywołania programu (który jest tablicą
int silnia_iteracyjnie(int n) { znaków) na typ int.
int i, wynik = 1;
for (i = 1; i <= n; i++) { ======================================
wynik *= i;
} #include <stdio.h>
return wynik;
} int main(int argc, char *argv[]) {

// Implementacja rekurencyjna int min = 0, max = 0, current = 0;

int silnia_rekurencyjnie(int n) {
if (n == 0) { sscanf(argv[1], "%d", &min);
return 1;
} else { sscanf(argv[1], "%d", &max);
return n * silnia_rekurencyjnie(n-1);
for (int i = 2; i < argc; i++) {
}
}
sscanf(argv[i], "%d", &current);
int main() { if (current < min) {
int n;
printf("Podaj liczbe, dla ktorej chcesz obliczyc silnie: min = current;
");
scanf("%d", &n); }
printf("Silnia z %d wynosi %d (iteracyjnie)\n", n,
silnia_iteracyjnie(n)); if (current > max) {
printf("Silnia z %d wynosi %d (rekurencyjnie)\n", n,
silnia_rekurencyjnie(n)); max = current;
return 0;
} }

printf("Najmniejsza liczba: %d\n", min);

printf("Największa liczba: %d\n", max);

return 0;

}
 unsigned long factorial_ulong(unsigned long n) {
Zadanie 5/L2 unsigned long result = 1;
for (unsigned long i = 2; i <= n; i++) {
Jaka jest największa liczba, dla której silnia liczona if (ULONG_MAX / i < result) {
jest poprawnie, tj. do momentu przekroczenia zakresu return i - 1;
liczb przechowywanych prze typ danych: }
result *= i;
● dla typu int, }
● dla typu unsigned int, return n;
● dla typów long oraz unsigned long, }
● dla typów float oraz double. float factorial_float(float n) {
float result = 1.0;
Napisz program znajdujący taką liczbę. for (float i = 2.0; i <= n; i++) {
if (isinf(result * i)) {
====================================== return i - 1;
#include <stdio.h> }
#include <limits.h> result *= i;
#include <float.h> }
#include <math.h> return n;
}
int factorial_int(int n) { double factorial_double(double n) {
int result = 1; double result = 1.0;
for (int i = 2; i <= n; i++) { for (double i = 2.0; i <= n; i++) {
if (INT_MAX / i < result) { if (isinf(result * i)) {
return i - 1; return i - 1;
} }
result *= i; result *= i;
} }
return n; return n;
} }
int main() {
unsigned int factorial_uint(unsigned int n) { int max_int = factorial_int(INT_MAX);
unsigned int result = 1; printf("Maksymalna liczba dla typu int: %d\n",
for (unsigned int i = 2; i <= n; i++) { max_int);
if (UINT_MAX / i < result) { unsigned int max_uint =
return i - 1; factorial_uint(UINT_MAX);
} printf("Maksymalna liczba dla typu unsigned
result *= i; int: %u\n", max_uint);
} long max_long = factorial_long(LONG_MAX);
return n; printf("Maksymalna liczba dla typu long:
} %ld\n", max_long);
unsigned long max_ulong =
long factorial_long(long n) { factorial_ulong(ULONG_MAX);
long result = 1; printf("Maksymalna liczba dla typu unsigned
for (long i = 2; i <= n; i++) { long: %lu\n", max_ulong);
if (LONG_MAX / i < result) { float max_float = factorial_float(FLT_MAX);
return i - 1; printf("Maksymalna liczba dla typu float:
} %.0f\n", max_float);
result *= i; double max_double =
} factorial_double(DBL_MAX);
return n; printf("Maksymalna liczba dla typu double:
} %.0f\n", max_double);
return 0;
}
 #include <stdio.h>
Zadanie 7/L2
void printBinary(int x) {
Napisz program, który pobiera od użytkownika liczbę int i;
całkowitą i wyświetla tę liczbę w zapisie ósemkowym, for (i = sizeof(x) * 8 - 1; i >= 0; i--) {
szesnastkowym i binarnym. if (x & (1 << i))
printf("1");
Podpowiedź: aby wyświetlić zapis ósemkowy i else
szesnastkowy użyj odpowiednich parametrów funkcji printf("0");
printf(). }
Napisz własną funkcję do wyświetlania zapisu printf("\n");
binarnego. Możesz użyć następujących obserwacji: }
● sizeof() zwraca wielkość zmiennej w int main() {
bajtach, stąd wiemy, że zmienna x zapisana int x;
jest w pamięci przy pomocy sizeof(x) * 8 printf("Podaj liczbe calkowita: ");
bitów, scanf("%d", &x);
● bit o numerze i ma wartość 1 wtedy i tylko
wtedy, gdy wyrażenie ( x & (1 << i)) printf("Zapis osemkowy: %o\n", x);
jest prawdziwe (dlaczego?). printf("Zapis szesnastkowy: %X\n", x);
printf("Zapis binarny: ");
Który bit powinien być wypisywany na ekran jako printBinary(x);
pierwszy?
return 0;
}

#include <stdio.h>
Zadanie 8/L2 #include <stdlib.h>
#include <time.h>
Napisz program, który losuje liczbę z
przedziału 1...15 i prosi użytkownika o jej int main() {
odgadnięcie. Jeśli użytkownik się pomyli, to srand(time(NULL));
program powinien podpowiedzieć czy int liczba = rand() % 15 + 1;
użytkownik podał za małą czy za dużą liczbę. int zgadniete = 0;
Program kończy się gdy użytkownik zgadnie
wylosowaną liczbę. while (!zgadniete) {
int strzal;
printf("Podaj liczbe z przedzialu 1...15: ");
Podpowiedź: aby wylosować liczbę całkowitą scanf("%d", &strzal);
użyj funkcji rand() zdefiniowanej w pliku if (strzal < 1 || strzal > 15) {
nagłówkowym stdlib.h. Aby program przy printf("Podaj liczbe z przedzialu 1...15!\n");
każdym uruchomieniu losował inną liczbę, } else if (strzal < liczba) {
przed losowaniem ustaw wartość startową printf("Za malo!\n");
generatora liczb losowych na czas } else if (strzal > liczba) {
uruchomienia (przy pomocy wywołania: printf("Za duzo!\n");
srand(time(NULL))). } else {
printf("Brawo! Zgadles liczbe %d.\n", liczba);
zgadniete = 1;
}
}

return 0;
}
Zadanie 1/L2 - ZawodyWeb #include <stdio.h>

Napisz program, który pobiera od użytkownika liczbę int main() {

całkowitą (scanf(), typ danych: %d) i wypisuje na int n, sum = 0;
ekran sumę cyfr tej liczby (np. dla liczby 2091 wynik scanf("%d", &n);
to: 2 + 0 + 9 + 1 = 12). while (n > 0) {
Przykład użycia: sum += n % 10;
n /= 10;
./a.out }
2091 printf("%d", sum);
12 return 0;
}

// check if third and fifth bits are on

Zadanie 1/L3 - Napisz program, który pobiera od
użytkownika napis złożony z cyfr 1 oraz 0 (tj. liczbę w
zapisie binarnym) a następnie, przy użyciu operacji
bitowych, oblicza i wyświetla :
● tę liczbę w systemie dziesiętnym;
● informacje, czy 3 oraz 5 bit są "włączone",
● informacje czy 3 lub 5 bit są "włączone".,
● (dziesiętnie) wartość podanej liczby po
"włączeniu" 3 bitu,
● (dziesiętnie) wartość podanej liczby po
"wyłączeniu" 1 bitu,
● (dziesiętnie) wartość 8 * podana_liczba,
● (dziesiętnie) wartość podana_liczba / 4.
======================================
#include <stdio.h>
int main() {
char binary[10];
int decimal = 0;
int third_bit_on = 0;
int fifth_bit_on = 0;
int three_or_five_bits_on = 0;
int turn_on_third_bit = 0;
int turn_off_one_bit = 0;
int multiply_eight = 0;
float divide_four = 0;
printf("Enter a binary number (up to 9 digits):
");
scanf("%s", binary);
// convert binary to decimal
for (int i = 0; binary[i] != '\0'; i++) {
decimal = decimal << 1;
if (binary[i] == '1') {
decimal = decimal | 1;
} printf("Trzeci lub piąty bit jest wlaczony.\n");
} else printf("Trzeci i piąty bit są wylaczone.\n");
printf("Decimal: %d\n", decimal);
if (decimal & 0b00000100) {
third_bit_on = 1;
}
if (decimal & 0b00010000) {
fifth_bit_on = 1;
}
printf("Third bit on: %d\n", third_bit_on);
printf("Fifth bit on: %d\n", fifth_bit_on);
// check if 3 or 5 bits are on
if ((decimal & 0b00000100) || (decimal &
0b00010000)) {
three_or_five_bits_on = 1;
}
printf("3 or 5 bits on: %d\n",
three_or_five_bits_on);
// turn on third bit
turn_on_third_bit = decimal | 0b00001000;
printf("Turn on third bit: %d\n",
turn_on_third_bit);
// turn off one bit
turn_off_one_bit = decimal & 0b11110111;
printf("Turn off one bit: %d\n",
turn_off_one_bit);
// multiply by 8
multiply_eight = decimal << 3;
printf("Multiply by 8: %d\n", multiply_eight);
// divide by 4
divide_four = decimal >> 2;
printf("Divide by 4: %f\n", divide_four);
if ((decimal & (1 << 2)) || (decimal & (1 << 4)))
return 0;
}
 if (ch == '\n') {
Zadanie 2/L3 Napisz program, który czyta dane z line_count++;
pliku dane.txt oraz: Wyświetla treść pliku na printf("Liczba znaków w wierszu %d: %d\n",
ekranie. Wyświetla informacje o całkowitej liczbie line_count, char_count_per_line);
znaków w pliku. Wyświetla informacje o ilości znaków char_count_per_line = 0;
w kolejnych wierszach. Wyświetla treść pliku } else {
zapisaną KAPITALIKAMI (podpowiedź: funkcja char_count_per_line++;
toupper()). Zapisuje w pliku wynik.txt treść }
pliku dane.txt zapisaną kapitalikami. }
// Wyświetl informacje o całkowitej liczbie
====================================== znaków w pliku
printf("Całkowita liczba znaków w pliku: %d\n",
#include <stdio.h> char_count);
#include <ctype.h>
#define MAXLINE 1000 // Wyświetl treść pliku zapisaną
int main() { KAPITALIKAMI
FILE *fp; rewind(fp);
char ch; printf("\nTreść pliku dane.txt zapisana
char line[MAXLINE]; KAPITALIKAMI:\n");
int char_count = 0;
int line_count = 0; while ((ch = fgetc(fp)) != EOF) {
int char_count_per_line = 0; putchar(toupper(ch));
// Otwórz plik dane.txt w trybie odczytu }
fp = fopen("dane.txt", "r");
// Sprawdź, czy plik został otwarty prawidłowo FILE *result_fp = fopen("wynik.txt", "w");
if (fp == NULL) { rewind(fp);
printf("Nie można otworzyć pliku dane.txt.\n"); while (fgets(line, MAXLINE, fp) != NULL) {
return 1; int i = 0;
} while (line[i]) {
// Wyświetl treść pliku na ekranie fputc(toupper(line[i]), result_fp);
printf("Treść pliku dane.txt:\n"); i++;
while ((ch = fgetc(fp)) != EOF) { }
putchar(ch); }
char_count++; fclose(fp);
fclose(result_fp);
return 0;
}

NWD dwóch liczb #include <stdio.h>

int main() {
int a, b, nwd;
printf("Podaj pierwsza liczbe: ");
scanf("%d", &a);
printf("Podaj druga liczbe: ");
scanf("%d", &b);
while (a != b) {
if (a > b) {
a = a - b;
} else {
b = b - a;
}
}
nwd = a;
printf("Najwiekszy wspolny dzielnik to: %d\n", nwd);
return 0;
}
Zadanie 1/L4 #include <stdio.h>
#include <stdlib.h>
Napisz program, który pobiera od użytkownika listę
liczb całkowitych zgodnie z następującym schematem: int main() {
int n, i;
● pierwsza liczba podana przez użytkownika int *tab;
określa wielkość tablicy, double srednia = 0.0;
● kolejne liczby podane przez użytkownika to
kolejne elementy tablic. printf("Podaj rozmiar tablicy: ");
scanf("%d", &n);
Program powinien dynamicznie (malloc())
zaallokować tablicę i wczytać podane liczby, następnie // alokacja dynamiczna tablicy
policzyć i wyświetlić średnią arytmetyczną (z tab = (int *)malloc(n * sizeof(int));
dokładnością do trzech miejsc po przecinku (formatka
"%.3f"). // pobranie liczb od użytkownika i zapisanie
ich w tablicy
Przykład użycia: for (i = 0; i < n; i++) {
printf("Podaj liczbe: ");
./a.out scanf("%d", &tab[i]);
4 }
6
2 // obliczenie średniej arytmetycznej
-7 for (i = 0; i < n; i++) {
1 srednia += tab[i];
0.500 }
srednia /= n;

// wyświetlenie wyniku
printf("Srednia arytmetyczna wynosi: %.3f\n",
srednia);

// zwolnienie pamięci
free(tab);

return 0;
}

tab[2] = *(tab+2)
Zadanie 3/L3 W kolejnych wierszach pliku Przykładowo:
matury.txt umieszczono:
#include <stdio.h>
1. nazwę województwa,
2. liczbę osób, które przystąpiło do egzaminu int main(int argc, char **argv){
maturalnego, FILE *fp;
3. informację o tym ile procent osób zdało char nazwa[255];
egzamin. char bufor[1024];
int liczba_zdajacych;
Napisz program, który czyta dane z pliku int odsetek_osob_ktore_zdaly;
matury.txt oraz:
fp = fopen("matury.txt", "r");
● wyświetla informację o tym ile osób zdawało if (fp == NULL){
maturę i ile osób zdało maturę w kraju, perror("Nie moge otworzyc
● wyświetla informację o tym ile osób zdało pliku z danymi");
maturę w kolejnych województwach, return -1;
● wyświetla nazwy tych województw, w których }
zdawało ponad 15000 osób,
● wyświetla nazwy tych województw, w których /* petla jest tylko pozornie
zdało mniej niż 70% osób, "nieskoczona" */
● wyświetla nawę województwa, w którym zdało for(;;) {
najwięcej osób (wraz z tą liczbą). /* fgets zwraca NULL po
dotarciu do konca pliku */
Podpowiedź: czytaj plik linia po linii (funkcja if (fgets(bufor, 1024, fp) ==
fgets()). Następnie użyj funkcji sscanf() aby NULL){
uzyskać konkretne informacje z danej linii. break; /* i wtedy
przerywamy petle */
}
sscanf(bufor, "%s %d %d%%\n",
nazwa, &liczba_zdajacych,
&odsetek_osob_ktore_zdaly);
printf("Przeczytalem: %s; %d;
%d\n", nazwa, liczba_zdajacych,
odsetek_osob_ktore_zdaly);
}

return 0;
}

Zadanie 1/L3 - ZawodyWeb #include <stdio.h>

#include <stdlib.h>
Napisz program, który pobiera od użytkownika napis int main() {
złożony z cyfr 1 oraz 0 (tj. liczbę w zapisie binarnym) char binary[32];
a następnie, przy użyciu operacji bitowych, oblicza i printf("Enter a binary number: ");
wyświetla tę liczbę w systemie dziesiętnym. scanf("%s", binary);
int decimal = 0;
Przykład użycia: for (int i = 0; binary[i] != '\0'; i++) {
decimal = decimal << 1;
./a.out if (binary[i] == '1') {
110 decimal = decimal | 1;
6 }
}
printf("%d\n", decimal);
return 0;
}
 struct ulamek dodaj_ulamki(struct ulamek u1, struct
Zadanie 4/L3 Napisz program, w którym ułamki ulamek u2) {
zapisane są w postaci struktur: struct ulamek wynik;
int nwd_mianownikow = nwd(u1.mianownik,
struct ulamek{ u2.mianownik);
int licznik; wynik.mianownik = (u1.mianownik * u2.mianownik)
int mianownik; / nwd_mianownikow;
}; wynik.licznik = (u1.licznik * (wynik.mianownik /
u1.mianownik)) + (u2.licznik * (wynik.mianownik /
zaimplementuj operację dodawania ułamków u2.mianownik));
(pamiętaj o konieczności obliczenia NWD!) i oblicz int nwd_licznika_mianownika = nwd(wynik.licznik,
wartość sumy wynik.mianownik);
wynik.licznik /= nwd_licznika_mianownika;
1/2 + 2/3 + 3/4 +4/5 + 5/6+ 6/7 + 7/8 + 8/9 + 9/10. wynik.mianownik /= nwd_licznika_mianownika;
return wynik;
}

int main() {
======================================= struct ulamek suma = {0, 1}; // zaczynamy od zera,
#include <stdio.h> aby nie trzeba było inicjalizować wartości licznika i
mianownika w każdym ułamku
struct ulamek { struct ulamek u = {1, 2};
int licznik; suma = dodaj_ulamki(suma, u);
int mianownik; u = (struct ulamek) {2, 3}; // można też
}; inicjalizować struktury bezpośrednio w wywołaniu
funkcji
int nwd(int a, int b) { suma = dodaj_ulamki(suma, u);
int c; u.licznik = 3;
while (b != 0) { u.mianownik = 4;
c = a % b; suma = dodaj_ulamki(suma, u);
a = b; u = (struct ulamek) {4, 5};
b = c; suma = dodaj_ulamki(suma, u);
} u = (struct ulamek) {5, 6};
return a; suma = dodaj_ulamki(suma, u);
} u = (struct ulamek) {6, 7};
suma = dodaj_ulamki(suma, u);
u.licznik = 7;
u.mianownik = 8;
suma = dodaj_ulamki(suma, u);
u = (struct ulamek) {8, 9};
suma = dodaj_ulamki(suma, u);
u.licznik = 9;
u.mianownik = 10;
suma = dodaj_ulamki(suma, u);

printf("Suma ułamków: %d/%d\n", suma.licznik,

suma.mianownik);

return 0;
}
Zadanie 2 #include <stdio.h>
#include <stdlib.h>
Napisz program, który analogicznie jak w pierwszym
zadaniu pobiera od użytkownika tablicę liczb int main() {
całkowitych i następnie wyświetla (po spacji) int n, i;
najmniejszą i największą liczbę z tej tablicy int *tab;
int min, max;
Przykład użycia: printf("Podaj rozmiar tablicy: ");
scanf("%d", &n);
./a.out
4 tab = (int *)malloc(n * sizeof(int));
6
2 for (i = 0; i < n; i++) {
-7 printf("Podaj liczbe: ");
1 scanf("%d", &tab[i]);
-7 6 }
min = max = tab[0];
for (i = 1; i < n; i++) {
if (tab[i] < min) {
min = tab[i];
}
if (tab[i] > max) {
max = tab[i];
}
}
printf("Najmniejsza liczba: %d\n", min);
printf("Największa liczba: %d\n", max);
free(tab);
return 0;
}

#include <stdio.h>
Zadanie 1/L6 - ZawodyWeb
double f(int k) {
Zaimplementuj funkcję rekurencyjną zdefiniowaną if (k == 1) {
następująco: return 9.5;
} else if (k == 2) {
● f(1) = 9.5 return 4;
● f(2) = 4 } else {
● f(k) = 2*f(k-1)-f(k-2)/3, jeśli k>2 return 2*f(k-1) - f(k-2)/3;
}
i napisz program, który pobiera od użytkownika liczę }
zmiennoprzecinkową d i wyświetla f(d) (z
dokładnością do 3 miejsc po przecinku). int main() {
double d;
Przykład użycia:
printf("Podaj liczbę: ");
./a.out scanf("%lf", &d);
7
49.648 double result = f((int)d);

printf("f(%g) = %.3f\n", d, result);

return 0;
}
Zadanie 1/L5 #include <stdio.h>
#include <stdlib.h>
Napisz program, który pobiera od użytkownika
macierz kwadratową złożoną liczb całkowitych int main() {
zgodnie z następującym schematem: int n, i, j;
int **matrix;
● pierwsza liczba podana przez użytkownika int trace = 0;
określa wymiar macierzy
● w kolejnych wierszach użytkownik (po spacji) printf("Podaj rozmiar macierzy: ");
podaje kolejne wiersze macierzy. scanf("%d", &n);

Napisz program, który wczytuje macierz do tablicy // alokacja dynamiczna tablicy

dwuwymiarowej i oblicza ślad macierzy (suma dwuwymiarowej
elementów na przekątnej). matrix = (int **)malloc(n * sizeof(int *));
for (i = 0; i < n; i++) {
Przykład użycia: matrix[i] = (int *)malloc(n * sizeof(int));
}
./a.out
4 // pobranie macierzy od użytkownika i
6351 zapisanie jej w tablicy dwuwymiarowej
2 -1 3 4 for (i = 0; i < n; i++) {
-7 -1 3 2 printf("Podaj wiersz %d (kolejne liczby
1231 oddzielone spacją): ", i+1);
9 for (j = 0; j < n; j++) {
scanf("%d", &matrix[i][j]);
}
}

// obliczenie śladu macierzy

for (i = 0; i < n; i++) {
trace += matrix[i][i];
}

// wyświetlenie wyniku
printf("Ślad macierzy wynosi: %d\n", trace);

// zwolnienie pamięci
for (i = 0; i < n; i++) {
free(matrix[i]);
}
free(matrix);

return 0;
}