Inicjalizacja repozytorium
This commit is contained in:
@@ -0,0 +1,6 @@
|
||||
*
|
||||
|
||||
!.gitignore
|
||||
!**/
|
||||
!*.pas
|
||||
.#*.pas
|
||||
@@ -0,0 +1,44 @@
|
||||
program rownanie_kwadratowe;
|
||||
var
|
||||
a,b,c : Double;
|
||||
x,x1,x2 : Double;
|
||||
Delta : Double;
|
||||
begin
|
||||
write('Podaj a: ');
|
||||
ReadLn(a);
|
||||
write('Podaj b: ');
|
||||
ReadLn(b);
|
||||
write('Podaj c: ');
|
||||
ReadLn(c);
|
||||
|
||||
|
||||
|
||||
if a=0 then
|
||||
begin
|
||||
x:=c/b;
|
||||
writeln('To jest rownanie liniowe');
|
||||
writeln(x:0:5); // Wypisze pięć miejsc po przecinku zamiast naukowej notacji
|
||||
end else
|
||||
begin
|
||||
Delta:=b*b-4*a*c;
|
||||
if Delta < 0 then
|
||||
writeln('Brak rozwiazan')
|
||||
else
|
||||
begin
|
||||
if Delta > 0 then
|
||||
begin
|
||||
x1:=(-b - Sqrt(Delta))/(2*a);
|
||||
x2:=(-b + Sqrt(Delta))/(2*a);
|
||||
writeln('Dwa pierwiastki');
|
||||
writeln(x1:0:5);
|
||||
writeln(x2:0:5);
|
||||
end else
|
||||
begin
|
||||
x:=b/(2*a);
|
||||
writeln('Jeden pierwiastek');
|
||||
writeln(x:0:5);
|
||||
end;
|
||||
end;
|
||||
|
||||
end;
|
||||
end.
|
||||
@@ -0,0 +1,37 @@
|
||||
program rok_przestepny;
|
||||
|
||||
function Czytaj_rok: Integer;
|
||||
var
|
||||
rok: Integer;
|
||||
begin
|
||||
write('Podaj rok: ');
|
||||
readln(rok);
|
||||
Czytaj_rok:=rok;
|
||||
end;
|
||||
|
||||
function Czy_przestepny(rok :Integer ): Boolean;
|
||||
begin
|
||||
Czy_przestepny:= ((rok mod 4 = 0) AND (NOT (rok mod 100 = 0)) ) OR (rok mod 400 = 0);
|
||||
end;
|
||||
|
||||
procedure Wypisz_czy_przestepny(rok : Integer; przestepny: Boolean );
|
||||
begin
|
||||
if przestepny then
|
||||
writeln('Rok ', rok, ' jest przestepny')
|
||||
else
|
||||
writeln('Rok ', rok, ' nie jest przestepny');
|
||||
end;
|
||||
|
||||
procedure Glowna_procedura;
|
||||
var
|
||||
rok : Integer;
|
||||
przestepny : Boolean;
|
||||
begin
|
||||
rok:= Czytaj_rok();
|
||||
przestepny:= Czy_przestepny(rok);
|
||||
Wypisz_czy_przestepny(rok,przestepny);
|
||||
end;
|
||||
|
||||
begin
|
||||
Glowna_procedura()
|
||||
end.
|
||||
@@ -0,0 +1,38 @@
|
||||
program suma_cyfr;
|
||||
function Czytaj_liczbe : Integer;
|
||||
var
|
||||
liczba : Integer;
|
||||
begin
|
||||
write('Podaj liczbe: ');
|
||||
readln(liczba);
|
||||
Czytaj_liczbe:=liczba;
|
||||
end;
|
||||
|
||||
function Suma_cyfr(liczba : Integer) : Integer;
|
||||
var suma : Integer;
|
||||
begin
|
||||
suma:=0;
|
||||
liczba:=abs(liczba);
|
||||
while liczba>0 do
|
||||
begin
|
||||
suma:=suma+(liczba mod 10);
|
||||
liczba:=trunc(liczba/10);
|
||||
end;
|
||||
Suma_cyfr:=suma;
|
||||
end;
|
||||
|
||||
procedure Wypisz_wynik(liczba : Integer; suma : Integer );
|
||||
begin
|
||||
writeln('Suma cyfr liczby ', liczba, ' to ', suma);
|
||||
end;
|
||||
|
||||
procedure Glowna_procedura;
|
||||
var liczba : Integer;
|
||||
begin
|
||||
liczba:=Czytaj_liczbe();
|
||||
Wypisz_wynik(liczba,Suma_cyfr(liczba));
|
||||
end;
|
||||
|
||||
begin
|
||||
Glowna_procedura();
|
||||
end.
|
||||
@@ -0,0 +1,53 @@
|
||||
program silnia;
|
||||
function Czytaj_liczbe: Int64;
|
||||
var
|
||||
liczba: Int64;
|
||||
begin
|
||||
Write('Podaj liczbę calkowita: ');
|
||||
ReadLn(liczba);
|
||||
Czytaj_liczbe := liczba;
|
||||
end;
|
||||
|
||||
function Silnia_rekurencyjna(n: Int64): Int64;
|
||||
begin
|
||||
if n = 0 then
|
||||
Silnia_rekurencyjna := 1
|
||||
else
|
||||
Silnia_rekurencyjna := n * Silnia_rekurencyjna(n - 1);
|
||||
end;
|
||||
|
||||
function Silnia_iteracyjna(n: Int64): Int64;
|
||||
var
|
||||
wynik, i: Int64;
|
||||
begin
|
||||
wynik := 1;
|
||||
for i := 1 to n do
|
||||
wynik := wynik * i;
|
||||
Silnia_iteracyjna := wynik;
|
||||
end;
|
||||
|
||||
procedure Wypisz_wyniki(wynikRek, wynikIter: Int64);
|
||||
begin
|
||||
WriteLn('Silnia rekurencyjna: ', wynikRek:10);
|
||||
WriteLn('Silnia iteracyjna: ', wynikIter:10);
|
||||
end;
|
||||
|
||||
procedure Glowna_procedura;
|
||||
var
|
||||
liczba, wynikRek, wynikIter: Int64;
|
||||
begin
|
||||
liczba := Czytaj_liczbe;
|
||||
if liczba < 0 then
|
||||
begin
|
||||
WriteLn('Silnia jest zdefiniowana tylko dla liczb nieujemnych.');
|
||||
Exit;
|
||||
end;
|
||||
|
||||
wynikRek := Silnia_rekurencyjna(liczba);
|
||||
wynikIter := Silnia_iteracyjna(liczba);
|
||||
Wypisz_wyniki(wynikRek, wynikIter);
|
||||
end;
|
||||
|
||||
begin
|
||||
Glowna_procedura()
|
||||
end.
|
||||
@@ -0,0 +1,71 @@
|
||||
program silnia_czas;
|
||||
uses sysUtils;
|
||||
function Czytaj_liczbe: Int64;
|
||||
var
|
||||
liczba : Int64;
|
||||
begin
|
||||
Write('Podaj liczbe calkowita: ');
|
||||
ReadLn(liczba);
|
||||
Czytaj_liczbe := liczba;
|
||||
end;
|
||||
|
||||
function Silnia_rekurencyjna(n: Int64): Int64;
|
||||
begin
|
||||
if n = 0 then
|
||||
Silnia_rekurencyjna := 1
|
||||
else
|
||||
Silnia_rekurencyjna := n * Silnia_rekurencyjna(n - 1);
|
||||
end;
|
||||
|
||||
function Silnia_iteracyjna(n: Int64): Int64;
|
||||
var
|
||||
wynik, i : Int64;
|
||||
begin
|
||||
wynik := 1;
|
||||
for i := 1 to n do
|
||||
wynik := wynik * i;
|
||||
Silnia_iteracyjna := wynik;
|
||||
end;
|
||||
|
||||
procedure Wypisz_wyniki(liczba,ile,wynikRek, wynikIter : Int64; CzasI, CzasR : TdateTime);
|
||||
begin
|
||||
writeln('Podana liczba: ', liczba);
|
||||
writeln('Podana liczba iteracji', ile);
|
||||
writeln('Czas silni rekurencyjnej: ', CzasR:0:2, ' sekund');
|
||||
WriteLn('Silnia rekurencyjna: ', wynikRek:10);
|
||||
writeln('Czas silni iteracyjnej: ', CzasI:0:2, ' sekund');
|
||||
WriteLn('Silnia iteracyjna: ', wynikIter:10);
|
||||
end;
|
||||
|
||||
|
||||
procedure Glowna_procedura;
|
||||
var
|
||||
CzasI, CzasR : TdateTime;
|
||||
i : Int64;
|
||||
ile, liczba : Int64;
|
||||
wynikI, wynikR : Int64;
|
||||
begin
|
||||
liczba := Czytaj_liczbe();
|
||||
Write('Podaj liczbe iteracji: ');
|
||||
ReadLn(ile);
|
||||
CzasI := Time();
|
||||
for i := 0 to ile do
|
||||
wynikI := Silnia_iteracyjna(liczba);
|
||||
CzasI := Time()-CzasI;
|
||||
CzasI := CzasI*24*60*60;
|
||||
|
||||
|
||||
CzasR := Time();
|
||||
for i := 0 to ile do
|
||||
wynikR := Silnia_rekurencyjna(liczba);
|
||||
CzasR := Time()-CzasR;
|
||||
CzasR := CzasR*24*60*60;
|
||||
|
||||
|
||||
Wypisz_wyniki(liczba,ile,wynikR,wynikI,CzasI,CzasR);
|
||||
|
||||
end;
|
||||
|
||||
begin
|
||||
Glowna_procedura()
|
||||
end.
|
||||
@@ -0,0 +1,33 @@
|
||||
program suma_cyfr;
|
||||
function Czytaj_liczbe : Integer;
|
||||
var
|
||||
liczba : Integer;
|
||||
begin
|
||||
write('Podaj liczbe: ');
|
||||
readln(liczba);
|
||||
Czytaj_liczbe:=liczba;
|
||||
end;
|
||||
|
||||
function Suma_cyfr(liczba : Integer) : Integer;
|
||||
begin
|
||||
if liczba = 0 then
|
||||
Suma_cyfr:=0
|
||||
else
|
||||
Suma_cyfr:= (abs(liczba) mod 10) + Suma_cyfr(liczba div 10);
|
||||
end;
|
||||
|
||||
procedure Wypisz_wynik(liczba : Integer; suma : Integer );
|
||||
begin
|
||||
writeln('Suma cyfr liczby ', liczba, ' to ', suma);
|
||||
end;
|
||||
|
||||
procedure Glowna_procedura;
|
||||
var liczba : Integer;
|
||||
begin
|
||||
liczba:=Czytaj_liczbe();
|
||||
Wypisz_wynik(liczba,Suma_cyfr(liczba));
|
||||
end;
|
||||
|
||||
begin
|
||||
Glowna_procedura();
|
||||
end.
|
||||
@@ -0,0 +1,65 @@
|
||||
program potega;
|
||||
function potega_iter(a : Integer ;n : Integer ) : Integer;
|
||||
var
|
||||
wynik, i : Integer;
|
||||
begin
|
||||
wynik := 1;
|
||||
for i := 1 to n do
|
||||
wynik:= wynik*a;
|
||||
potega_iter:= wynik;
|
||||
end;
|
||||
|
||||
function potega_rek(a : Integer ;n : Integer ) :Integer;
|
||||
begin
|
||||
if n = 0 then
|
||||
potega_rek:= 1
|
||||
else
|
||||
potega_rek:= a * potega_rek(a,n-1);
|
||||
end;
|
||||
|
||||
|
||||
function potega_iter_kwr(a : Integer ;n : Integer ) : Integer;
|
||||
var
|
||||
wynik : Integer;
|
||||
begin
|
||||
wynik := 1;
|
||||
if n = 1 then
|
||||
wynik:=a;
|
||||
while n>1 do
|
||||
begin
|
||||
if n mod 2 = 1 then
|
||||
begin
|
||||
wynik:=a*wynik;
|
||||
n:=n-1;
|
||||
end
|
||||
else
|
||||
begin
|
||||
wynik:=a*a*wynik;
|
||||
n:=n div 2;
|
||||
end;
|
||||
end;
|
||||
potega_iter_kwr:=wynik;
|
||||
end;
|
||||
|
||||
function potega_rek_kwr(a : Integer ;n : Integer ) :Integer;
|
||||
var
|
||||
wynik : Integer;
|
||||
begin
|
||||
wynik:=0;
|
||||
if n = 0 then
|
||||
potega_rek_kwr:= 1
|
||||
else if n mod 2 = 1 then
|
||||
potega_rek_kwr:= a * potega_rek_kwr(a,n-1)
|
||||
else
|
||||
begin
|
||||
wynik := potega_rek_kwr(a, n div 2);
|
||||
potega_rek_kwr:=wynik*wynik;
|
||||
end;
|
||||
end;
|
||||
|
||||
begin
|
||||
WriteLn('Potega Iteracyjna: ', potega_iter(2,3));
|
||||
WriteLn('Potega Rekurencyjna: ', potega_rek(2,3));
|
||||
WriteLn('Potega Iteracyjna Kwadratowa: ', potega_iter_kwr(2,3));
|
||||
WriteLn('Potega Rekurencyjna Kwadratowa: ', potega_rek_kwr(2,3));
|
||||
end.
|
||||
@@ -0,0 +1,20 @@
|
||||
import math;
|
||||
|
||||
a = float(input("Podaj a: "))
|
||||
b = float(input("Podaj b: "))
|
||||
c = float(input("Podaj c: "))
|
||||
|
||||
if(a==0):
|
||||
x=c/b
|
||||
print("To jest rownanie liniowe\n", x)
|
||||
else:
|
||||
Delta=b*b-4*a*c
|
||||
if (Delta < 0):
|
||||
print("Brak rozwiazan")
|
||||
elif (Delta > 0):
|
||||
x1=(-b - math.sqrt(Delta))/(2*a)
|
||||
x2=(-b + math.sqrt(Delta))/(2*a)
|
||||
print('Dwa pierwiastki\n', x1,'\n', x2)
|
||||
else:
|
||||
x=b/(2*a)
|
||||
print('Jeden pierwiastek\n',x);
|
||||
@@ -0,0 +1,15 @@
|
||||
def Czytaj_rok():
|
||||
rok = int(input("Podaj rok: "))
|
||||
return rok;
|
||||
def Czy_przestepny(rok):
|
||||
return ((rok%4==0) and not (rok%100==0)) or (rok % 400 == 0)
|
||||
def Wypisz_czy_przestepny(rok,przestepny):
|
||||
if(przestepny):
|
||||
print("Rok", rok, "jest przestepny")
|
||||
else:
|
||||
print("Rok", rok, "nie jest przestepny")
|
||||
def Glowna_procedura():
|
||||
rok = Czytaj_rok()
|
||||
Wypisz_czy_przestepny(rok,Czy_przestepny(rok))
|
||||
|
||||
Glowna_procedura()
|
||||
@@ -0,0 +1,16 @@
|
||||
from math import trunc
|
||||
def Czytaj_liczbe():
|
||||
return int(input("Podaj liczbe: "))
|
||||
def Suma_cyfr(liczba):
|
||||
suma=0
|
||||
liczba=abs(liczba)
|
||||
while(liczba>0):
|
||||
suma=suma+(liczba%10)
|
||||
liczba=int(trunc(liczba/10))
|
||||
return suma
|
||||
def Wypisz_wynik(liczba,suma):
|
||||
print("Suma cyfr liczby",liczba,"to",suma)
|
||||
def Glowna_procedura():
|
||||
liczba=Czytaj_liczbe()
|
||||
Wypisz_wynik(liczba,Suma_cyfr(liczba))
|
||||
Glowna_procedura()
|
||||
@@ -0,0 +1,40 @@
|
||||
from datetime import datetime
|
||||
def Czytaj_liczbe():
|
||||
return int(input("Podaj liczbe calkowita: "))
|
||||
def Silnia_rekurencyjna(n):
|
||||
if(n==0):
|
||||
return 1
|
||||
else:
|
||||
return n * Silnia_rekurencyjna(n-1);
|
||||
def Silnia_iteracyjna(n):
|
||||
wynik = 1
|
||||
for i in range(1,n+1):
|
||||
wynik = wynik*i
|
||||
return wynik
|
||||
def Wypisz_wynikli(liczba,ile,wynikRek,wynikIter,CzasI,CzasR):
|
||||
print("Podana liczba:", liczba);
|
||||
print("Podana liczba iteracji", ile);
|
||||
print("Czas silni rekurencyjnej:", CzasR, 'sekund');
|
||||
print("Silnia rekurencyjna:", wynikRek);
|
||||
print("Czas silni iteracyjnej:", CzasI, 'sekund');
|
||||
print("Silnia iteracyjna:", wynikIter);
|
||||
def Glowna_procedura():
|
||||
wynikR = 0
|
||||
wynikI = 0
|
||||
liczba = Czytaj_liczbe()
|
||||
ile = int(input("Podaj liczbe iteracji: "))
|
||||
CzasI = datetime.today()
|
||||
for i in range(0,ile+1):
|
||||
wynikI = Silnia_iteracyjna(liczba)
|
||||
CzasI = datetime.today() - CzasI
|
||||
CzasI = CzasI.seconds+CzasI.microseconds*0.000001
|
||||
|
||||
CzasR = datetime.today()
|
||||
for i in range(0,ile+1):
|
||||
wynikR = Silnia_rekurencyjna(liczba)
|
||||
CzasR = datetime.today() - CzasR
|
||||
CzasR = CzasR.seconds+CzasR.microseconds*0.000001
|
||||
|
||||
Wypisz_wynikli(liczba,ile,wynikR,wynikI,CzasI,CzasR)
|
||||
|
||||
Glowna_procedura()
|
||||
@@ -0,0 +1,75 @@
|
||||
---
|
||||
author: Mateusz Słodkowicz
|
||||
lang: pl
|
||||
title: Algorytmy i Struktury Danych
|
||||
---
|
||||
|
||||
Zadania/Ćwiczenia z przedmiotu Algorytmy i Struktury Danych.
|
||||
|
||||
# Ćwiczenie 2 - Zadanie 1
|
||||
|
||||
Program na rozwiązywanie równania kwadratowego.
|
||||
|
||||
**Wymagania na program**:
|
||||
|
||||
1. Aplikacja konsolowa (prosty program)
|
||||
2. Na wejściu programu należy podać wartości a,b,c
|
||||
3. Na wyjściu program wypisuje komunikaty, opisane algorytmem
|
||||
|
||||
[Pascal](./Pascal/AiSD5_C2%20Ćwiczenie%202/zad1_rownanie_kwadratowe.pas)
|
||||
[Python](./Python/AiSD5_C2%20Ćwiczenie%202/zad1_rownanie_kwadratowe.py)
|
||||
|
||||
# Ćwiczenie 2 - Zadanie 2
|
||||
|
||||
**Definicja**
|
||||
Rok przestępny to taki, który spełnia następujące warunki:
|
||||
|
||||
- jest podzielny przez 4 i niepodzielny przez 100
|
||||
|
||||
lub
|
||||
|
||||
- jest podzielny przez 400
|
||||
|
||||
**Wymagania na program**:
|
||||
|
||||
1. Aplikacja konsolowa (prosty program)
|
||||
2. Na wejściu programu należy podać liczbę określającą numer roku
|
||||
3. Na wyjściu program wypisuje komunikat, czy podany rok jest
|
||||
przestępny.
|
||||
4. Podziel program na cztery części:
|
||||
1. Funkcja typu całkowitego czytająca numer roku podany przez
|
||||
użytkownika i zwracająca odczytaną liczbę
|
||||
2. Funkcja typu logicznego, której argumentem jest liczba całkowita
|
||||
sprawdzająca, czy rok jest przestępny
|
||||
3. Procedura, której argumentami są: numer roku i wartość logiczna,
|
||||
wypisująca na konsoli, czy rok jest przestępny
|
||||
4. Procedura zawierająca w sobie wywołania pozostałych funkcji i
|
||||
procedur, która jest wywoływana z programu głównego.
|
||||
|
||||
[Pascal](./Pascal/AiSD5_C2%20Ćwiczenie%202/zad2_rok_przestepny.pas)
|
||||
[Python](./Python/AiSD5_C2%20Ćwiczenie%202/zad2_rok_przestepny.py)
|
||||
|
||||
# Ćwiczenie 2 - Zadanie 3
|
||||
|
||||
Obliczanie sumy cyfr
|
||||
|
||||
**Wymagania na algorytm**:
|
||||
|
||||
1. Algorytm iteracyjny (nie rekurencyjny)
|
||||
|
||||
**Wymagania na program**:
|
||||
|
||||
1. Aplikacja konsolowa (prosty program)
|
||||
2. Na wejściu programu należy podać liczbę całkowitą.
|
||||
3. Na wyjściu program wypisuje wynik obliczeń.
|
||||
4. Podziel program na cztery części:
|
||||
1. Funkcja typu całkowitego czytająca liczbę całkowitą
|
||||
2. Funkcja typu całkowitego, której argumentem jest liczba
|
||||
całkowita, a wynikiem suma cyfr tej liczby
|
||||
3. Procedura wypisująca wynik obliczeń, której argumentami są:
|
||||
liczba całkowita i suma cyfr tej liczby
|
||||
4. Procedura zawierająca w sobie wywołania pozostałych funkcji i
|
||||
procedur, która jest wywoływana z programu głównego.
|
||||
|
||||
[Pascal](./Pascal/AiSD5_C2%20Ćwiczenie%202/zad3_suma_cyfr.pas)
|
||||
[Python](./Python/AiSD5_C2%20Ćwiczenie%202/zad3_suma_cyfr.py)
|
||||
Reference in New Issue
Block a user