├── dzialy ├── zadania_arkusze │ ├── 2005_maj.md │ ├── 2006_maj.md │ ├── 2007_maj.md │ ├── 2008_maj.md │ ├── 2014_grudzien_pr.md │ ├── 2016_maj_stare.md │ ├── 2020_maj │ │ ├── 5.accdb │ │ ├── 2020_maj_zad.6.xlsx │ │ ├── 4.3.py │ │ ├── 4.2.py │ │ ├── 4.1.py │ │ ├── 1.2_1.3.py │ │ └── 2020_maj.md │ ├── 2019_czerwiec │ │ ├── 6.accdb │ │ ├── 4.1.py │ │ ├── 4.2.py │ │ ├── 4.3.py │ │ └── 2019_czerwiec.md │ ├── 2019_maj │ │ ├── zadanko.xlsx │ │ ├── perfumydlawas.accdb │ │ ├── 4.2.py │ │ ├── 4.1.py │ │ ├── 4.3.py │ │ └── 2019_maj.md │ ├── 2018_maj │ │ ├── zbiornik.xlsx │ │ ├── centrum_danych.accdb │ │ ├── 4.1.py │ │ ├── 4.3.py │ │ ├── 4.2.py │ │ └── 2018_maj.md │ ├── 2010_maj_podstawa │ │ └── 2010_maj_podstawa.md │ ├── 2015_maj_stare.md │ ├── 2011_maj.md │ ├── 2012_maj.md │ ├── 2009_maj_podstawa │ │ └── 2009_maj_podstawa.md │ ├── 2010_maj.md │ ├── 2012_maj_podstawa │ │ └── 2012_maj_podstawa.md │ ├── 2015_maj_podstawa │ │ └── 2015_maj_podstawa.md │ ├── 2011_maj_podstawa │ │ └── 2011_maj_podstawa.md │ ├── 2013_maj_podstawa │ │ └── 2013_maj_podstawa.md │ ├── 2021_kwiecen │ │ └── 2021_kwiecien.md │ ├── 2014_maj_podstawa │ │ └── 2014_maj_podstawa.md │ ├── 2009_maj.md │ ├── 2013_maj.md │ ├── 2017_maj_podstawa │ │ └── 2017_maj_podstawa.md │ ├── 2015_maj.md │ ├── 2014_maj.md │ ├── 2018_czerwiec.md │ ├── 2017_maj_stare.md │ ├── 2016_maj_podstawa │ │ └── 2016_maj_podstawa.md │ ├── 2020_kwiecien_pr.md │ ├── 2016_czerwiec.md │ ├── 2015_czerwiec.md │ ├── 2017_czerwiec.md │ ├── 2016_maj.md │ ├── 2017_maj.md │ └── 2021_marzec_pr.md ├── images │ ├── mediana.png │ ├── srednia.png │ ├── wariancja.png │ └── srednia_wazona.png ├── zadania_zbior │ ├── 63.md │ ├── 64.md │ ├── 60.md │ ├── 59.md │ ├── 62.md │ ├── 61.md │ └── 58.md ├── funkcje_wbudowane.md ├── metody.md ├── dodatkowe_algorytmy.md ├── biblioteki.md ├── zadania_arkusze.md └── algorytmy_wymagania.md └── docs ├── images ├── bg_menu.png ├── bg_footer.png ├── discord_icon.svg └── github_icon.svg ├── css ├── main_style.css └── style.css ├── index.html └── README.md /dzialy/zadania_arkusze/2005_maj.md: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2006_maj.md: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2007_maj.md: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2008_maj.md: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2014_grudzien_pr.md: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2016_maj_stare.md: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /docs/images/bg_menu.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wernexnrs/MATURA-INFORMATYKA/HEAD/docs/images/bg_menu.png -------------------------------------------------------------------------------- /docs/images/bg_footer.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wernexnrs/MATURA-INFORMATYKA/HEAD/docs/images/bg_footer.png -------------------------------------------------------------------------------- /dzialy/images/mediana.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wernexnrs/MATURA-INFORMATYKA/HEAD/dzialy/images/mediana.png -------------------------------------------------------------------------------- /dzialy/images/srednia.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wernexnrs/MATURA-INFORMATYKA/HEAD/dzialy/images/srednia.png -------------------------------------------------------------------------------- /dzialy/images/wariancja.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wernexnrs/MATURA-INFORMATYKA/HEAD/dzialy/images/wariancja.png -------------------------------------------------------------------------------- /dzialy/images/srednia_wazona.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wernexnrs/MATURA-INFORMATYKA/HEAD/dzialy/images/srednia_wazona.png -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2020_maj/5.accdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wernexnrs/MATURA-INFORMATYKA/HEAD/dzialy/zadania_arkusze/2020_maj/5.accdb -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2019_czerwiec/6.accdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wernexnrs/MATURA-INFORMATYKA/HEAD/dzialy/zadania_arkusze/2019_czerwiec/6.accdb -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2019_maj/zadanko.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wernexnrs/MATURA-INFORMATYKA/HEAD/dzialy/zadania_arkusze/2019_maj/zadanko.xlsx -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2018_maj/zbiornik.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wernexnrs/MATURA-INFORMATYKA/HEAD/dzialy/zadania_arkusze/2018_maj/zbiornik.xlsx -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2018_maj/centrum_danych.accdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wernexnrs/MATURA-INFORMATYKA/HEAD/dzialy/zadania_arkusze/2018_maj/centrum_danych.accdb -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2019_maj/perfumydlawas.accdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wernexnrs/MATURA-INFORMATYKA/HEAD/dzialy/zadania_arkusze/2019_maj/perfumydlawas.accdb -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2020_maj/2020_maj_zad.6.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wernexnrs/MATURA-INFORMATYKA/HEAD/dzialy/zadania_arkusze/2020_maj/2020_maj_zad.6.xlsx -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2018_maj/4.1.py: -------------------------------------------------------------------------------- 1 | res = "" 2 | 3 | with open("Dane_PR/przyklad.txt") as file: 4 | lista = file.read().splitlines() 5 | 6 | for i in range(39, len(lista) + 1, 40): 7 | res += lista[i][9] 8 | 9 | print(res) -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2010_maj_podstawa/2010_maj_podstawa.md: -------------------------------------------------------------------------------- 1 | ## 4 2 | 3 | ```py 4 | with open("Dane/dane.txt") as file: 5 | for line in file: 6 | line = line.strip() 7 | if line == line[::-1]: 8 | print(line) 9 | ``` 10 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2018_maj/4.3.py: -------------------------------------------------------------------------------- 1 | with open("Dane_PR/sygnaly.txt") as file: 2 | lista = file.read().splitlines() 3 | 4 | for word in lista: 5 | if all(abs(ord(x) - ord(word[char-1])) < 10 for char in range(1, len(word)) for x in word): 6 | print(word) -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2018_maj/4.2.py: -------------------------------------------------------------------------------- 1 | with open("Dane_PR/przyklad.txt") as file: 2 | lista = file.read().splitlines() 3 | 4 | maxi = 0 5 | 6 | for i in range(len(lista)): 7 | if len(set(lista[i])) > maxi: 8 | maxi = len(set(lista[i])) 9 | index = i 10 | print(lista[index], maxi) 11 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2020_maj/4.3.py: -------------------------------------------------------------------------------- 1 | lista = [] 2 | 3 | with open("Dane_PR2\pary.txt") as file: 4 | for line in file: 5 | line, slowo = line.strip().split() 6 | line = int(line) 7 | 8 | if line == len(slowo): 9 | lista.append((line, slowo)) 10 | 11 | print(sorted(lista)[0]) 12 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2019_maj/4.2.py: -------------------------------------------------------------------------------- 1 | import math 2 | 3 | with open("Dane_PR/liczby.txt") as file: 4 | for line in file: 5 | line = line.strip() 6 | suma = 0 7 | for num in line: 8 | num = int(num) 9 | suma += math.factorial(num) 10 | if int(line) == suma: 11 | print(line) -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2015_maj_stare.md: -------------------------------------------------------------------------------- 1 | # 4.1 2 | ```py 3 | count = 0 4 | 5 | with open("Dane/slowa.txt") as file: 6 | for line in file: 7 | line = line.strip() 8 | if line.count('0') > line.count("1"): 9 | count += 1 10 | 11 | print(count) 12 | 13 | ``` 14 | 15 | # 4.2 16 | ```py 17 | ``` 18 | 19 | # 4.3 20 | ```py 21 | ``` 22 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2019_maj/4.1.py: -------------------------------------------------------------------------------- 1 | lista = [] 2 | liczba = 0 3 | i = 0 4 | 5 | while liczba <= 100000: 6 | liczba = 3 ** i 7 | lista.append(liczba) 8 | i += 1 9 | 10 | count = 0 11 | 12 | with open("Dane_PR/liczby.txt") as file: 13 | for line in file: 14 | line = int(line.strip()) 15 | if line in lista: 16 | count += 1 17 | print(count) -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2019_czerwiec/4.1.py: -------------------------------------------------------------------------------- 1 | def is_prime(x): 2 | if x > 1: 3 | for i in range(2, x): 4 | if x % i == 0: 5 | return False 6 | return True 7 | return False 8 | 9 | 10 | with open("MIN-R2A1P-193_dane/liczby.txt") as file: 11 | for line in file: 12 | line = int(line) 13 | if is_prime(line) and line in range(100, 5001): 14 | print(line) -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2019_czerwiec/4.2.py: -------------------------------------------------------------------------------- 1 | def is_prime(x): 2 | if x > 1: 3 | for i in range(2, x): 4 | if x % i == 0: 5 | return False 6 | return True 7 | return False 8 | 9 | 10 | with open("MIN-R2A1P-193_dane/pierwsze.txt") as file: 11 | for line in file: 12 | line = line.strip() 13 | liczba = int(line[::-1]) 14 | if is_prime(liczba): 15 | print(line) -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2019_czerwiec/4.3.py: -------------------------------------------------------------------------------- 1 | def waga(n=''): 2 | wynik = 0 3 | while len(str(n)) > 1: 4 | for char in n: 5 | char = int(char) 6 | wynik += char 7 | n = str(wynik) 8 | wynik = 0 9 | return n 10 | 11 | 12 | count = 0 13 | 14 | with open("MIN-R2A1P-193_dane/pierwsze_przyklad.txt") as file: 15 | for line in file: 16 | line = line.strip() 17 | if waga(line) == '1': 18 | count += 1 19 | print(count) -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2020_maj/4.2.py: -------------------------------------------------------------------------------- 1 | with open("Dane_PR2\pary.txt") as file: 2 | for line in file: 3 | line, slowo = line.strip().split() 4 | res = slowo[0] 5 | longest = slowo[0] 6 | for i in range(1, len(slowo)): 7 | if slowo[i - 1] == slowo[i]: 8 | res += slowo[i - 1] 9 | else: 10 | res = slowo[i] 11 | if len(res) > len(longest): 12 | longest = res 13 | print(longest, len(longest)) -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2011_maj.md: -------------------------------------------------------------------------------- 1 | # 6 2 | ```py 3 | parzyste = 0 4 | maxi = -2 5 | nine = 0 6 | suma = 0 7 | 8 | with open("dane/liczby.txt") as file: 9 | for line in file: 10 | line = int(line.strip(), 2) 11 | if line % 2 == 0: 12 | parzyste += 1 13 | if line > maxi: 14 | maxi = line 15 | if len(str(bin(line)[2:])) == 9: 16 | nine += 1 17 | suma += line 18 | 19 | print(parzyste, maxi, bin(maxi)[2:], nine, bin(suma)[2:]) 20 | 21 | ``` 22 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2012_maj.md: -------------------------------------------------------------------------------- 1 | # 5a 2 | ```py 3 | from math import factorial 4 | 5 | 6 | def triangle(n): 7 | lista = [] 8 | for i in range(n): 9 | for j in range(i + 1): 10 | lista.append(factorial(i) // (factorial(j) * factorial(i - j))) 11 | return lista 12 | 13 | 14 | print(max(triangle(10))) 15 | print(max(triangle(20))) 16 | print(max(triangle(30))) 17 | 18 | ``` 19 | 20 | # 5b 21 | ```py 22 | 23 | ``` 24 | 25 | # 5c 26 | ```py 27 | 28 | ``` 29 | 30 | # 5d 31 | ```py 32 | 33 | ``` 34 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2009_maj_podstawa/2009_maj_podstawa.md: -------------------------------------------------------------------------------- 1 | ## 5 2 | ```py 3 | import math 4 | 5 | 6 | def is_prime(x): 7 | if x > 1: 8 | for i in range(2, x): 9 | if x % i == 0: 10 | return False 11 | return True 12 | return False 13 | 14 | 15 | with open("Dane/liczby.txt") as file: 16 | for line in file: 17 | line = int(line.strip()) 18 | square = math.sqrt(line) 19 | if int(square + 0.5) ** 2 == line and is_prime(int(square)): 20 | print(line) 21 | ``` 22 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2010_maj.md: -------------------------------------------------------------------------------- 1 | # 4 2 | ```py 3 | def is_anagram(a, x): 4 | x = "".join(sorted(list(x))) 5 | a = "".join(sorted(list(a))) 6 | if a == x: 7 | return True 8 | return False 9 | 10 | 11 | with open("dane/anagram.txt") as file: 12 | for line in file: 13 | line = line.strip().split() 14 | 15 | if all(len(i) == len(line[0]) for i in line): 16 | print(line) 17 | 18 | first = line[0] 19 | if all(is_anagram(first, i) for i in line[1:]): 20 | print(line) 21 | 22 | ``` 23 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2020_maj/4.1.py: -------------------------------------------------------------------------------- 1 | def is_prime(x): 2 | if x > 1: 3 | for i in range(2, x): 4 | if x % i == 0: 5 | return False 6 | return True 7 | return False 8 | 9 | 10 | with open('Dane_PR2\pary.txt') as file: 11 | for line in file: 12 | num, word = line.strip().split() 13 | num = int(num) 14 | if num > 4 and num % 2 == 0: 15 | for j in range(3, num + 1): 16 | if is_prime(j) and is_prime(num - j): 17 | print(num, j, num - j) 18 | break -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2020_maj/1.2_1.3.py: -------------------------------------------------------------------------------- 1 | n = 3 2 | k = 0 3 | 4 | A = [5, 7, 9] 5 | B = [5, 7, 9] 6 | 7 | 8 | def czy_k_podobne(n, A, B, k): 9 | for i in range(k): 10 | 11 | if A[i] != B[n - k + i]: 12 | return False 13 | 14 | for i in range(n - k): 15 | if B[i] != A[k + i]: 16 | return False 17 | return True 18 | 19 | 20 | def czy_podobne(n, A, B): 21 | for k in range(n): 22 | if czy_k_podobne(n, A, B, k): 23 | return True 24 | return False 25 | 26 | 27 | print(czy_k_podobne(n, A, B, k)) 28 | -------------------------------------------------------------------------------- /docs/css/main_style.css: -------------------------------------------------------------------------------- 1 | a{ 2 | text-decoration: none; 3 | color: lightblue; 4 | } 5 | 6 | .markdown-body{ 7 | color: white; 8 | background-color: rgba(0,0,0,0.25); 9 | border-radius: 40px; 10 | font-size: 20px; 11 | width: 1200px; 12 | height: 100%; 13 | margin: 50px auto 50px auto; 14 | padding: 30px 0 30px 0; 15 | padding: 10px 50px 10px 50px; 16 | box-shadow: rgba(0, 0, 0, 0.4) 0px 2px 4px, rgba(0, 0, 0, 0.3) 0px 7px 13px -3px, rgba(0, 0, 0, 0.2) 0px -3px 0px inset; 17 | } 18 | 19 | .markdown-body > p{ 20 | text-align: center; 21 | } 22 | 23 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2012_maj_podstawa/2012_maj_podstawa.md: -------------------------------------------------------------------------------- 1 | ## 4 2 | ```py 3 | parzyste = 0 4 | lista = [] 5 | with open("dane/cyfry.txt") as file: 6 | for line in file: 7 | line = line.strip() 8 | 9 | if int(line) % 2 == 0: # a 10 | parzyste += 1 11 | 12 | lista.append((line, sum(int(i) for i in line))) 13 | 14 | if all(int(line[i - 1]) < int(line[i]) for i in range(1, len(line))): 15 | print(line) 16 | 17 | print("min:", sorted(lista, key=lambda x: x[1])[0][0]) 18 | print("max:", sorted(lista, key=lambda x: x[1], reverse=True)[0][0]) 19 | 20 | print(parzyste) 21 | 22 | ``` 23 | -------------------------------------------------------------------------------- /dzialy/zadania_zbior/63.md: -------------------------------------------------------------------------------- 1 | # 63.1 2 | ```py 3 | with open("dane/63/ciagi.txt") as file: 4 | for line in file: 5 | line = line.strip() 6 | 7 | if len(line) % 2 == 0: 8 | dlugosc = int(len(line)/2) 9 | 10 | lewa = line[:dlugosc] 11 | prawa = line[dlugosc:] 12 | 13 | if lewa == prawa: 14 | print(line) 15 | ``` 16 | 17 | # 63.2 18 | ```py 19 | count = 0 20 | with open("dane/63/ciagi.txt") as file: 21 | for line in file: 22 | line = line.strip() 23 | 24 | if "11" not in line: 25 | count += 1 26 | print(count) 27 | ``` 28 | 29 | # 63.3 30 | ```py 31 | ``` 32 | -------------------------------------------------------------------------------- /dzialy/zadania_zbior/64.md: -------------------------------------------------------------------------------- 1 | # 64.1 2 | 3 | ```py 4 | lista = [] 5 | obrazek = "" 6 | with open("dane/64/dane_obrazki.txt") as file: 7 | for line in file: 8 | 9 | if line != "\n" and len(line.strip()) != 20: 10 | obrazek += line.strip()[:-1] 11 | else: 12 | if len(obrazek) > 1: 13 | lista.append(obrazek) 14 | obrazek = "" 15 | 16 | count = 0 17 | maxi = lista[0].count("1") 18 | 19 | for i in lista: 20 | black = i.count("1") 21 | 22 | if i.count("0") < black: 23 | count += 1 24 | 25 | if maxi < black: 26 | maxi = black 27 | 28 | print(count, maxi) 29 | 30 | ``` 31 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2015_maj_podstawa/2015_maj_podstawa.md: -------------------------------------------------------------------------------- 1 | ## 5.1 2 | ```py 3 | slowa = [] 4 | 5 | with open("slowa.txt") as file: 6 | for line in file: 7 | slowa.append(line.strip()) 8 | 9 | for i in range(1, 13): 10 | count = 0 11 | for line in slowa: 12 | if len(line) == i: 13 | count += 1 14 | print(i, count) 15 | 16 | ``` 17 | 18 | ## 5.2 19 | ```py 20 | slowa = [] 21 | nowe = [] 22 | 23 | with open("slowa.txt") as file: 24 | for line in file: 25 | slowa.append(line.strip()) 26 | 27 | with open("nowe.txt") as file2: 28 | for line in file2: 29 | nowe.append(line.strip()) 30 | 31 | for line in nowe: 32 | print(line, slowa.count(line), slowa.count(line[::-1])) 33 | ``` 34 | -------------------------------------------------------------------------------- /dzialy/zadania_zbior/60.md: -------------------------------------------------------------------------------- 1 | # 60.1 2 | 3 | ```py 4 | liczby = [] 5 | with open("dane/60/liczby.txt") as file: 6 | for line in file: 7 | line = int(line.strip()) 8 | if line < 1000: 9 | liczby.append(line) 10 | print(len(liczby)) 11 | print(liczby[-2:]) 12 | ``` 13 | 14 | # 60.2 15 | 16 | ```py 17 | liczby = [] 18 | 19 | with open("dane/60/liczby.txt") as file: 20 | for line in file: 21 | dzielniki = [] 22 | line = int(line.strip()) 23 | for i in range(1, line + 1): 24 | if line % i == 0: 25 | dzielniki.append(i) 26 | if len(dzielniki) == 18: 27 | liczby.append((line, dzielniki)) 28 | 29 | for i in liczby: 30 | print(i) 31 | ``` 32 | 33 | # 60.3 34 | 35 | ```py 36 | ``` 37 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2011_maj_podstawa/2011_maj_podstawa.md: -------------------------------------------------------------------------------- 1 | ## 4abc 2 | 3 | ```py 4 | parzyste = 0 5 | nieparzyste = 0 6 | 7 | with open("dane/hasla.txt") as file: 8 | with open("dane/wynik4b.txt", "w") as file2: 9 | with open("dane/wynik4c.txt", "w") as file3: 10 | for line in file: 11 | line = line.strip() 12 | if len(line) % 2 == 0: 13 | parzyste += 1 14 | else: 15 | nieparzyste += 1 16 | if line == line[::-1]: 17 | file2.write(line + "\n") 18 | if any((ord(line[i - 1]) + ord(line[i])) == 220 for i in range(1, len(line))): 19 | file3.write(line + "\n") 20 | 21 | print(parzyste, nieparzyste) 22 | 23 | ``` 24 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2013_maj_podstawa/2013_maj_podstawa.md: -------------------------------------------------------------------------------- 1 | ## 5abcd 2 | ```py 3 | parzyste = 0 4 | dl_b = 0 5 | zera = 0 6 | jedynki = 0 7 | 8 | lista = [] 9 | 10 | with open("dane/napisy.txt") as file: 11 | for line in file: 12 | line = line.strip() 13 | 14 | if len(line) % 2 == 0: # a 15 | parzyste += 1 16 | 17 | if line.count("1") == line.count("0"): # b 18 | dl_b += 1 19 | 20 | if "".join(set(list(line))) == "0": # c 21 | zera += 1 22 | elif "".join(set(list(line))) == "1": 23 | jedynki += 1 24 | 25 | lista.append(line) 26 | print(parzyste, dl_b, zera, jedynki) 27 | print("-----------------") 28 | for i in range(2, 17): 29 | count = 0 30 | for line in lista: 31 | if len(line) == i: 32 | count += 1 33 | print(i, count) 34 | 35 | ``` 36 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2021_kwiecen/2021_kwiecien.md: -------------------------------------------------------------------------------- 1 | ## 6 2 | ```py 3 | count = 0 4 | count2 = 0 5 | count3 = 0 6 | count4 = 0 7 | suma = 0 8 | lista_liczb = [] 9 | 10 | with open("liczby.txt") as file: 11 | for line in file: 12 | line = line.strip() 13 | if line[-1] == "6": # 6.1 14 | count += 1 15 | 16 | if line[-1] == "7" and "6" not in line: # 6.2 17 | count2 += 1 18 | 19 | if line[-1] == "2": 20 | if int(line[:-1], 2) % 2 != 0: # 6.3 21 | count3 += 1 22 | 23 | if line[-1] == "4": # 6.4 24 | suma += int(line[:-1], 4) 25 | 26 | lista_liczb.append((line, int(line[:-1], int(line[-1])))) 27 | 28 | print(count, count2, count3, suma) 29 | 30 | print(sorted(lista_liczb, key=lambda x: x[1], reverse=True)[0]) 31 | print(sorted(lista_liczb, key=lambda x: x[1])[0]) 32 | 33 | ``` 34 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2014_maj_podstawa/2014_maj_podstawa.md: -------------------------------------------------------------------------------- 1 | ## 5a 2 | ```py 3 | count = 0 4 | with open("dane_PP/pary_liczb.txt") as file: 5 | for line in file: 6 | a, b = map(int, line.strip().split()) 7 | if a % b == 0 or b % a == 0: 8 | count += 1 9 | 10 | print(count) 11 | 12 | ``` 13 | 14 | ## 5b 15 | ```py 16 | def nwd(a, b): return nwd(b, a % b) if b else a 17 | 18 | 19 | count = 0 20 | with open("dane_PP/pary_liczb.txt") as file: 21 | for line in file: 22 | a, b = map(int, line.strip().split()) 23 | if nwd(a, b) == 1: 24 | count += 1 25 | 26 | print(count) 27 | 28 | ``` 29 | 30 | ## 5c 31 | ```py 32 | count = 0 33 | with open("dane_PP/pary_liczb.txt") as file: 34 | for line in file: 35 | a, b = line.strip().split() 36 | suma_a = sum(int(i) for i in a) 37 | suma_b = sum(int(i) for i in b) 38 | if suma_a == suma_b: 39 | count += 1 40 | 41 | 42 | print(count) 43 | 44 | ``` 45 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2009_maj.md: -------------------------------------------------------------------------------- 1 | # 5a 2 | ```py 3 | def is_palindrom(x): 4 | if x == x[::-1]: 5 | return True 6 | return False 7 | 8 | 9 | count = 0 10 | 11 | with open("dane/dane.txt") as file: 12 | for line in file: 13 | line = line.strip().split() 14 | for i in line: 15 | if is_palindrom(i): 16 | count += 1 17 | print(count) 18 | ``` 19 | 20 | # 5b 21 | ```py 22 | count = 0 23 | 24 | with open("dane/dane.txt") as file: 25 | for line in file: 26 | line = line.strip().split() 27 | if line[1] in line[0]: 28 | count += 1 29 | print(count) 30 | ``` 31 | 32 | # 5c 33 | ```py 34 | count = 0 35 | 36 | with open("dane/dane.txt") as file: 37 | for line in file: 38 | line = line.strip().split() 39 | if "".join(set(list(line[1]))) == "0": 40 | count += 1 41 | elif "".join(set(list(line[0]))) == "0": 42 | count += 1 43 | print(count) 44 | ``` 45 | 46 | # 5d 47 | ```py 48 | ``` 49 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2013_maj.md: -------------------------------------------------------------------------------- 1 | # 6a 2 | 3 | ```py 4 | count = 0 5 | 6 | with open("dane/dane.txt") as file: 7 | for line in file: 8 | line = line.strip() 9 | if int(line[0]) == int(line[-1]): 10 | count += 1 11 | 12 | print(count) 13 | 14 | ``` 15 | 16 | # 6b 17 | ```py 18 | count = 0 19 | 20 | with open("dane/dane.txt") as file: 21 | for line in file: 22 | line = str(int(line.strip(), 8)) 23 | if int(line[0]) == int(line[-1]): 24 | count += 1 25 | 26 | print(count) 27 | 28 | ``` 29 | 30 | # 6c 31 | 32 | ```py 33 | count = 0 34 | lista = [] 35 | 36 | with open("dane/dane.txt") as file: 37 | for line in file: 38 | line = line.strip() 39 | liczba = line[0] 40 | for i in range(1, len(line)): 41 | if line[i - 1] <= line[i]: 42 | liczba += line[i] 43 | if liczba == line: 44 | count += 1 45 | lista.append(int(liczba)) 46 | 47 | print(count, max(lista), min(lista)) 48 | 49 | ``` 50 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2017_maj_podstawa/2017_maj_podstawa.md: -------------------------------------------------------------------------------- 1 | ## 4.1 2 | ```py 3 | count = 0 4 | 5 | with open("dane_PP/liczby.txt") as file: 6 | for line in file: 7 | a, b, c = map(int, line.strip().split()) 8 | if [a, b, c] == sorted([a, b, c]): 9 | count += 1 10 | print(count) 11 | ``` 12 | 13 | ## 4.2 14 | ```py 15 | def nwd(a, b): 16 | if b > 0: 17 | return nwd(b, a % b) 18 | return a 19 | 20 | 21 | suma = 0 22 | 23 | with open("dane_PP/liczby.txt") as file: 24 | for line in file: 25 | a, b, c = map(int, line.strip().split()) 26 | suma += nwd(nwd(a, b), c) 27 | print(suma) 28 | ``` 29 | 30 | 31 | ## 4.3 32 | ```py 33 | def nwd(a, b): 34 | if b > 0: 35 | return nwd(b, a % b) 36 | return a 37 | 38 | 39 | suma_cyfr = [] 40 | 41 | with open("dane_PP/liczby.txt") as file: 42 | for line in file: 43 | a, b, c = line.strip().split() 44 | 45 | wiersz = "".join([a, b, c]) 46 | 47 | suma = 0 48 | 49 | for i in wiersz: 50 | suma += int(i) 51 | 52 | suma_cyfr.append(suma) 53 | 54 | print(suma_cyfr.count(35), max(suma_cyfr), suma_cyfr.count(max(suma_cyfr))) 55 | ``` 56 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2015_maj.md: -------------------------------------------------------------------------------- 1 |

2015 maj

2 | 3 | [SPIS ARKUSZY](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze.md) 4 | 5 | ## 4.1 6 | 7 | ```py 8 | zera = jedynki = wynik = 0 9 | 10 | with open("Dane_PR/liczby.txt") as file: 11 | for line in file: 12 | for char in line: 13 | if char == "0": 14 | zera += 1 15 | elif char == "1": 16 | jedynki += 1 17 | if zera > jedynki: 18 | wynik += 1 19 | zera = 0 20 | jedynki = 0 21 | 22 | print(wynik) 23 | 24 | ``` 25 | 26 | ## 4.2 27 | 28 | ```py 29 | przezdwa = przezosiem = 0 30 | with open("Dane_PR/liczby.txt") as file: 31 | for line in file: 32 | line = int(line, 2) 33 | 34 | if line % 2 == 0: 35 | przezdwa += 1 36 | if line % 8 == 0: 37 | przezosiem += 1 38 | 39 | print(przezdwa, "|", przezosiem) 40 | 41 | ``` 42 | 43 | ## 4.3 44 | 45 | ```py 46 | lista = [] 47 | 48 | with open("Dane_PR/liczby.txt") as file: 49 | for line in file: 50 | lista.append(int(line, 2)) 51 | 52 | print(lista.index(max(lista)) + 1, "|", lista.index(min(lista)) + 1) 53 | 54 | ``` 55 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2014_maj.md: -------------------------------------------------------------------------------- 1 | # 5a 2 | ```py 3 | def is_prime(x): 4 | if x > 1: 5 | for i in range(2, x): 6 | if x % i == 0: 7 | return False 8 | return True 9 | return False 10 | 11 | 12 | count = 0 13 | 14 | with open("Dane_PR/napis.txt") as file: 15 | for line in file: 16 | line = line.strip() 17 | liczba = 0 18 | for char in line: 19 | liczba += ord(char) 20 | if is_prime(liczba): 21 | count += 1 22 | print(count) 23 | 24 | ``` 25 | 26 | # 5b 27 | ```py 28 | count = 0 29 | 30 | with open("Dane_PR/napis.txt") as file: 31 | for line in file: 32 | line = line.strip() 33 | liczba = 0 34 | napis = line[0] 35 | for i in range(1, len(line)): 36 | 37 | if ord(line[i - 1]) < ord(line[i]): 38 | napis += line[i] 39 | if napis == line: 40 | print(line) 41 | ``` 42 | 43 | # 5c 44 | ```py 45 | from collections import Counter 46 | 47 | lista = [] 48 | 49 | with open("Dane_PR/napis.txt") as file: 50 | for line in file: 51 | line = line.strip() 52 | lista.append(line) 53 | 54 | counter = dict(Counter(lista)) 55 | 56 | for k, v in counter.items(): 57 | if v > 1: 58 | print(k) 59 | ``` 60 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2018_czerwiec.md: -------------------------------------------------------------------------------- 1 |

2018 Czerwiec

2 | 3 | [SPIS ARKUSZY](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze.md) 4 | 5 | ## 4.1 6 | 7 | ```py 8 | count = 0 9 | with open("NM_DANE_PR/dane1.txt") as dane1, open("NM_DANE_PR/dane2.txt") as dane2: 10 | for (a, b) in zip(dane1, dane2): 11 | a, b = a.strip(), b.strip() 12 | if a[-3:] == b[-3:]: 13 | count += 1 14 | print(count) 15 | 16 | ``` 17 | 18 | ## 4.2 19 | 20 | ```py 21 | count = parzyste = parzyste2 = 0 22 | 23 | with open("NM_DANE_PR/dane1.txt") as dane1, open("NM_DANE_PR/dane2.txt") as dane2: 24 | for (a, b) in zip(dane1, dane2): 25 | a, b = a.strip().split(), b.strip().split() 26 | for i, j in zip(a, b): 27 | i, j = int(i), int(j) 28 | if i % 2 == 0: 29 | parzyste += 1 30 | if j % 2 == 0: 31 | parzyste2 += 1 32 | if parzyste == 5 and parzyste2 == 5: 33 | count += 1 34 | parzyste = parzyste2 = 0 35 | print(count) 36 | 37 | ``` 38 | 39 | ## 4.3 40 | 41 | ```py 42 | index = 1 43 | with open("NM_DANE_PR/dane1.txt") as dane1, open("NM_DANE_PR/dane2.txt") as dane2: 44 | for (a, b) in zip(dane1, dane2): 45 | a = list(set(a.strip().split())) 46 | b = list(set(b.strip().split())) 47 | 48 | if a == b: 49 | print(index) 50 | index += 1 51 | 52 | ``` 53 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2017_maj_stare.md: -------------------------------------------------------------------------------- 1 |

2017 maj Matura stara

2 | 3 | [SPIS ARKUSZY](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze.md) 4 | 5 | # 4.1 6 | ```py 7 | count = 0 8 | maxi = 0 9 | with open("Dane_PR/binarne.txt") as file: 10 | for line in file: 11 | line = line.strip() 12 | pol = int(len(line) / 2) 13 | l = line[:pol] 14 | r = line[pol:] 15 | 16 | if l == r: 17 | count += 1 18 | if len(line) > maxi: 19 | maxi = len(line) 20 | napis = line 21 | 22 | print(count, napis, maxi) 23 | 24 | ``` 25 | 26 | 27 | # 4.2 28 | ```py 29 | count = 0 30 | dlugosc = 99999999 31 | with open("Dane_PR/binarne.txt") as file: 32 | for line in file: 33 | line = line.strip() 34 | res = [int((line[i:i + 4]), 2) for i in range(0, len(line), 4)] # jakis błąd syntaxu pycharm widzi tu 35 | 36 | if any(i > 9 for i in res): 37 | count += 1 38 | if len(line) < dlugosc: 39 | dlugosc = len(line) 40 | 41 | print(count, dlugosc) 42 | 43 | ``` 44 | 45 | # 4.3 46 | ```py 47 | maxi = 0 48 | 49 | with open("Dane_PR/binarne.txt") as file: 50 | for line in file: 51 | line = line.strip() 52 | liczba = int(line, 2) 53 | 54 | if liczba <= 65535: 55 | if liczba > maxi: 56 | maxi = liczba 57 | 58 | print(maxi, str(bin(maxi))[2:]) 59 | 60 | ``` 61 | -------------------------------------------------------------------------------- /dzialy/zadania_zbior/59.md: -------------------------------------------------------------------------------- 1 | ## 59.1 2 | 3 | ```py 4 | def prime_factors(n): 5 | i = 2 6 | factors = set() 7 | while i * i <= n: 8 | if n % i: 9 | i += 1 10 | else: 11 | n //= i 12 | factors.add(i) 13 | if n > 1: 14 | factors.add(n) 15 | return factors 16 | 17 | 18 | count = 0 19 | 20 | with open("dane/59/liczby.txt") as file: 21 | for line in file: 22 | line = int(line.strip()) 23 | liczby = prime_factors(line) 24 | 25 | if len(liczby) == 3 and all(i % 2 != 0 for i in liczby): 26 | count += 1 27 | 28 | print(count) 29 | ``` 30 | 31 | ## 59.2 32 | 33 | ```py 34 | count = 0 35 | with open("dane/59/liczby.txt") as file: 36 | for line in file: 37 | line = int(line.strip()) 38 | wynik = line + int(str(line)[::-1]) 39 | if wynik == int(str(wynik)[::-1]): 40 | count +=1 41 | 42 | print(count) 43 | ``` 44 | 45 | ## 59.3 46 | 47 | ```py 48 | from collections import Counter 49 | count = 0 50 | moce = [] 51 | 52 | with open("dane/59/liczby.txt") as file: 53 | for line in file: 54 | line = line.strip() 55 | liczba = line 56 | j = 0 57 | while len(line) > 1: 58 | wynik = 1 59 | for char in line: 60 | wynik *= int(char) 61 | line = str(wynik) 62 | j += 1 63 | moce.append((int(liczba),j)) 64 | 65 | print(Counter(moce[i][1] for i in range(len(moce)))) 66 | print(sorted(moce)) 67 | print(sorted(moce, reverse=True)) 68 | ``` 69 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2016_maj_podstawa/2016_maj_podstawa.md: -------------------------------------------------------------------------------- 1 | 2 | ## 6.1 3 | ```py 4 | def is_prime(x): 5 | if x > 1: 6 | for i in range(2, x): 7 | if x % i == 0: 8 | return False 9 | return True 10 | return False 11 | 12 | 13 | count = 0 14 | 15 | with open("dane/dane4.txt") as file: 16 | for line in file: 17 | line = int(line.strip()) 18 | if is_prime(line): 19 | count += 1 20 | 21 | print(count) 22 | ``` 23 | 24 | ## 6.2 25 | ```py 26 | def is_prime(x): 27 | if x > 1: 28 | for i in range(2, x): 29 | if x % i == 0: 30 | return False 31 | return True 32 | return False 33 | 34 | 35 | lista = [] 36 | 37 | with open("dane/dane4.txt") as file: 38 | for line in file: 39 | line = int(line.strip()) 40 | if is_prime(line): 41 | lista.append(line) 42 | 43 | print("max:", max(lista), "min", min(lista)) 44 | ``` 45 | 46 | ## 6.3 47 | ```py 48 | def is_prime(x): 49 | if x > 1: 50 | for i in range(2, x): 51 | if x % i == 0: 52 | return False 53 | return True 54 | return False 55 | 56 | 57 | liczby = [] 58 | 59 | with open("dane/dane4.txt") as file: 60 | for line in file: 61 | liczby.append(int(line.strip())) 62 | 63 | count = 0 64 | for i in range(1, len(liczby)): 65 | if is_prime(liczby[i - 1]) and is_prime(liczby[i]) and abs(liczby[i - 1] - liczby[i]) == 2: 66 | count += 1 67 | print(liczby[i - 1], liczby[i]) 68 | print(count) 69 | ``` 70 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2020_kwiecien_pr.md: -------------------------------------------------------------------------------- 1 |

2020 Kwiecień

2 | 3 | [SPIS ARKUSZY](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze.md) 4 | 5 | ## 4.1 6 | 7 | ```py 8 | lista = luki = [] 9 | with open("dane\dane4.txt") as file: 10 | for line in file: 11 | line = int(line.strip()) 12 | lista.append(line) 13 | 14 | wartownik = lista[0] 15 | for i in lista[1:]: 16 | wynik = abs(wartownik - i) 17 | luki.append(wynik) 18 | wartownik = i 19 | 20 | print(min(luki)) 21 | print(max(luki)) 22 | ``` 23 | 24 | ## 4.2 25 | 26 | ```py 27 | lista, luki, max_list = [], [], [] 28 | 29 | with open("dane/dane4.txt") as file: 30 | for line in file: 31 | line = int(line.strip()) 32 | lista.append(line) 33 | 34 | for i in range(len(lista)): 35 | luki.append(abs(lista[i - 1] - lista[i])) 36 | 37 | longest = count = 1 38 | 39 | for i in range(len(luki)): 40 | if luki[i - 1] == luki[i]: 41 | count += 1 42 | else: 43 | count = 1 44 | max_list.append(count) 45 | 46 | print(max(max_list) + 1) 47 | print("poczatek", lista[max_list.index(max(max_list)) - max(max_list)]) 48 | print("koniec", lista[max_list.index(max(max_list))]) 49 | 50 | ``` 51 | 52 | ## 4.3 53 | 54 | ```py 55 | from collections import Counter 56 | 57 | lista = luki = [] 58 | 59 | with open("dane/dane4.txt") as file: 60 | for line in file: 61 | line = int(line.strip()) 62 | lista.append(line) 63 | 64 | for i in range(1, len(lista)): 65 | luki.append(abs(lista[i - 1] - lista[i])) 66 | 67 | print(Counter(luki)) 68 | 69 | ``` 70 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2016_czerwiec.md: -------------------------------------------------------------------------------- 1 |

2016 Czerwiec

2 | 3 | [SPIS ARKUSZY](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze.md) 4 | 5 | ## 6.1 6 | 7 | ```py 8 | count = 0 9 | with open("MIN-R2A1P-163_dane/liczby.txt") as file: 10 | for line in file: 11 | if line.strip()[-1] == "8": 12 | count += 1 13 | print(count) 14 | 15 | ``` 16 | 17 | ## 6.2 18 | 19 | ```py 20 | count = 0 21 | with open("MIN-R2A1P-163_dane/liczby.txt") as file: 22 | for line in file: 23 | line = line.strip() 24 | print(line[:-1]) 25 | if line[-1] == "4" and "0" not in line[:-1]: 26 | count += 1 27 | print(count) 28 | 29 | ``` 30 | 31 | ## 6.3 32 | 33 | ```py 34 | count = 0 35 | with open("MIN-R2A1P-163_dane/liczby.txt") as file: 36 | for line in file: 37 | line = line.strip() 38 | if line[-1] == "2" and int(line[:-1], 2) % 2 == 0: 39 | count += 1 40 | print(count) 41 | 42 | ``` 43 | 44 | ## 6.4 45 | 46 | ```py 47 | count = 0 48 | with open("MIN-R2A1P-163_dane/liczby.txt") as file: 49 | for line in file: 50 | line = line.strip() 51 | if line[-1] == "8": 52 | count += int(line[:-1], 8) 53 | print(count) 54 | 55 | ``` 56 | 57 | ## 6.5 58 | 59 | ```py 60 | lista = [] 61 | with open("MIN-R2A1P-163_dane/liczby.txt") as file: 62 | for line in file: 63 | line = line.strip() 64 | base = int(line[-1]) 65 | lista.append((int(line), base, int(line[:-1], base))) 66 | 67 | sort_end = sorted(lista, key=lambda x: x[2], reverse=True) 68 | 69 | print(sort_end[0]) 70 | print(sort_end[-1]) 71 | 72 | ``` 73 | -------------------------------------------------------------------------------- /docs/images/discord_icon.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 5 | 9 | 10 | 11 | 12 | 13 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /dzialy/zadania_zbior/62.md: -------------------------------------------------------------------------------- 1 | # 62.1 2 | 3 | ```py 4 | liczby2 = [] 5 | with open("dane/62/liczby1.txt") as file: 6 | for line in file: 7 | line = int(line, 8) 8 | liczby2.append(line) 9 | print("max:", oct(max(liczby2))[2:], "min:", oct(min(liczby2))[2:]) 10 | ``` 11 | 12 | # 62.2 13 | 14 | ```py 15 | liczby = [] 16 | 17 | with open("dane/62/liczby2.txt") as file: 18 | for line in file: 19 | line = int(line.strip()) 20 | liczby.append(line) 21 | 22 | count = 0 23 | prev = 0 24 | indexend = 0 25 | for i in range(1, len(liczby)): 26 | if liczby[i - 1] < liczby[i]: 27 | count += 1 28 | else: 29 | if count > prev: 30 | prev = count 31 | indexend = i - 1 32 | count = 0 33 | 34 | print(prev + 1) 35 | print(liczby[indexend - prev]) 36 | ``` 37 | 38 | # 62.3 39 | 40 | Błąd w odpowiedziach od cke 41 | 42 | ```py 43 | liczba_wierszy = 0 44 | liczba_wierszy2 = 0 45 | with open("dane/62/liczby1.txt") as file: # zapisane ósemkowo 46 | with open("dane/62/liczby2.txt") as file2: # zapisane dziesiętnie 47 | for x, y in zip(file, file2): 48 | 49 | x = int(x.strip(), 8) 50 | y = int(y.strip()) 51 | 52 | if x == y: 53 | liczba_wierszy += 1 54 | elif x > y: 55 | liczba_wierszy2 += 1 56 | 57 | print(liczba_wierszy) # ma być 160 w odpowiedziach jest 639 58 | print(liczba_wierszy2) 59 | ``` 60 | 61 | # 62.4 62 | Błąd w odpowiedziach od cke. Wyniki zapisali na odwrót. 63 | 64 | ```py 65 | count1 = 0 66 | count2 = 0 67 | with open("dane/62/liczby2.txt") as file2: # zapisane dziesiętnie 68 | for x in file2: 69 | x = x.strip() 70 | 71 | count1 += int(x.count("6")) 72 | x = str(oct(int(x))) 73 | count2 += int(x.count("6")) 74 | 75 | print(count1) 76 | print(count2) 77 | 78 | ``` 79 | -------------------------------------------------------------------------------- /dzialy/zadania_zbior/61.md: -------------------------------------------------------------------------------- 1 | # 61.1 2 | 3 | ```py 4 | liczby = [] 5 | 6 | with open("dane/61/ciagi.txt") as file: 7 | for line in file: 8 | liczby.append(line.strip()) 9 | 10 | ciagi = [] 11 | 12 | for i in range(1,len(liczby),2): 13 | ciagi.append(liczby[i]) 14 | 15 | liczby.clear() 16 | 17 | count = 0 18 | maxi = -1 19 | for i in ciagi: 20 | i = list(map(int,i.split())) 21 | r = abs(i[1] - i[0]) 22 | if all(i[j] == i[j-1] + r for j in range(1,len(i))): 23 | count += 1 24 | if r > maxi: 25 | maxi = r 26 | 27 | print(count) 28 | print(maxi) 29 | 30 | ``` 31 | 32 | # 61.2 33 | 34 | ```py 35 | def is_perfect_cube(n): 36 | c = int(n ** (1 / 3.)) 37 | return (c ** 3 == n) or ((c + 1) ** 3 == n) 38 | 39 | 40 | liczby = [] 41 | 42 | with open("dane/61/ciagi.txt") as file: 43 | for line in file: 44 | liczby.append(line.strip()) 45 | 46 | ciagi = [] 47 | 48 | for i in range(1, len(liczby), 2): 49 | ciagi.append(liczby[i]) 50 | 51 | liczby.clear() 52 | 53 | for i in ciagi: 54 | i = list(map(int, i.split())) 55 | najw = 0 56 | for char in i: 57 | if is_perfect_cube(char) and char > najw: 58 | najw = char 59 | if najw != 0: 60 | print(najw) 61 | 62 | ``` 63 | 64 | # 61.3 65 | ```py 66 | def is_arithmetic(l): 67 | delta = l[1] - l[0] 68 | for index in range(len(l) - 1): 69 | if not (l[index + 1] - l[index] == delta): 70 | return l[index + 1] 71 | return True 72 | 73 | 74 | liczby = [] 75 | 76 | with open("dane/61/bledne.txt") as file: 77 | for line in file: 78 | liczby.append(line.strip()) 79 | 80 | ciagi = [] 81 | 82 | for i in range(1, len(liczby), 2): 83 | ciagi.append(liczby[i]) 84 | 85 | liczby.clear() 86 | 87 | for i in ciagi: 88 | i = list(map(int, i.split())) 89 | 90 | print(is_arithmetic(i)) 91 | 92 | ``` 93 | -------------------------------------------------------------------------------- /docs/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 |
12 | 19 | 20 | 21 | 22 | 25 | 26 | 27 | 28 | 32 | 33 | 34 | 54 | 55 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2019_maj/4.3.py: -------------------------------------------------------------------------------- 1 | # BRUTE FORCE METHOD 2 | def return_divisors(int_number): 3 | divisors = list(filter(lambda i: (int_number % i == 0), list(range(2, int_number)))) 4 | return divisors 5 | 6 | with open("liczby.txt", "r") as file: 7 | # PREPARE DATA 8 | numbers = file.read().splitlines() 9 | numbers = list(map(int, numbers)) 10 | 11 | # SET "GLOBAL" CONTAINERS 12 | max_length_of_numeric_string = 0 13 | start_number = None 14 | max_divisor = None 15 | 16 | # FIND ALL DIVISORS 17 | all_divisors = list() 18 | for number in numbers: 19 | number = int(number) 20 | all_divisors.extend(return_divisors(number)) 21 | 22 | # DELETE ALL REPETITIONS AND REVERSE 23 | all_divisors = list(set(all_divisors)) 24 | all_divisors.reverse() 25 | 26 | # TRY TO DEVISE EVERY NUMBER BY ALL POSIBLE DIVISORS 27 | for divisor in all_divisors: 28 | local_length_of_numeric_string = 1 29 | local_start_number = None 30 | for i in range(len(numbers)): 31 | if numbers[i] % divisor == 0: 32 | local_length_of_numeric_string += 1 33 | else: 34 | # FIND STRING START NUMBER 35 | try: 36 | local_start_number = numbers[i - local_length_of_numeric_string] 37 | except IndexError: 38 | local_start_number = numbers[i - local_length_of_numeric_string - 1] 39 | 40 | # CHECK IF THIS NUMBER STRING IS LONGER THAT PREVIOUS 41 | if local_length_of_numeric_string > max_length_of_numeric_string: 42 | start_number = local_start_number 43 | max_length_of_numeric_string = local_length_of_numeric_string 44 | max_divisor = divisor 45 | 46 | # RESET VARIABLE STORING NUMBER STRING LENGTHH 47 | local_length_of_numeric_string = 1 48 | 49 | print(start_number, max_length_of_numeric_string, max_divisor) 50 | -------------------------------------------------------------------------------- /dzialy/zadania_zbior/58.md: -------------------------------------------------------------------------------- 1 | ```py 2 | import math 3 | 4 | temperatury = [] 5 | temperatury2 = [] 6 | temperatury3 = [] 7 | 8 | count = 0 9 | 10 | zegary = [] 11 | zegary2 = [] 12 | zegary3 = [] 13 | 14 | with open("dane/58/dane_systemy1.txt") as s1: # binarny 15 | with open("dane/58/dane_systemy2.txt") as s2: # czworkowy 16 | with open("dane/58/dane_systemy3.txt") as s3: # ósemkowy 17 | 18 | for line in s1: 19 | zegar, temperatura = line.strip().split() 20 | zegary.append(int(zegar, 2)) 21 | temperatury.append(int(temperatura, 2)) 22 | 23 | for line in s2: 24 | zegar, temperatura = line.strip().split() 25 | zegary2.append(int(zegar, 4)) 26 | temperatury2.append(int(temperatura, 4)) 27 | 28 | for line in s3: 29 | zegar, temperatura = line.strip().split() 30 | zegary3.append(int(zegar, 8)) 31 | temperatury3.append(int(temperatura, 8)) 32 | 33 | print(bin(min(temperatury))) 34 | print(bin(min(temperatury2))) 35 | print(bin(min(temperatury3))) 36 | 37 | for i in range(len(zegary)): 38 | if zegary[i] % 12 != 0 and zegary2[i] % 12 != 0 and zegary3[i] % 12 != 0: 39 | count += 1 40 | print(count) 41 | 42 | dni = 1 43 | 44 | maxi = temperatury[0] 45 | maxi2 = temperatury2[0] 46 | maxi3 = temperatury3[0] 47 | rekord = bool 48 | 49 | for i in range(1, len(temperatury)): 50 | rekord = False 51 | 52 | if maxi < temperatury[i]: 53 | maxi = temperatury[i] 54 | rekord = True 55 | 56 | if maxi2 < temperatury2[i]: 57 | maxi2 = temperatury2[i] 58 | rekord = True 59 | 60 | if maxi3 < temperatury3[i]: 61 | maxi3 = temperatury3[i] 62 | rekord = True 63 | 64 | if rekord: 65 | dni += 1 66 | 67 | print(dni) 68 | 69 | maxi = [] 70 | lista = [3, 5, 4, 7] 71 | 72 | for i in range(len(temperatury)): 73 | for j in range(i + 1, len(temperatury)): 74 | r_ij = (temperatury[i] - temperatury[j]) ** 2 75 | maxi.append(math.ceil(r_ij / abs(i - j))) 76 | print(max(maxi)) 77 | ``` 78 | 79 | -------------------------------------------------------------------------------- /docs/css/style.css: -------------------------------------------------------------------------------- 1 | html, body { 2 | width: 100%; 3 | height: 100%; 4 | background-color: #303030; 5 | margin: 0 !important; 6 | } 7 | 8 | #container{ 9 | width: 100%; 10 | height: 100%; 11 | } 12 | 13 | ul{ 14 | list-style-type: none; 15 | font-size: 25px; 16 | width: 30%; 17 | background-color: blue; 18 | transition: all 0.7s; 19 | } 20 | 21 | li{ 22 | display: inline-block; 23 | background-color: red; 24 | padding: 0 15px 0 15px; 25 | } 26 | 27 | li:hover{ 28 | background-color: aqua; 29 | } 30 | 31 | .fix_menu{ 32 | margin-top: 10px; 33 | transition: all 0.7s; 34 | font-size: 20px; 35 | } 36 | 37 | #menu { 38 | height: 80px; 39 | z-index: 1; 40 | overflow: hidden; 41 | transition: all 0.7s; 42 | box-shadow: rgba(0, 0, 0, 0.35) 0px -50px 36px -28px inset; 43 | background-image: url("../images/bg_menu.png"); 44 | } 45 | 46 | .fixed{ 47 | position: fixed; 48 | overflow: hidden; 49 | width: 100%; 50 | height: 40px !important; 51 | transition: all 0.7s; 52 | margin-bottom: 40px; 53 | } 54 | 55 | .fix_content{ 56 | padding-top: 40px; 57 | } 58 | 59 | footer{ 60 | position:relative; 61 | border-radius: 80px 80px 0 0; 62 | height: 200px; 63 | width: 100%; 64 | background-image: url("../images/bg_footer.png"); 65 | text-align: center; 66 | box-shadow: rgba(0, 0, 0, 0.17) 0px -23px 25px 0px inset, rgba(0, 0, 0, 0.15) 0px -36px 30px 0px inset, rgba(0, 0, 0, 0.1) 0px -79px 40px 0px inset, rgba(0, 0, 0, 0.06) 0px 2px 1px, rgba(0, 0, 0, 0.09) 0px 4px 2px, rgba(0, 0, 0, 0.09) 0px 8px 4px, rgba(0, 0, 0, 0.09) 0px 16px 8px, rgba(0, 0, 0, 0.09) 0px 32px 16px; 67 | } 68 | 69 | footer img{ 70 | position: absolute; 71 | transition: all 0.7s; 72 | height: 180px; 73 | width: 180px; 74 | margin: 10px 40px 0 40px; 75 | top: 0px; 76 | left: 0px; 77 | } 78 | 79 | footer img:hover{ 80 | transition: all 0.7s; 81 | top: -50px; 82 | -webkit-filter: drop-shadow( 3px 3px 2px rgba(0, 0, 0, .7)); 83 | filter: drop-shadow( 6px 6px 4px rgba(0, 0, 0, .7)); 84 | } 85 | 86 | footer a{ 87 | display: inline-block; 88 | } 89 | 90 | footer a img{ 91 | position: relative; 92 | width: 180px; 93 | } -------------------------------------------------------------------------------- /dzialy/funkcje_wbudowane.md: -------------------------------------------------------------------------------- 1 |

Najważniejsze funkcje wbudowane

2 | 3 | * __abs()__ -> Zwraca wartość bezwględna liczby 4 | * __set()__ -> Zwraca zbiór 5 | * __dict()__ -> Zwraca słownik 6 | * __tuple()__ -> Zwraca krotkę 7 | * __frozenset()__ -> Zwraca zbiór niemożliwy do edycji 8 | * __list()__ -> Zwraca listę 9 | * __str()__ -> Zwraca string 10 | * __bool()__ -> Zwraca prawdę/fałsz 11 | * __int()__ -> Zwraca liczbę całkowitą 12 | * __float()__ -> Zwraca liczbę zmiennoprzecinkową 13 | * __min()__ -> Zwraca minimalna wartość z obiektu 14 | * __sum()__ -> Zwraca sume liczb w obiekcie 15 | * __max()__ -> Zwraca maksymalną liczbę z obiektu 16 | * __pow()__ -> Zwraca potęgę 17 | * __hex()__ -> Zwraca wartość heksadecymalną liczby dzisiętnej 18 | * __bin()__ -> Zwraca wartość binarną liczby dzisiętnej 19 | * __oct()__ -> Zwraca wartość oktalną liczby dzisiętnej 20 | * __complex()__ -> Zwraca liczbę zespoloną 21 | * __id()__ -> Zwraca adres komórki w pamięci zmiennej 22 | * __sorted()__ -> Sortuje listę 23 | * __len()__ -> Zwraca długość obiektu 24 | * __input()__ -> Pobiera wartość na wejściu 25 | * __print()__ -> Wyświetla wartość 26 | * __range()__ -> Zwraca sekwencje liczb 27 | * __round()__ -> Zaokrągla liczbę 28 | * __open()__ -> Podpięcie pliku 29 | * __format()__ -> Formaty stringa 30 | * __zip()__ -> Łączenie obiektów 31 | * __map()__ -> Rzutowanie obiektów 32 | * __any()__ -> Zwraca True, jeżeli któryś element w obiekcie jest prawdą 33 | * __all()__ -> Zwraca True, jeżeli każy element w obiekcie jest prawdą 34 | * __ord()__ -> Zwraca numer reprezentujący znak w tablicy UNICODE 35 | * __chr()__ -> Zwraca znak numeru z tablicy UNICODE 36 | * __help()__ -> System pomocy 37 | * __type()__ -> Zwraca klase zmiennej 38 | * __reversed()__ -> Zwraca odwróconą listę 39 | * __eval()__ -> Jeżeli string w zmiennej jest poprawnym kodem pythona wykonuje go 40 | * __iter()__ -> Tworzy iterator 41 | * __next()__ -> Zwraca kolejny element iteratora 42 | * __divmod()__ -> Zwraca krotke dzielnia i reszte z tego dzielenia 43 | * __enumerate(iterable, start=0)__ -> Zwraca krotke ponumerowanych elementów 44 | * __isinstance()__ -> Zwraca prawde jeżeli dany obiekt jest danego typu 45 | * __filter()__ -> Zwraca iterator funkcji, która zwraca true/false. Jeżeli true filtruje obiekt zgodnie z wartościami z funkcji. 46 | * __callable()__ -> Zwraca prawde jeżeli obiekt jest gotowy do wywołania 47 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2015_czerwiec.md: -------------------------------------------------------------------------------- 1 |

2015 czerwiec

2 | 3 | [SPIS ARKUSZY](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze.md) 4 | 5 | ## 6.1 6 | 7 | ```py 8 | suma = suma_2 = 0 9 | with open("MIN-R2A1P-153_dane\kody.txt") as file: 10 | with open("kody1.txt", "w") as result: 11 | for line in file: 12 | line = line.strip() 13 | 14 | for i in range(1, len(line), 2): 15 | suma += int(line[i]) 16 | suma_2 += int(line[i - 1]) 17 | result.write(f"{suma} {suma_2}\n") 18 | suma = suma_2 = 0 19 | 20 | ``` 21 | 22 | ## 6.2 23 | 24 | ```py 25 | suma = suma_2 = 0 26 | 27 | slow = { 28 | "0": "10101110111010", 29 | "1": "11101010101110", 30 | "2": "10111010101110", 31 | "3": "11101110101010", 32 | "4": "10101110101110", 33 | "5": "11101011101010", 34 | "6": "10111011101010", 35 | "7": "10101011101110", 36 | "8": "11101010111010", 37 | "9": "10111010111010" 38 | } 39 | with open("MIN-R2A1P-153_dane\kody.txt") as file: 40 | with open("kody2.txt", "w") as result: 41 | for line in file: 42 | line = line.strip() 43 | 44 | for i in range(1, len(line), 2): 45 | suma += int(line[i]) 46 | suma_2 += int(line[i - 1]) 47 | wynik = suma + suma_2 48 | 49 | suma = suma_2 = 0 50 | 51 | wynik %= 10 52 | wynik = 10 - wynik 53 | wynik %= 10 54 | result.write(f"{wynik} {slow[str(wynik)]}\n") 55 | 56 | ``` 57 | 58 | ## 6.3 59 | 60 | ```py 61 | suma = suma_2 = 0 62 | 63 | slow = { 64 | "0": "10101110111010", 65 | "1": "11101010101110", 66 | "2": "10111010101110", 67 | "3": "11101110101010", 68 | "4": "10101110101110", 69 | "5": "11101011101010", 70 | "6": "10111011101010", 71 | "7": "10101011101110", 72 | "8": "11101010111010", 73 | "9": "10111010111010" 74 | } 75 | with open("MIN-R2A1P-153_dane\kody.txt") as file: 76 | with open("kody3.txt", "w") as result: 77 | for line in file: 78 | line = line.strip() 79 | 80 | for i in range(1, len(line), 2): 81 | suma += int(line[i]) 82 | suma_2 += int(line[i - 1]) 83 | wynik = suma + suma_2 84 | 85 | suma = suma_2 = 0 86 | 87 | wynik %= 10 88 | wynik = 10 - wynik 89 | wynik %= 10 90 | 91 | end = f"11011010" 92 | 93 | for i in line: 94 | end += slow[i] 95 | end += f"{slow[str(wynik)]}11010110\n" 96 | result.write(end) 97 | 98 | ``` 99 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2017_czerwiec.md: -------------------------------------------------------------------------------- 1 |

2017 Czerwiec

2 | 3 | [SPIS ARKUSZY](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze.md) 4 | 5 | ## 4.1 6 | 7 | ```py 8 | import re 9 | 10 | 11 | def is_prime(x): 12 | if x > 1: 13 | for i in range(2, x): 14 | if (x % i) == 0: 15 | return False 16 | return True 17 | return False 18 | 19 | 20 | count = 0 21 | 22 | with open("MIN-DANE-2017/punkty.txt") as file: 23 | for line in file: 24 | line = re.split('\W+', line.strip()) 25 | if is_prime(int(line[0])) and is_prime(int(line[1])): 26 | print(int(line[0]), int(line[1])) 27 | count += 1 28 | print(count) 29 | 30 | ``` 31 | 32 | ## 4.2 33 | 34 | ```py 35 | import re 36 | 37 | 38 | def is_anagram(x, y): 39 | x = set(sorted(list(x))) 40 | y = set(sorted(list(y))) 41 | if x == y: 42 | return True 43 | return False 44 | 45 | 46 | count = 0 47 | 48 | with open("MIN-DANE-2017/punkty.txt") as file: 49 | for line in file: 50 | line = re.split('\W+', line.strip()) 51 | if is_anagram(line[0], line[1]): 52 | print(line[0], line[1]) 53 | count += 1 54 | print(count) 55 | 56 | ``` 57 | 58 | ## 4.3 59 | 60 | ```py 61 | import math 62 | import re 63 | from operator import itemgetter 64 | 65 | lista = [] 66 | odleglosci = [] 67 | 68 | 69 | def odleglosc(x1, y1, x2, y2): 70 | return (x1, y1), (x2, y2), int(math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)) 71 | 72 | 73 | count = 0 74 | 75 | with open("MIN-DANE-2017/punkty.txt") as file: 76 | for line in file: 77 | line = re.split('\W+', line.strip()) 78 | lista.append(line) 79 | 80 | for i in range(len(lista)): 81 | 82 | x1 = int(lista[i][0]) 83 | y1 = int(lista[i][1]) 84 | 85 | for j in range(1, len(lista)): 86 | odleglosci.append(odleglosc(x1, y1, int(lista[j][0]), int(lista[j][1]))) 87 | 88 | odleglosci.sort(key=itemgetter(2)) 89 | 90 | print(odleglosci[-1]) 91 | 92 | ``` 93 | 94 | ## 4.4 95 | 96 | ```py 97 | import re 98 | 99 | inside = 0 100 | na_boku = 0 101 | poza = 0 102 | 103 | with open("MIN-DANE-2017/punkty.txt") as file: 104 | for line in file: 105 | line = re.split('\W+', line.strip()) 106 | x = int(line[0]) 107 | y = int(line[1]) 108 | # print(x,y) 109 | if x < 5000 and y < 5000: 110 | inside += 1 111 | elif (x == 5000 or x == -5000) or (y == 5000 or y == -5000): 112 | na_boku += 1 113 | elif (x > 5000 or x < -5000) or (y > 5000 or y < -5000): 114 | poza += 1 115 | 116 | print(inside, na_boku, poza) 117 | 118 | ``` 119 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2016_maj.md: -------------------------------------------------------------------------------- 1 |

2016 maj

2 | 3 | [SPIS ARKUSZY](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze.md) 4 | 5 | ## 4.1 6 | 7 | ```PY 8 | import math 9 | 10 | count = 0 11 | 12 | 13 | def odleglosc(x, y): 14 | return math.sqrt((200 - x) ** 2 + (200 - y) ** 2) 15 | 16 | 17 | with open("Dane_NOWA\punkty.txt") as file: 18 | for line in file: 19 | x, y = line.strip().split(" ") 20 | x = int(x) 21 | y = int(y) 22 | 23 | if odleglosc(x, y) == 200: 24 | print(x, y) 25 | elif odleglosc(x, y) < 200: 26 | count += 1 27 | print(count) 28 | 29 | ``` 30 | 31 | ## 4.2 32 | To nie działa chyba 33 | 34 | ```PY 35 | import math 36 | 37 | do_kola = 0 38 | do_kwadratu = 0 39 | lista = [] 40 | 41 | 42 | def odleglosc(x, y): 43 | return math.sqrt((200 - x) ** 2 + (200 - y) ** 2) 44 | 45 | 46 | def odleglosc_od_pocz(x, y): 47 | return math.sqrt((0 - x) ** 2 + (0 - y) ** 2) 48 | 49 | 50 | with open("Dane_NOWA\punkty.txt") as file: 51 | for line in file: 52 | x, y = line.strip().split(" ") 53 | x = int(x) 54 | y = int(y) 55 | lista.append((x, y)) 56 | 57 | for i in lista[:101]: 58 | print(i) 59 | if odleglosc(i[0], i[1]) < 200: 60 | do_kola += 1 61 | if odleglosc(i[0], i[1]) > 200 and odleglosc_od_pocz(i[0], i[1]): 62 | do_kwadratu += 1 63 | 64 | print(round((4 * do_kola) / do_kwadratu, 4)) 65 | 66 | ``` 67 | 68 | ## 6.1 69 | ```py 70 | def koduj(wiadomosc, klucz): 71 | wynik = "" 72 | wiadomosc = wiadomosc.upper().strip().replace(" ", "") 73 | for i in wiadomosc: 74 | wynik += chr((ord(i) + klucz - 65) % 26 + 65) 75 | return wynik 76 | 77 | 78 | with open("Dane_NOWA/dane_6_1.txt") as file: 79 | with open("Dane_NOWA/wyniki_6_1.txt", "w") as file2: 80 | for line in file: 81 | line = line.strip() 82 | file2.write(koduj(line, 107) + "\n") 83 | 84 | ``` 85 | 86 | ## 6.2 87 | ```py 88 | def dekoduj(wiadomosc, klucz): 89 | wynik = "" 90 | wiadomosc = wiadomosc.upper().strip().replace(" ", "") 91 | for i in wiadomosc: 92 | wynik += chr((ord(i) - klucz - 65) % 26 + 65) 93 | return wynik 94 | 95 | 96 | with open("Dane_NOWA/dane_6_2.txt") as file: 97 | with open("Dane_NOWA/wyniki_6_2.txt", "w") as file2: 98 | for line in file: 99 | line = line.strip() 100 | words = line.split() 101 | 102 | try: # niektore slowa nie maja kluczy 103 | word, key = words[0], words[1] 104 | except IndexError: 105 | key = 0 106 | file2.write(dekoduj(word, int(key)) + "\n") 107 | 108 | ``` 109 | 110 | ## 6.3 111 | ```py 112 | with open("Dane_NOWA/dane_6_3.txt") as file: 113 | with open("Dane_NOWA/wyniki_6_3.txt", "w") as file2: 114 | for line in file: 115 | line = line.strip() 116 | words = line.split() 117 | 118 | word1, word2 = words[0], words[1] 119 | 120 | temp = True 121 | key = (ord(word1[0]) - ord(word2[0])) % 26 122 | 123 | for i in range(1, len(word1)): 124 | if (ord(word1[i]) - ord(word2[i])) % 26 != key: 125 | temp = False 126 | break 127 | 128 | if not temp: 129 | file2.write(word1 + " " + word2 + "\n") 130 | 131 | ``` 132 | 133 | -------------------------------------------------------------------------------- /docs/images/github_icon.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2019_czerwiec/2019_czerwiec.md: -------------------------------------------------------------------------------- 1 |

7 czerwca 2019 r.

2 | 3 | [SPIS ARKUSZY](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze.md) --- [PLIKI](https://github.com/wernexnrs/MATURA-INFORMATYKA/tree/master/dzialy/zadania_arkusze/2019_czerwiec) 4 | 5 | ## 4.1 6 | 7 | ```py 8 | def is_prime(x): 9 | if x > 1: 10 | for i in range(2, x): 11 | if x % i == 0: 12 | return False 13 | return True 14 | return False 15 | 16 | 17 | with open("MIN-R2A1P-193_dane/liczby.txt") as file: 18 | for line in file: 19 | line = int(line) 20 | if is_prime(line) and line in range(100, 5001): 21 | print(line) 22 | ``` 23 | 24 | ## 4.2 25 | 26 | ```py 27 | def is_prime(x): 28 | if x > 1: 29 | for i in range(2, x): 30 | if x % i == 0: 31 | return False 32 | return True 33 | return False 34 | 35 | 36 | with open("MIN-R2A1P-193_dane/pierwsze.txt") as file: 37 | for line in file: 38 | line = line.strip() 39 | liczba = int(line[::-1]) 40 | if is_prime(liczba): 41 | print(line) 42 | ``` 43 | 44 | ## 4.3 45 | 46 | ```py 47 | def waga(n=''): 48 | wynik = 0 49 | while len(str(n)) > 1: 50 | for char in n: 51 | char = int(char) 52 | wynik += char 53 | n = str(wynik) 54 | wynik = 0 55 | return n 56 | 57 | 58 | count = 0 59 | 60 | with open("MIN-R2A1P-193_dane/pierwsze_przyklad.txt") as file: 61 | for line in file: 62 | line = line.strip() 63 | if waga(line) == '1': 64 | count += 1 65 | print(count) 66 | ``` 67 | 68 | ## 5 [[EXCEL] POBIERZ]() - brak 69 | 70 | ### 5.* 71 | - [Wyjaśnienie]() - brak 72 | 73 | ## 6 [[ACCESS] POBIERZ](https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2019_czerwiec/6.accdb?raw=true) 74 | 75 | ### 6.1 76 | - [Wyjaśnienie]() - brak 77 | 78 | #### Kwarenda o nazwie 6_1(wynik) 79 | ```sql 80 | SELECT TOP 1 Agenci.Imie, Agenci.Nazwisko, Zainteresowanie.Id_oferty 81 | FROM Agenci INNER JOIN (Oferty INNER JOIN Zainteresowanie ON Oferty.Id_oferty = Zainteresowanie.Id_oferty) ON Agenci.Id_agenta = Oferty.Id_agenta 82 | GROUP BY Agenci.Imie, Agenci.Nazwisko, Zainteresowanie.Id_oferty, Oferty.Id_agenta 83 | ORDER BY Count(Zainteresowanie.Id_klienta) DESC; 84 | ``` 85 | 86 | ### 6.2 87 | - [Wyjaśnienie]() - brak 88 | 89 | #### Kwarenda o nazwie 6_2(wynik) 90 | ```sql 91 | SELECT Oferty.Woj, Avg(Oferty.Cena) AS ŚredniaOfCena 92 | FROM Oferty 93 | GROUP BY Oferty.Woj 94 | ORDER BY Oferty.Woj; 95 | ``` 96 | 97 | ### 6.3 98 | - [Wyjaśnienie]() - brak 99 | 100 | #### Kwarenda o nazwie 6_3(wynik) 101 | ```sql 102 | SELECT Oferty.Id_oferty, Agenci.Imie, Agenci.Nazwisko, Oferty.Woj, Oferty.Pow, Oferty.Cena 103 | FROM Agenci INNER JOIN Oferty ON Agenci.Id_agenta = Oferty.Id_agenta 104 | WHERE (((Oferty.Id_oferty) Like "*MT") AND ((Oferty.Status) Like "A")); 105 | ``` 106 | 107 | ### 6.4 108 | - [Wyjaśnienie]() - brak 109 | 110 | #### Kwarenda o nazwie 6_4(wynik) 111 | ```sql 112 | SELECT Agenci.imie, Agenci.nazwisko 113 | FROM Agenci 114 | WHERE (((Agenci.Id_agenta) Not In (SELECT id_agenta FROM oferty WHERE status="S" AND data_zglosz LIKE "2017*"))); 115 | ``` 116 | 117 | ### 6.5 118 | - [Wyjaśnienie]() - brak 119 | 120 | #### Kwarenda o nazwie 6_5(wynik) 121 | ```sql 122 | SELECT Oferty.Id_oferty, Oferty.Pow, Oferty.L_pokoi, Oferty.L_laz, Oferty.Cena, Agenci.Imie, Agenci.Nazwisko, Oferty.Status 123 | FROM Agenci INNER JOIN Oferty ON Agenci.Id_agenta = Oferty.Id_agenta 124 | WHERE (((Oferty.Pow)>180) AND ((Oferty.L_laz)>1) AND ((Oferty.Status) Like "A")); 125 | ``` 126 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2017_maj.md: -------------------------------------------------------------------------------- 1 |

2017 maj

2 | 3 | [SPIS ARKUSZY](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze.md) 4 | 5 | ## 4.1 6 | 7 | ```py 8 | import re 9 | from collections import defaultdict 10 | 11 | lista = [] 12 | 13 | with open("Dane_PR/cukier.txt") as file: 14 | for line in file: 15 | line = line.strip() 16 | lista.append((line.split("\t"))) 17 | 18 | my_dict = defaultdict(int) 19 | 20 | for k, n, v in lista: 21 | my_dict[n] += int(v) 22 | 23 | my_dict = dict(sorted(my_dict.items(), key=lambda item: item[1], reverse=True)) 24 | 25 | print(my_dict) 26 | 27 | ``` 28 | 29 | ## 4.2 30 | 31 | ```py 32 | import re 33 | 34 | lista = [] 35 | 36 | with open("Dane_PR/cukier.txt") as file: 37 | for line in file: 38 | line = line.strip() 39 | lista.append((line.split("\t"))) 40 | 41 | for i in range(len(lista)): 42 | lista[i][0] = re.findall("^[0-9]{4}", lista[i][0]) 43 | print(lista[i]) 44 | 45 | ``` 46 | 47 | ## 6.1 48 | ```py 49 | mini = 999999 50 | maxi = -999999 51 | 52 | with open("dane_pr/dane.txt") as file: 53 | for line in file: 54 | line = list(map(int,line.strip().split())) 55 | 56 | if max(line) > maxi: 57 | maxi = max(line) 58 | if min(line) < mini: 59 | mini = min(line) 60 | 61 | print(maxi,mini) 62 | ``` 63 | 64 | ## 6.2 65 | ```py 66 | count = 0 67 | 68 | with open("dane_pr/dane.txt") as file: 69 | for line in file: 70 | line = list(map(int, line.strip().split())) 71 | 72 | l = line[:160] 73 | r = line[160:] 74 | 75 | if l != list(reversed(r)): 76 | count += 1 77 | 78 | print(count) 79 | ``` 80 | 81 | ## 6.3 82 | ```py 83 | tablica = [] 84 | 85 | with open("dane_pr/dane.txt") as file: 86 | for line in file: 87 | line = list(map(int, line.strip().split())) 88 | tablica.append(line) 89 | 90 | ilekontrastujacych = 0 91 | 92 | for i in range(200): 93 | for j in range(320): 94 | 95 | kontrastujacy = 0 96 | 97 | if j > 0: 98 | roznica = tablica[i][j] - tablica[i][j - 1] 99 | if roznica < 0: 100 | roznica = roznica * (-1) 101 | if roznica > 128: 102 | kontrastujacy = 1 103 | 104 | if j < 319: 105 | roznica = tablica[i][j] - tablica[i][j + 1] 106 | if roznica < 0: 107 | roznica = roznica * (-1) 108 | if roznica > 128: 109 | kontrastujacy = 1 110 | 111 | if i > 0: 112 | roznica = tablica[i][j] - tablica[i - 1][j] 113 | if roznica < 0: 114 | roznica = roznica * (-1) 115 | if roznica > 128: 116 | kontrastujacy = 1 117 | 118 | if i < 199: 119 | roznica = tablica[i][j] - tablica[i + 1][j] 120 | if roznica < 0: 121 | roznica = roznica * (-1) 122 | if roznica > 128: 123 | kontrastujacy = 1 124 | 125 | if kontrastujacy == 1: 126 | ilekontrastujacych += 1 127 | 128 | print(ilekontrastujacych) 129 | 130 | ``` 131 | 132 | ## 6.4 133 | ```py 134 | Y_SIZE = 200 # rows number 135 | X_SIZE = 320 # columns number 136 | table = [] 137 | 138 | with open("dane_pr/dane.txt") as file: 139 | lines = file.read().splitlines() 140 | for line in lines: 141 | row = list(map(int, line.split(' '))) 142 | table.append(row) 143 | 144 | max_length = 1 145 | for x in range(X_SIZE): 146 | last_number = None 147 | row_max_length = 1 148 | for y in range(Y_SIZE): 149 | if last_number == table[y][x]: 150 | row_max_length += 1 151 | else: 152 | last_number = table[y][x] 153 | if row_max_length > max_length: 154 | max_length = row_max_length 155 | row_max_length = 1 156 | 157 | if row_max_length > max_length: 158 | max_length = row_max_length 159 | 160 | print(max_length) 161 | ``` 162 | -------------------------------------------------------------------------------- /dzialy/metody.md: -------------------------------------------------------------------------------- 1 |

Metody

2 |

Nie jest to wyczerpanie tematu.

3 | 4 | ### STRING [⬆️](#) 5 |

Wszystkie metody na napisach zwracają wartości. Nie zmieniają oryginalnego ciągu znaków.

6 | 7 | * __.capitalize()__ -> zmienia pierwszy znak na duży 8 | * __.lower()__ -> zmienia ciąg na małe litery 9 | * __.upper()__ -> zmienia ciąg na wielkie litery 10 | * __.center(length, char = " ")__ -> wyśrodkowany string 11 | * __.count(value, start = 0, end = -1)__ -> zwraca ilość wystąpień danego znaku 12 | * __.endswith(value, start = 0, end = -1)__ -> True jeżeli kończy sie podaną wartością 13 | * __.find(value, start = 0, end = -1)__ -> zwraca index pierwszego znaku szukanego ciągu, -1 jeżeli nie ma 14 | * __.index()__ -> To samo co find tylko tutaj zwraca błąd, jeżeli znaku nie ma w stringu 15 | * __.isalpha()__ -> True jeżeli same litery 16 | * __.isdecimal()__ -> True jeżeli same liczby 17 | * __.islower()__ -> True jeżeli same małe znaki 18 | * __.isnumeric()__ -> True jeżeli same liczby ascii 19 | * __.isspace()__ -> True jeżeli same białe znaki 20 | * __.istitle()__ -> True jeżeli pierwsza litera każdego słowa jest wielka 21 | * __.isupper()__ -> True jeżeli same duze litery 22 | * __.islower()__ -> True jeżeli same małe litery 23 | * __.title()__ -> zmienia pierwszy znak każdego słowa na wielki 24 | * __.swapcase()__ -> zamienia małe na wielkie, wielkie na małe litery 25 | * __.strip(char)__ -> usuwa białe znaki z początku i końca lub znaki podane jako argument 26 | * __.splitlines(keeplinebreaks = False)__ -> zwraca liste ciągu znaków odzielonych końcem lini 27 | * __.split(separator, maxsplit = -1)__ -> zwraca liste ciągu znaków odzielonych argumentem 28 | * __.replace(x, y, count)__ -> zamienia x na y 29 | * __".".join(iterable)__ -> łączy ciągi znaków w tym wypadku kropką 30 | 31 | ### LISTY [⬆️](#) 32 | * __.append()__ -> Dodaje element na koniec listy 33 | * __.clear()__ -> Czyści liste 34 | * __.copy()__ -> Zwraca płytką kopię listy 35 | * __.count(value)__ -> Zwraca liczbę wystąpień argumentu 36 | * __.extend()__ -> Rozszerza listę 37 | * __.index()__ -> Zwraca index pierwszego napotkanego argumentu 38 | * __.insert(pos, elmnt)__ -> Wstawia element na dany index 39 | * __.pop(pos = -1)__ -> Usuwa element na danym indexie, zwraca go również 40 | * __.remove()__ -> Usuwa pierwszy element o danej wartości 41 | * __.reverse()__ -> Odwraca listę 42 | * __.sort(reverse = True | False, key = myFunc)__ -> Sortuje listę w miejscu 43 | 44 | ### SŁOWNIKI [⬆️](#) 45 | * __.clear()__ -> Czyści słownik 46 | * __.copy()__ -> Plytka kopia 47 | * __.get(keyname, value)__ -> Zwraca wartość danego klucza 48 | * __.fromkeys(x, y)__ -> Zwraca słownik klucza i wartości 49 | * __.items()__ -> Zwraca listę krotek kluczy i wartości 50 | * __.keys()__ -> Zwraca listę kluczy 51 | * __.pop(keyname, defaultvalue)__ -> Usuwa element z danym kluczem, jeżeli nie ma zwraca wartość argumentu "defaultvalue" 52 | * __.popitem()__ -> Usuwa ostatni wstawiony do słownika element 53 | * __.update()__ -> Updates the dictionary with the specified key-value pairs 54 | * __.values()__ -> Zwraca listę wartości 55 | 56 | ### ZBIORY [⬆️](#) 57 | * __.add()__ -> Dodaje element 58 | * __.clear()__ -> Usuwa wszystkie elementy 59 | * __.copy()__ -> Zwraca kopie 60 | * __x.difference(y)__ -> Zwraca zbiór elementów z x których nie ma w y 61 | * __.discard()__ -> Usuwa dany element, nie zwraca błędu jeżeli go nie ma 62 | * __x.intersection(y)__ -> Zwraca zbiór z wartościami które występują w obu zbiorach 63 | * __x.isdisjoint(y)__ -> Zwraca prawdę, jeżeli nie ma takiego elementu który jest w obu zbiorach 64 | * __x.issubset(y)__ -> Zwraca prawdę, jeżeli wszystkie elementy z x są w y 65 | * __.pop()__ -> Usuwa randomowy element ze zbioru, również go zwraca 66 | * __.remove()__ -> Usuwa dany element ze zbioru 67 | * __x.symmetric_difference(y)__ -> Zwraca elementy które nie są częscią wspólną zbiorów 68 | * __.union()__ -> Zwraca zbiór wszystkich elementów bez powtórzeń 69 | 70 | ### KROTKI [⬆️](#) 71 | * __.count(x)__ -> Zwraca liczbę powtórzeń wartości 72 | * __.index(x)__ -> Zwraca index wartości i błąd jeżeli wartości nie ma 73 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2021_marzec_pr.md: -------------------------------------------------------------------------------- 1 | # 4.1 2 | ```py 3 | from collections import Counter 4 | 5 | panstwa = [] 6 | with open("Dane_2103/galerie.txt") as file: 7 | for line in file: 8 | line = line.strip() 9 | kod_kraju, miasto, *liczby = line.split() 10 | 11 | panstwa.append(kod_kraju) 12 | 13 | with open("Dane_2103/wynik4_1.tx.txt", "w") as file2: 14 | for k, v in Counter(panstwa).items(): 15 | file2.write(k + " " + str(v) + "\n") 16 | 17 | ``` 18 | 19 | # 4.2a 20 | ```py 21 | with open("Dane_2103/galerie.txt") as file: 22 | with open("Dane_2103/wynik4_2a.txt", "w") as file2: 23 | for line in file: 24 | kod_kraju, miasto, *liczby = line.strip().split() 25 | liczby = list(map(int, filter(lambda x: x != '0', liczby))) 26 | 27 | powierzchnie = [liczby[i - 1] * liczby[i] for i in range(1, len(liczby), 2)] 28 | 29 | #albo 30 | ''' 31 | powierzchnie = [a * b for a, b in zip(liczby[::2], liczby[1::2])] 32 | ''' 33 | 34 | file2.write(miasto + " " + str(sum(powierzchnie)) + " " + str(len(powierzchnie)) + "\n") 35 | 36 | ``` 37 | 38 | # 4.2b 39 | ```py 40 | maxi = 0 41 | mini = 999999999999999999999999 42 | lista = [] 43 | with open("Dane_2103/galerie.txt") as file: 44 | for line in file: 45 | kod_kraju, miasto, *liczby = line.strip().split() 46 | liczby = list(map(int, filter(lambda x: x != '0', liczby))) 47 | 48 | powierzchnie = [liczby[i - 1] * liczby[i] for i in range(1, len(liczby), 2)] 49 | 50 | # albo 51 | ''' 52 | powierzchnie = [a * b for a, b in zip(liczby[::2], liczby[1::2])] 53 | ''' 54 | lista.append((miasto, sum(powierzchnie))) 55 | 56 | maxi = sorted(lista, key=lambda x: x[1], reverse=True)[0] 57 | mini = sorted(lista, key=lambda x: x[1])[0] 58 | 59 | with open("Dane_2103/wynik4_2b.txt", "w") as file2: 60 | file2.write(maxi[0] + " " + str(maxi[1]) + "\n") 61 | file2.write(mini[0] + " " + str(mini[1]) + "\n") 62 | 63 | # albo 64 | ''' 65 | suma_pow = sum(powierzchnie) 66 | if suma_pow > maxi: 67 | maxi = suma_pow 68 | maxi_miasto = miasto 69 | 70 | if suma_pow < mini: 71 | mini = suma_pow 72 | mini_miasto = miasto 73 | 74 | 75 | with open("Dane_2103/wynik4_2b.txt", "w") as file2: 76 | file2.write(maxi_miasto + " " + str(maxi) + "\n") 77 | file2.write(mini_miasto+ " " + str(mini) + "\n") 78 | 79 | ''' 80 | 81 | ``` 82 | 83 | # 4.3 84 | ```py 85 | lokale = [] 86 | 87 | with open("Dane_2103/galerie_przyklad.txt") as file: 88 | for line in file: 89 | line = line.strip() 90 | kod_kraju, miasto, *liczby = line.split() 91 | 92 | liczby = list(map(int, filter(lambda a: a != '0', liczby))) 93 | 94 | powierzchnie = [liczby[i - 1] * liczby[i] for i in range(1, len(liczby), 2)] 95 | 96 | # albo 97 | ''' 98 | powierzchnie = [a * b for a, b in zip(liczby[::2], liczby[1::2])] 99 | ''' 100 | lokale.append((miasto, len(set(powierzchnie)))) 101 | 102 | maxi = max(lokale, key=lambda x: x[1]) 103 | mini = min(lokale, key=lambda x: x[1]) 104 | 105 | # albo 106 | ''' 107 | maxi = sorted(lokale, key=lambda x: x[1], reverse=True)[0] 108 | mini = sorted(lokale, key=lambda x: x[1])[0] 109 | ''' 110 | 111 | with open("Dane_2103/wynik4_3.txt", "w") as file2: 112 | file2.write(maxi[0] + " " + str(maxi[1]) + "\n") 113 | file2.write(mini[0] + " " + str(mini[1]) + "\n") 114 | 115 | ``` 116 | 117 | # 5.1 118 | ```py 119 | from collections import Counter 120 | 121 | lista = [] 122 | 123 | with open("Dane_2103/telefony.txt") as file: 124 | for line in file: 125 | line = line.strip().split() 126 | lista.append(line) 127 | 128 | del lista[0] 129 | numery = [] 130 | 131 | for line in lista: 132 | numery.append(line[0]) 133 | 134 | print(sorted(list(Counter(numery).items()), key=lambda x: x[1], reverse=True)[:3]) 135 | 136 | ``` 137 | 138 | # 5.2 139 | ```py 140 | # bez wykresu, nie ma matplotlib 141 | lista = [] 142 | 143 | with open("Dane_2103/telefony.txt") as file: 144 | for line in file: 145 | line = line.strip().split() 146 | lista.append(line) 147 | 148 | del lista[0] 149 | 150 | zestawienie = dict() 151 | 152 | for line in lista: 153 | if line[1] not in zestawienie: 154 | zestawienie[line[1]] = list() 155 | zestawienie[line[1]].extend([line[0]]) 156 | 157 | for k, v in zestawienie.items(): 158 | komorkowe = 0 159 | stacjonarne = 0 160 | for i in v: 161 | if len(i) == 7: 162 | stacjonarne += 1 163 | elif len(i) == 8: 164 | komorkowe += 1 165 | 166 | print(k, komorkowe, stacjonarne) 167 | 168 | 169 | ``` 170 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2018_maj/2018_maj.md: -------------------------------------------------------------------------------- 1 |

11 maja 2018

2 | 3 | [SPIS ARKUSZY](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze.md) 4 | 5 | ## 4.1 6 | 7 | ```py 8 | res = "" 9 | 10 | with open("Dane_PR/przyklad.txt") as file: 11 | lista = file.read().splitlines() 12 | 13 | for i in range(39, len(lista) + 1, 40): 14 | res += lista[i][9] 15 | 16 | print(res) 17 | ``` 18 | 19 | ## 4.2 20 | 21 | ```py 22 | with open("Dane_PR/przyklad.txt") as file: 23 | lista = file.read().splitlines() 24 | 25 | maxi = 0 26 | 27 | for i in range(len(lista)): 28 | if len(set(lista[i])) > maxi: 29 | maxi = len(set(lista[i])) 30 | index = i 31 | print(lista[index], maxi) 32 | ``` 33 | 34 | ## 4.3 35 | 36 | 37 | ```py 38 | with open("Dane_PR/sygnaly.txt") as file: 39 | lista = file.read().splitlines() 40 | 41 | for word in lista: 42 | if all(abs(ord(x) - ord(word[char-1])) < 10 for char in range(1, len(word)) for x in word): 43 | print(word) 44 | ``` 45 | 46 | ## 5 [[EXCEL] POBIERZ](https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2018_maj/zbiornik.xlsx?raw=true) 47 | 48 | ### 5.* 49 | - [Wyjaśnienie](https://www.youtube.com/watch?v=US9jXTPTytY&ab_channel=KonradBuzak) 50 | 51 | ### 5.1 52 | - [Wyjaśnienie](https://www.youtube.com/watch?v=de44MtdIlw4&ab_channel=Excel.iAdam) 53 | 54 | ### 5.2 55 | - [Wyjaśnienie](https://www.youtube.com/watch?v=MsDWcbx75rg&ab_channel=Excel.iAdam) 56 | 57 | ### 5.3 58 | - [Wyjaśnienie](https://www.youtube.com/watch?v=x3yhpVcfOwE&ab_channel=Excel.iAdam) 59 | 60 | ### 5.4 61 | - [Wyjaśnienie](https://www.youtube.com/watch?v=skn67wqwX-E&ab_channel=Excel.iAdam) 62 | 63 | ## 6 [[ACCESS] POBIERZ](https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2020_maj/5.accdb?raw=true) 64 | 65 | - [Wyjaśnienie](https://www.youtube.com/watch?v=GgcosD1kXbo&ab_channel=Informatura) 66 | 67 | ### 6.1 68 | 69 | #### Kwarenda o nazwie 6_1(wynik) 70 | ```sql 71 | SELECT TOP 10 Komputery.Pojemnosc_dysku, Count(Komputery.Pojemnosc_dysku) AS PoliczOfPojemnosc_dysku 72 | FROM Komputery 73 | GROUP BY Komputery.Pojemnosc_dysku 74 | ORDER BY Count(Komputery.Pojemnosc_dysku) DESC; 75 | ``` 76 | 77 | ### 6.2 78 | 79 | #### Kwarenda o nazwie 6_2(1) 80 | ```sql 81 | SELECT Komputery.Sekcja, Awarie.Numer_komputera, Naprawy.Rodzaj 82 | FROM Komputery INNER JOIN (Awarie INNER JOIN Naprawy ON Awarie.Numer_zgloszenia = Naprawy.Numer_zgloszenia) ON Komputery.Numer_komputera = Awarie.Numer_komputera 83 | WHERE (((Komputery.Sekcja)="A") AND ((Naprawy.Rodzaj) Like "wymiana")); 84 | ``` 85 | 86 | #### Kwarenda o nazwie 6_2(wynik) 87 | ```sql 88 | SELECT [6_2(1)].Numer_komputera, Count([6_2(1)].Rodzaj) AS PoliczOfRodzaj 89 | FROM [6_2(1)] 90 | GROUP BY [6_2(1)].Numer_komputera 91 | HAVING (((Count([6_2(1)].Rodzaj))>=10)); 92 | ``` 93 | 94 | ### 6.3 95 | 96 | #### Kwarenda o nazwie 6_3(1) 97 | ```sql 98 | SELECT Komputery.Sekcja, Count(Komputery.Sekcja) AS PoliczOfSekcja 99 | FROM Komputery 100 | GROUP BY Komputery.Sekcja; 101 | ``` 102 | 103 | #### Kwarenda o nazwie 6_3(2) 104 | ```sql 105 | SELECT DateValue([Awarie]![Czas_awarii]) AS Wyr1, Komputery.Sekcja, Count(Komputery.Sekcja) AS PoliczOfSekcja 106 | FROM Komputery INNER JOIN (Awarie INNER JOIN Naprawy ON Awarie.Numer_zgloszenia = Naprawy.Numer_zgloszenia) ON Komputery.Numer_komputera = Awarie.Numer_komputera 107 | GROUP BY DateValue([Awarie]![Czas_awarii]), Komputery.Sekcja; 108 | ``` 109 | 110 | #### Kwarenda o nazwie 6_3(wynik) 111 | ```sql 112 | SELECT TOP 1 [6_3(2)].Wyr1, [6_3(2)].PoliczOfSekcja, [6_3(2)].PoliczOfSekcja, [6_3(2)].Sekcja 113 | FROM [6_3(1)], [6_3(2)] 114 | WHERE ((([6_3(2)].PoliczOfSekcja) In ([6_3(1)].[PoliczOfSekcja]) And ([6_3(2)].PoliczOfSekcja)=([6_3(1)].[PoliczOfSekcja]))); 115 | ``` 116 | 117 | ### 6.4 118 | 119 | #### Kwarenda o nazwie 6_4(wynik) 120 | ```sql 121 | SELECT TOP 1 [Naprawy]![Czas_naprawy]-[Awarie]![Czas_awarii] AS Wyr1, Naprawy.Numer_zgloszenia, Naprawy.Czas_naprawy, Awarie.Czas_awarii 122 | FROM Komputery INNER JOIN (Awarie INNER JOIN Naprawy ON Awarie.Numer_zgloszenia = Naprawy.Numer_zgloszenia) ON Komputery.Numer_komputera = Awarie.Numer_komputera 123 | ORDER BY [Naprawy]![Czas_naprawy]-[Awarie]![Czas_awarii] DESC; 124 | ``` 125 | 126 | ### 6.5 127 | 128 | #### Kwarenda o nazwie 6_5(1) 129 | ```sql 130 | SELECT Komputery.Numer_komputera 131 | FROM Komputery INNER JOIN Awarie ON Komputery.Numer_komputera = Awarie.Numer_komputera 132 | WHERE (((Awarie.Priorytet)>=8)) 133 | GROUP BY Komputery.Numer_komputera; 134 | ``` 135 | 136 | #### Kwarenda o nazwie 6_5(2) 137 | ```sql 138 | SELECT Count([6_5(1)].Numer_komputera) AS PoliczOfNumer_komputera 139 | FROM [6_5(1)]; 140 | ``` 141 | 142 | #### Kwarenda o nazwie 6_5(3) 143 | ```sql 144 | SELECT Count(Komputery.Numer_komputera) AS PoliczOfNumer_komputera 145 | FROM Komputery; 146 | ``` 147 | 148 | #### Kwarenda o nazwie 6_5(wynik) 149 | ```sql 150 | SELECT [6_5(3)]![PoliczOfNumer_komputera]-[6_5(2)]![PoliczOfNumer_komputera] AS Wyr1 151 | FROM [6_5(2)], [6_5(3)]; 152 | ``` 153 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2019_maj/2019_maj.md: -------------------------------------------------------------------------------- 1 |

2019 Maj

2 | 3 | [SPIS ARKUSZY](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze.md) 4 | 5 | ## 4.1 6 | 7 | ```py 8 | lista = [] 9 | liczba = 0 10 | i = 0 11 | 12 | while liczba <= 100000: 13 | liczba = 3 ** i 14 | lista.append(liczba) 15 | i += 1 16 | 17 | count = 0 18 | 19 | with open("Dane_PR/liczby.txt") as file: 20 | for line in file: 21 | line = int(line.strip()) 22 | if line in lista: 23 | count += 1 24 | print(count) 25 | 26 | 27 | ``` 28 | 29 | ## 4.2 30 | 31 | ```py 32 | import math 33 | 34 | with open("Dane_PR/liczby.txt") as file: 35 | for line in file: 36 | line = line.strip() 37 | suma = 0 38 | for num in line: 39 | num = int(num) 40 | suma += math.factorial(num) 41 | if int(line) == suma: 42 | print(line) 43 | 44 | 45 | ``` 46 | 47 | ## 4.3 48 | 49 | ```PY 50 | # BRUTE FORCE METHOD 51 | def return_divisors(int_number): 52 | divisors = list(filter(lambda i: (int_number % i == 0), list(range(2, int_number)))) 53 | return divisors 54 | 55 | with open("liczby.txt", "r") as file: 56 | # PREPARE DATA 57 | numbers = file.read().splitlines() 58 | numbers = list(map(int, numbers)) 59 | 60 | # SET "GLOBAL" CONTAINERS 61 | max_length_of_numeric_string = 0 62 | start_number = None 63 | max_divisor = None 64 | 65 | # FIND ALL DIVISORS 66 | all_divisors = list() 67 | for number in numbers: 68 | number = int(number) 69 | all_divisors.extend(return_divisors(number)) 70 | 71 | # DELETE ALL REPETITIONS AND REVERSE 72 | all_divisors = list(set(all_divisors)) 73 | all_divisors.reverse() 74 | 75 | # TRY TO DEVISE EVERY NUMBER BY ALL POSIBLE DIVISORS 76 | for divisor in all_divisors: 77 | local_length_of_numeric_string = 1 78 | local_start_number = None 79 | for i in range(len(numbers)): 80 | if numbers[i] % divisor == 0: 81 | local_length_of_numeric_string += 1 82 | else: 83 | # FIND STRING START NUMBER 84 | try: 85 | local_start_number = numbers[i - local_length_of_numeric_string] 86 | except IndexError: 87 | local_start_number = numbers[i - local_length_of_numeric_string - 1] 88 | 89 | # CHECK IF THIS NUMBER STRING IS LONGER THAT PREVIOUS 90 | if local_length_of_numeric_string > max_length_of_numeric_string: 91 | start_number = local_start_number 92 | max_length_of_numeric_string = local_length_of_numeric_string 93 | max_divisor = divisor 94 | 95 | # RESET VARIABLE STORING NUMBER STRING LENGTHH 96 | local_length_of_numeric_string = 1 97 | 98 | print(start_number, max_length_of_numeric_string, max_divisor) 99 | ``` 100 | 101 | ## 5 [[EXCEL] POBIERZ](https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2019_maj/zadanko.xlsx?raw=true) 102 | 103 | ### 5.* 104 | - [Wyjaśnienie](https://www.youtube.com/watch?v=GVuGcqjkubc&ab_channel=KonradBuzak) 105 | 106 | ## 6 [[ACCESS] POBIERZ](https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2019_maj/perfumydlawas.accdb?raw=true) 107 | 108 | ### 6.* 109 | - [Wyjaśnienie](https://www.youtube.com/watch?v=m1GHqhcnO_g) 110 | 111 | #### Kwarenda o nazwie 6_1(wynik) 112 | ```sql 113 | SELECT Perfumy.nazwa_p 114 | FROM Perfumy INNER JOIN Sklad ON Perfumy.id_perfum = Sklad.id_perfum 115 | WHERE (((Sklad.nazwa_skladnika)="absolut jasminu")); 116 | ``` 117 | 118 | #### Kwarenda o nazwie 6_2(1) 119 | ```sql 120 | SELECT Perfumy.rodzina_zapachow, Min(Perfumy.cena) AS MinimumOfcena 121 | FROM (Marki INNER JOIN Perfumy ON Marki.id_marki = Perfumy.id_marki) INNER JOIN Sklad ON Perfumy.id_perfum = Sklad.id_perfum 122 | GROUP BY Perfumy.rodzina_zapachow; 123 | ``` 124 | 125 | #### Kwarenda o nazwie 6_2(wynik) 126 | ```sql 127 | SELECT [6_2(1)].rodzina_zapachow, Perfumy.cena, Perfumy.nazwa_p 128 | FROM [6_2(1)] INNER JOIN Perfumy ON ([6_2(1)].rodzina_zapachow = Perfumy.rodzina_zapachow) AND ([6_2(1)].MinimumOfcena = Perfumy.cena); 129 | ``` 130 | 131 | #### Kwarenda o nazwie 6_3(1) 132 | ```sql 133 | SELECT Marki.id_marki, Sklad.nazwa_skladnika 134 | FROM (Marki INNER JOIN Perfumy ON Marki.id_marki = Perfumy.id_marki) INNER JOIN Sklad ON Perfumy.id_perfum = Sklad.id_perfum 135 | WHERE (((Sklad.nazwa_skladnika) Like "*paczula*")); 136 | ``` 137 | 138 | #### Kwarenda o nazwie 6_3(wynik) 139 | ```sql 140 | SELECT Marki.nazwa_m 141 | FROM Marki LEFT JOIN [6_3(1)] ON Marki.[id_marki] = [6_3(1)].[id_marki] 142 | WHERE ((([6_3(1)].id_marki) Is Null)) 143 | ORDER BY Marki.nazwa_m; 144 | ``` 145 | 146 | #### Kwarenda o nazwie 6_4(wynik) 147 | ```sql 148 | SELECT Perfumy.nazwa_p, [cena]*0.85 AS Wyr1 149 | FROM (Marki INNER JOIN Perfumy ON Marki.id_marki = Perfumy.id_marki) INNER JOIN Sklad ON Perfumy.id_perfum = Sklad.id_perfum 150 | GROUP BY Perfumy.nazwa_p, [cena]*0.85, Perfumy.id_marki, Perfumy.rodzina_zapachow 151 | HAVING (((Perfumy.id_marki)="m_1") AND ((Perfumy.rodzina_zapachow)="orientalno-drzewna")) 152 | ORDER BY [cena]*0.85; 153 | ``` 154 | 155 | 156 | #### Kwarenda o nazwie 6_5(1) 157 | ```sql 158 | SELECT Marki.id_marki 159 | FROM (Marki INNER JOIN Perfumy ON Marki.id_marki = Perfumy.id_marki) INNER JOIN Sklad ON Perfumy.id_perfum = Sklad.id_perfum 160 | GROUP BY Marki.id_marki, Perfumy.rodzina_zapachow; 161 | ``` 162 | 163 | #### Kwarenda o nazwie 6_5(wynik) 164 | ```sql 165 | SELECT [6_5(1)].id_marki, Count(Marki.id_marki) AS PoliczOfid_marki, Marki.nazwa_m 166 | FROM Marki INNER JOIN [6_5(1)] ON Marki.id_marki = [6_5(1)].id_marki 167 | GROUP BY [6_5(1)].id_marki, Marki.nazwa_m 168 | ORDER BY Count(Marki.id_marki); 169 | ``` 170 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze/2020_maj/2020_maj.md: -------------------------------------------------------------------------------- 1 |

11 maj 2020

2 | 3 | [SPIS ARKUSZY](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze.md) --- [PLIKI](https://github.com/wernexnrs/MATURA-INFORMATYKA/tree/master/dzialy/zadania_arkusze/2020_maj) 4 | 5 | ## 1.2 i 1.3 6 | 7 | ```py 8 | n = 3 9 | k = 0 10 | 11 | A = [5, 7, 9] 12 | B = [5, 7, 9] 13 | 14 | 15 | def czy_k_podobne(n, A, B, k): 16 | for i in range(k): 17 | 18 | if A[i] != B[n - k + i]: 19 | return False 20 | 21 | for i in range(n - k): 22 | if B[i] != A[k + i]: 23 | return False 24 | return True 25 | 26 | 27 | def czy_podobne(n, A, B): 28 | for k in range(n): 29 | if czy_k_podobne(n, A, B, k): 30 | return True 31 | return False 32 | 33 | 34 | print(czy_k_podobne(n, A, B, k)) 35 | ``` 36 | 37 | ## 4.1 38 | 39 | ```py 40 | def is_prime(x): 41 | if x > 1: 42 | for i in range(2, x): 43 | if x % i == 0: 44 | return False 45 | return True 46 | return False 47 | 48 | 49 | with open('Dane_PR2\pary.txt') as file: 50 | for line in file: 51 | num, word = line.strip().split() 52 | num = int(num) 53 | if num > 4 and num % 2 == 0: 54 | for j in range(3, num + 1): 55 | if is_prime(j) and is_prime(num - j): 56 | print(num, j, num - j) 57 | break 58 | ``` 59 | 60 | ## 4.2 61 | 62 | ```py 63 | with open("Dane_PR2\pary.txt") as file: 64 | for line in file: 65 | line, slowo = line.strip().split() 66 | res = slowo[0] 67 | longest = slowo[0] 68 | for i in range(1, len(slowo)): 69 | if slowo[i - 1] == slowo[i]: 70 | res += slowo[i - 1] 71 | else: 72 | res = slowo[i] 73 | if len(res) > len(longest): 74 | longest = res 75 | print(longest, len(longest)) 76 | ``` 77 | 78 | ## 4.3 79 | 80 | ```py 81 | lista = [] 82 | 83 | with open("Dane_PR2\pary.txt") as file: 84 | for line in file: 85 | line, slowo = line.strip().split() 86 | line = int(line) 87 | 88 | if line == len(slowo): 89 | lista.append((line, slowo)) 90 | 91 | print(sorted(lista)[0]) 92 | ``` 93 | 94 | ## 6 [[EXCEL] POBIERZ](https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2020_maj/2020_maj_zad.6.xlsx?raw=true) 95 | 96 | ### 6.* 97 | - [Wyjaśnienie](https://www.youtube.com/watch?v=hmjoEGo8ygk&ab_channel=KonradBuzak) 98 | 99 | ### 6.* 100 | - [Wyjaśnienie](https://www.youtube.com/watch?v=01JBCwImCJs&ab_channel=TomaszStypu%C5%82a) 101 | 102 | 103 | ## 5 [[ACCESS] POBIERZ](https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2020_maj/5.accdb?raw=true) 104 | 105 | ### 5.1 106 | - [Wyjaśnienie](https://www.youtube.com/watch?v=sz2J-Oqv8WE&ab_channel=paulinapat96) 107 | 108 | #### Kwarenda o nazwie 5_1 109 | ```sql 110 | SELECT Jezyki.Rodzina, Count(Jezyki.Jezyk) AS PoliczOfJezyk 111 | FROM Jezyki 112 | GROUP BY Jezyki.Rodzina 113 | ORDER BY Count(Jezyki.Jezyk) DESC; 114 | ``` 115 | 116 | ### 5.2 117 | - [Wyjaśnienie](https://www.youtube.com/watch?v=8TdMKctIvXs&list=PLjE1juPSBAT0jo3fbVZP9pzfF4EOROoPR&index=7&ab_channel=paulinapat96) 118 | 119 | #### Kwarenda o nazwie 5_2(1) 120 | ```sql 121 | SELECT Uzytkownicy.Jezyk, Uzytkownicy.Urzedowy 122 | FROM Uzytkownicy 123 | GROUP BY Uzytkownicy.Jezyk, Uzytkownicy.Urzedowy 124 | HAVING (((Uzytkownicy.Urzedowy)="Tak")); 125 | 126 | ``` 127 | 128 | #### Kwarenda o nazwie 5_2(2) 129 | ```sql 130 | SELECT Count([5_2(1)].Urzedowy) AS PoliczOfUrzedowy 131 | FROM [5_2(1)]; 132 | ``` 133 | 134 | #### Kwarenda o nazwie 5_2(3) 135 | ```sql 136 | SELECT Count(Jezyki.Jezyk) AS PoliczOfJezyk 137 | FROM Jezyki; 138 | ``` 139 | 140 | #### Kwarenda o nazwie 5_2(wynik) 141 | ```sql 142 | SELECT [5_2(3)].PoliczOfJezyk, [5_2(2)].PoliczOfUrzedowy, [5_2(3)]![PoliczOfJezyk]-[5_2(2)]![PoliczOfUrzedowy] AS Wynik 143 | FROM [5_2(2)], [5_2(3)]; 144 | ``` 145 | 146 | ### 5.3 147 | - [Wyjaśnienie](https://www.youtube.com/watch?v=rT1fReqmAuQ&list=PLjE1juPSBAT0jo3fbVZP9pzfF4EOROoPR&index=8&ab_channel=paulinapat96) 148 | 149 | #### Kwarenda o nazwie 5_3 150 | ```sql 151 | SELECT Uzytkownicy.Jezyk, Panstwa.Kontynent 152 | FROM Panstwa INNER JOIN (Jezyki INNER JOIN Uzytkownicy ON Jezyki.Jezyk = Uzytkownicy.Jezyk) ON Panstwa.Panstwo = Uzytkownicy.Panstwo 153 | GROUP BY Uzytkownicy.Jezyk, Panstwa.Kontynent; 154 | ``` 155 | 156 | #### Kwarenda o nazwie 5_3(wynik) 157 | ```sql 158 | SELECT [5_3].Jezyk, Count([5_3].Kontynent) AS PoliczOfKontynent 159 | FROM 5_3 160 | GROUP BY [5_3].Jezyk 161 | HAVING (((Count([5_3].Kontynent))>3)); 162 | ``` 163 | 164 | ### 5.4 165 | - [Wyjaśnienie](https://www.youtube.com/watch?v=flYz6rodrCI&list=PLjE1juPSBAT0jo3fbVZP9pzfF4EOROoPR&index=10&ab_channel=paulinapat96) 166 | 167 | #### Kwarenda o nazwie 5_4 168 | ```sql 169 | SELECT Jezyki.Jezyk, Panstwa.Kontynent, Jezyki.Rodzina, Uzytkownicy.Uzytkownicy 170 | FROM Panstwa INNER JOIN (Jezyki INNER JOIN Uzytkownicy ON Jezyki.Jezyk = Uzytkownicy.Jezyk) ON Panstwa.Panstwo = Uzytkownicy.Panstwo 171 | WHERE (((Panstwa.Kontynent) Like "Ameryka*") AND (Not (Jezyki.Rodzina)="indoeuropejska")); 172 | ``` 173 | 174 | #### Kwarenda o nazwie 5_4(wynik) 175 | ```sql 176 | SELECT TOP 6 [5_4].Jezyk, Sum([5_4].Uzytkownicy) AS SumaOfUzytkownicy 177 | FROM 5_4 178 | GROUP BY [5_4].Jezyk 179 | ORDER BY Sum([5_4].Uzytkownicy) DESC; 180 | ``` 181 | 182 | ### 5.5 183 | - [Wyjaśnienie](https://www.youtube.com/watch?v=R_LuOnJxLyE&list=PLjE1juPSBAT0jo3fbVZP9pzfF4EOROoPR&index=6&ab_channel=paulinapat96) 184 | 185 | #### Kwarenda o nazwie 5_5(wynik) 186 | ```sql 187 | SELECT Uzytkownicy.Panstwo, Uzytkownicy.Jezyk, Round([Uzytkownicy]![Uzytkownicy]/[Panstwa]![Populacja]*100,2) AS wynik 188 | FROM Panstwa INNER JOIN (Jezyki INNER JOIN Uzytkownicy ON Jezyki.Jezyk = Uzytkownicy.Jezyk) ON Panstwa.Panstwo = Uzytkownicy.Panstwo 189 | WHERE (((Uzytkownicy.Urzedowy)="nie") AND ((Round([Uzytkownicy]![Uzytkownicy]/[Panstwa]![Populacja]*100,2))>29)); 190 | ``` 191 | 192 | -------------------------------------------------------------------------------- /dzialy/dodatkowe_algorytmy.md: -------------------------------------------------------------------------------- 1 |

Dodatkowe algorytmy

2 | 3 | 1. __algorytmy numeryczne__ 4 | 5 | - ![py] ![noc++] ![nojava] [Suma liczb od a do b](#suma) 6 | - ![py] ![noc++] ![nojava] [Iloczyn liczb od a do b](#iloczyn) 7 | - ![py] ![noc++] ![nojava] [Czy liczba jest parzysta](#even) 8 | - ![py] ![noc++] ![nojava] [Czy liczba jest podzielna przez n bez reszty](#n) 9 | - ![py] ![noc++] ![nojava] [Czy liczba jest wielokrotnością n](#multiple) 10 | - ![nopy] ![noc++] ![nojava] Najwiekszy i najmniejszy element w zbiorze 11 | - ![nopy] ![noc++] ![nojava] Moc liczby 12 | 13 | 2. __algorytmy arytmetyczne__ 14 | 15 | - ![py] ![noc++] ![nojava] [Silnia (n)](#factorial) 16 | - ![py] ![noc++] ![nojava] [Pierwiastek kwadratowy](#sqrt) 17 | - ![py] ![noc++] ![nojava] [Pierwiastek n-tego stopnia](#sqrt2) 18 | - ![py] ![noc++] ![nojava] [Moda](#moda) 19 | - ![py] ![noc++] ![nojava] [Mediana](#med) 20 | - ![py] ![noc++] ![nojava] [Średnia arytmetyczna](#ary) 21 | - ![py] ![noc++] ![nojava] [Średnia ważona](#waz) 22 | - ![py] ![noc++] ![nojava] [Średnia geometryczna](#geo) 23 | - ![py] ![noc++] ![nojava] [Wariancja i odchylenie standardowe](#odchylenie) 24 | - ![nopy] ![noc++] ![nojava] Symbol Newtona 25 | 26 | 3. __algorytmy na łańcuchach__ 27 | 28 | - ![nopy] ![noc++] ![nojava] Zliczanie znaków w ciągu 29 | - ![py] ![noc++] ![nojava] [Zliczanie słów w łańcuchu](#iloscslow) 30 | - ![nopy] ![noc++] ![nojava] Wyszukiwanie najdłuższego słowa w łańcuchu 31 | - ![nopy] ![noc++] ![nojava] Wyszukiwanie najdłuższego wspólnego podłańcucha 32 | - ![nopy] ![noc++] ![nojava] Wyszukiwanie najdłuższego wspólnego podciągu 33 | - ![py] ![noc++] ![nojava] [Krotność znaków w łańcuchu](#kro) 34 | - ![nopy] ![noc++] ![nojava] Naprzemienność dużych i małych liter w tekście 35 | - ![nopy] ![noc++] ![nojava] Algorytm Manachera 36 | - ![nopy] ![noc++] ![nojava] Algorytm N 37 | - ![nopy] ![noc++] ![nojava] Algorytm Knutha-Morrisa-Pratta 38 | - ![nopy] ![noc++] ![nojava] Algorytm Boyer-Moore'a 39 | - ![nopy] ![noc++] ![nojava] Algorytm Galila Seiferasa 40 | - ![nopy] ![noc++] ![nojava] Algorytm Karpa-Rabina 41 | 42 | 4. __kombinatoryka__ 43 | 44 | - ![nopy] ![noc++] ![nojava] Porządek leksykograficzny 45 | - ![nopy] ![noc++] ![nojava] Wyszukiwanie liczby palindromów w tekście 46 | 47 | 5. __geometria__ 48 | 49 | - ![nopy] ![noc++] ![nojava] Wyznaczenie punktów przecięcia okręgu z prostą 50 | - ![nopy] ![noc++] ![nojava] Wyznaczanie punktu przecięcia dwóch prostych 51 | - ![nopy] ![noc++] ![nojava] Przynależność punktu do odcinka 52 | - ![nopy] ![noc++] ![nojava] Przynależność punktu do wielokąta 53 | - ![nopy] ![noc++] ![nojava] Środek odcinka 54 | - ![nopy] ![noc++] ![nojava] Długość odcinka 55 | - ![nopy] ![noc++] ![nojava] Znajdowanie punktu tworzącego figure 56 | - ![nopy] ![noc++] ![nojava] Sprawdzanie czy proste są prostopadłe / równoległe 57 | 58 | ## Czy liczba jest parzysta [⬆️](#main) 59 | 60 |
Rozwiń 61 | 62 | ```python 63 | def is_even(x): 64 | if x % 2 == 0: 65 | return True 66 | return False 67 | ``` 68 |
69 | 70 | ## Czy liczba jest podzielna przez n bez reszty [⬆️](#main) 71 | 72 |
Rozwiń 73 | 74 | ```python 75 | def divisible(x,n): 76 | if x % n == 0: 77 | return True 78 | return False 79 | ``` 80 |
81 | 82 | ## Czy liczba jest wielokrotnością n [⬆️](#main) 83 | 84 |
Rozwiń 85 | 86 | ```python 87 | 88 | def is_multiple2(x,n): 89 | if n % x == 0: 90 | return True 91 | return False 92 | 93 | print(is_multiple(3,333)) 94 | ``` 95 |
96 | 97 | ## Silnia (n) [⬆️](#main) 98 | 99 |
Rozwiń 100 | 101 | ```python 102 | from math import factorial 103 | 104 | print(factorial(5)) 105 | ``` 106 | 107 | ```python 108 | #Iterated version 109 | 110 | def fact(n): 111 | factorial = 1 112 | if n >= 1: 113 | for i in range (1, n + 1): 114 | factorial = factorial * i 115 | return factorial 116 | ``` 117 | 118 | ```python 119 | #Recursive version 120 | 121 | def fact(n): 122 | if n == 1: 123 | return n 124 | elif n < 1: 125 | return None 126 | return n*fact(n-1) 127 | ``` 128 |
129 | 130 | ## Pierwiastek kwadratowy [⬆️](#main) 131 | 132 |
Rozwiń 133 | 134 | ```python 135 | from math import sqrt 136 | 137 | print(sqrt(4)) 138 | ``` 139 | 140 | ```python 141 | #sqrt1(number,stopien) 142 | 143 | def sqrt1(x): 144 | return x ** (1/2) 145 | ``` 146 |
147 | 148 | ## Pierwiastek n-tego stopnia [⬆️](#main) 149 | 150 |
Rozwiń 151 | 152 | ```python 153 | #sqrt1(number,stopien) 154 | 155 | def sqrt1(x,p): 156 | return x ** (1/p) 157 | ``` 158 |
159 | 160 | ## Suma liczb od a do b [⬆️](#main) 161 | 162 |
Rozwiń 163 | 164 | ```python 165 | def suma(a,b): 166 | return sum(range(a, b + 1)) 167 | ``` 168 | 169 | ```python 170 | def suma(a,b): 171 | wynik = 0 172 | for i in range(a, b +1 ): 173 | wynik += i 174 | return wynik 175 | ``` 176 |
177 | 178 | ## Iloczyn liczb od a do b [⬆️](#main) 179 | 180 |
Rozwiń 181 | 182 | ```python 183 | def iloczyn(a,b): 184 | wynik = 1 185 | for i in range(a, b + 1): 186 | wynik *= i 187 | return wynik 188 | ``` 189 |
190 | 191 | ## Krotność np. znaków w ciągu [⬆️](#main) 192 | 193 |
Rozwiń 194 | 195 | ```python 196 | from collections import Counter 197 | 198 | lista_slow = ['nie','zdam','matury'] 199 | 200 | lista_slow = ",".join(lista_slow) 201 | 202 | print(Counter(lista_slow)) 203 | ``` 204 | 205 | ```python 206 | def freq(str): 207 | dict = {} 208 | for n in str: 209 | if n in dict.keys(): 210 | dict[n] += 1 211 | else: 212 | dict[n] = 1 213 | return dict 214 | 215 | print(freq('slowo')) 216 | ``` 217 |
218 | 219 | ## Moda/dominanta [⬆️](#main) 220 | 221 |
Rozwiń 222 | 223 | ```python 224 | from collections import Counter 225 | 226 | lista=[1,2,3,4,5] 227 | 228 | def moda(lista): 229 | if all(i == 1 for i in Counter(lista).values()): 230 | return lista 231 | return Counter(lista).most_common(1)[0][0] 232 | ``` 233 | 234 | ```python 235 | def moda(lista): 236 | return max(set(lista), key = lista.count) 237 | ``` 238 | 239 | ```py 240 | # Na teorię 241 | def moda2(T): 242 | maxi = 0 243 | n = len(T) 244 | for i in range(n): 245 | count = 0 246 | for j in range(n): 247 | if T[i] == T[j]: 248 | count += 1 249 | if count > maxi: 250 | maxi = count 251 | moda = T[i] 252 | return moda 253 | ``` 254 |
255 | 256 | ## Mediana [⬆️](#main) 257 | 258 |
Rozwiń 259 | 260 | ```python 261 | def mediana(lista): 262 | for i in range(len(lista)): 263 | for j in range(len(lista) - i - 1): 264 | if lista[j] > lista[j + 1]: 265 | lista[j + 1], lista[j] = lista[j], lista[j + 1] 266 | 267 | if len(lista) % 2 == 0: 268 | mediana = lista[int(len(lista) / 2)] + lista[int(len(lista) / 2 - 1)] 269 | mediana /= 2 270 | else: 271 | mediana = lista[int(len(lista) / 2)] 272 | return mediana 273 | ``` 274 | 275 | ### Ze wzoru: 276 | ![equation](https://raw.githubusercontent.com/wernexnrs123/MATURA-INFORMATYKA/master/dzialy/images/mediana.png) 277 |
278 | 279 | ## Średnia arytmetyczna [⬆️](#main) 280 | 281 |
Rozwiń 282 | 283 | ```python 284 | def srednia(x): 285 | return sum(x)/len(x) 286 | ``` 287 | 288 | ```python 289 | def srednia(x): 290 | count = 0 291 | licznik = 0 292 | for i in range(len(x)): 293 | count += 1 294 | licznik += x[i] 295 | return licznik/count 296 | ``` 297 | 298 | ### Ze wzoru: 299 | ![equation](https://raw.githubusercontent.com/wernexnrs123/MATURA-INFORMATYKA/master/dzialy/images/srednia.png) 300 |
301 | 302 | ## Średnia ważona [⬆️](#main) 303 | 304 |
Rozwiń 305 | 306 | ```python 307 | def srednia(lista, wagi): 308 | wynik = sum((i * j for i, j in zip(lista, wagi))) / sum(wagi) 309 | return wynik 310 | 311 | ``` 312 | 313 | ```python 314 | def srednia(lista, wagi): 315 | wynik_wagi = 0 316 | wynik = 0 317 | for i in range(len(wagi)): 318 | wynik_wagi += wagi[i] 319 | wynik += lista[i] * wagi[i] 320 | return wynik/wynik_wagi 321 | 322 | ``` 323 | 324 | ### Ze wzoru: 325 | ![equation](https://raw.githubusercontent.com/wernexnrs123/MATURA-INFORMATYKA/master/dzialy/images/srednia_wazona.png) 326 |
327 | 328 | ## Średnia geometryczna [⬆️](#main) 329 | 330 |
Rozwiń 331 | 332 | ```python 333 | def srednia(lista): 334 | wynik = 1 335 | for i in lista: 336 | wynik *= i 337 | wynik = wynik ** (1/len(lista)) 338 | return wynik 339 | ``` 340 | 341 | ### Ze wzoru: 342 | ![equation](https://wikimedia.org/api/rest_v1/media/math/render/svg/d97e78adc3acddf0b54ed5624ab2ceff2057bf40) 343 |
344 | 345 | ## Wariancja i odchylenie standardowe [⬆️](#main) 346 | 347 |
Rozwiń 348 | 349 | ```python 350 | def wariancja(lista): 351 | return sum(i ** 2 for i in lista) / len(lista) - (sum(lista) / len(lista)) ** 2 352 | ``` 353 | 354 | ```python 355 | def srednia(x): 356 | count = 0 357 | licznik = 0 358 | for i in range(len(x)): 359 | count += 1 360 | licznik += x[i] 361 | return licznik / count 362 | 363 | 364 | def wariancja2(lista): 365 | n = 0 366 | suma = 0 367 | for i in range(len(lista)): 368 | n += 1 369 | suma += lista[i] ** 2 370 | return suma / n - srednia(lista) ** 2 371 | ``` 372 | 373 | ### Ze wzoru: 374 | ![equation](https://raw.githubusercontent.com/wernexnrs123/MATURA-INFORMATYKA/master/dzialy/images/wariancja.png) 375 |
376 | 377 | ## Zliczanie słów w łańcuchu [⬆️](#main) 378 | 379 |
Rozwiń 380 | 381 | ```python 382 | slowo = "Ala ma kota" 383 | i = len(slowo.split()) 384 | 385 | print(i) 386 | ``` 387 |
388 | 389 | 390 | [py]: https://img.shields.io/badge/Python-%E2%9C%94-green?style=flat-square&logo=python 391 | [nopy]: https://img.shields.io/badge/Python-%E2%9C%98-red?style=flat-square&logo=python 392 | 393 | [java]: https://img.shields.io/badge/Java-%E2%9C%94-green?style=flat-square&logo=Java&logoColor=yellow 394 | [nojava]: https://img.shields.io/badge/Java-%E2%9C%98-red?style=flat-square&logo=Java&logoColor=yellow 395 | 396 | [c++]: https://img.shields.io/badge/C++-%E2%9C%94-green?style=flat-square&logo=c%2B%2B&logoColor=blue 397 | [noc++]: https://img.shields.io/badge/C++-%E2%9C%98-red?style=flat-square&logo=c%2B%2B&logoColor=blue 398 | -------------------------------------------------------------------------------- /dzialy/biblioteki.md: -------------------------------------------------------------------------------- 1 | ## Wszystkie opisane tu zagadnienia nie są wyczerpaniem tematu. Są to jedynie rzeczy, które moga się przydać. 2 | 3 | # Przydatne moduły 4 | * __collections__ - słowniki 5 | * [Counter()](#counter) 6 | * .elements() 7 | * .most_common() 8 | * .subtract() 9 | * [OrderedDict()](#order) 10 | * __math__ - matematyka 11 | * [funkcje](#funkcje) 12 | * __statistics__ - statystyka 13 | * [funkcje](#statfunc) 14 | * __re__ - RegEX 15 | * [funkcje](#refunc) 16 | * [Metacharacters](#meta) 17 | * [Specjalne sekwencje](#special) 18 | * [Zbiory](#sets) 19 | * [Białe znaki](#biale) 20 | * __fractions__ - ułamki 21 | * [Fraction](#ulamki) 22 | * __itertools__ 23 | * [count](#count) 24 | * [zip_longest](#zip_longest) 25 | * [cycle](#cycle) 26 | * [repeat](#repeat) 27 | * [starmap](#starmap) 28 | * [combinations](#combinations) 29 | * [permutations](#permutations) 30 | * [product](#product) 31 | * [chain](#chain) 32 | * [islice](#islice) 33 | * [accumulate](#accumulate) 34 | * [groupby](#groupby) 35 | * __operator__ 36 | * __functools__ 37 | * __enum__ 38 | 39 | ## collections 40 | ### Counter() [⬆️](#) 41 | 42 | ```python 43 | c = Counter(a=3, b=1) 44 | d = Counter(a=1, b=2) 45 | c + d # dodawanie 46 | #Output: Counter({'a': 4, 'b': 3}) 47 | c - d # odejmowanie, zachowanie tylko dodatnich liczb 48 | #Output:Counter({'a': 2}) 49 | c & d # min każdego klucza 50 | #Output:Counter({'a': 1, 'b': 1}) 51 | c | d # max każdego klucza 52 | #Output:Counter({'a': 3, 'b': 2}) 53 | ``` 54 |
Metody
55 | 56 | * __.elements()__ -> zwraca iteracje kluczy: 'klucz'*vaule 57 | * __.most_common()__ -> zwraca liste krotek malejąca według wartości kluczy 58 | * __.subtract()__ -> zwraca counter jako wynik odejmowania z zachowaniem ujemnych wartości 59 | 60 | ### OrderedDict() [⬆️](#) 61 | Właściwości: 62 | 63 | - Gdy porównamy 2 słowniki klasy dict, które zawierają te same elementy, niezależnie od ich kolejności dostaniemy True. Słowniki klasy OrderedDict do zwrócenia prawdy muszą mieć tą samą kolejność elementów. 64 | 65 | Zwraca podsłownik, którym można zarządzać np.: 66 | ```python 67 | d = collections.OrderedDict() 68 | d['a'] = 'A' 69 | d['b'] = 'B' 70 | d['c'] = 'C' 71 | d['d'] = 'D' 72 | d['e'] = 'E' 73 | 74 | for k, v in d.items(): 75 | print k, v 76 | ''' 77 | Regular dictionary: 78 | a A 79 | c C 80 | b B 81 | e E 82 | d D 83 | 84 | OrderedDict: 85 | a A 86 | b B 87 | c C 88 | d D 89 | e E 90 | ''' 91 | ``` 92 | 93 | ## math 94 | 95 | 96 | ### Funkcje [⬆️](#) 97 | 98 | - __cos(x)__ -> Zwraca cosinus argumentu x. 99 | - __sin(x)__ -> Zwraca sinus argumentu x. 100 | - __tan(x)__ -> Zwraca tangens argumentu x. 101 | - __radians(x)__ -> Przekształca kąt x ze stopni na radiany. 102 | - __degrees(x)__ -> Przekształca kąt x z radianów na stopnie. 103 | - __exp(x)__ -> Zwraca wartość e**x. 104 | - __fabs(x)__ -> Zwraca moduł (wartość bezwzględną) argumentu x. 105 | - __floor(x)__ -> Zwraca quotpodłogę (największą liczbę całkowitą nie większą od) argumentu x w postaci liczby zmiennoprzecinkowej. 106 | - __ceil(x)__ -> Zwraca najmniejszą liczbę całkowitą nie mniejszą od argumentu x w postaci liczby zmiennoprzecinkowej. 107 | - __hypot(x, y)__ -> Zwraca wartość sqrt(x*x + y*y). Jest to długość przeciwprostokątnej w trójkącie prostokątnym o przyprostokątnych, których długości są równe x oraz y, lub odległość punktu (x, y) od środka układu współrzędnych. 108 | - __log(x,y)__ -> Zwraca logarytm o podstawie y argumentu x. 109 | - __log10(x)__ -> Zwraca logarytm o podstawie 10 argumentu x. 110 | - __log2(x)__ -> Zwraca logarytm o podstawie 2 argumentu x. 111 | - __pow(x, y)__ -> Zwraca wartość x**y. 112 | - __sqrt(x)__ -> Zwraca pierwiastek kwadratowy argumentu x. 113 | - __dist()__ -> Zwraca dystans między dwoma punktami 114 | - __factorial()__ -> zwraca silnie 115 | - __fsum()__ -> zwraca sume elementów obiektu 116 | - __prod()__ -> zwraca iloczyn elementów obiektu 117 | - __gcd()__ -> zwraca największy wspólny dzielnik 118 | - __e__ -> zwraca wartość liczby Eulera (2.7182...) 119 | - __pi__ -> zwraca wartość PI (3.1415...) 120 | 121 | 122 | ## statistics 123 | 124 | 125 | ### Funkcje [⬆️](#) 126 | 127 | - __mean()__ -> Średnia arytmetyczna 128 | - __median()__ -> Mediana 129 | - __median_high()__ -> w zbiorze parzystym zwraca większa wartość środkową 130 | - __median_low()__ -> w zbiorze parzystym zwraca mniejsza wartość środkową 131 | - __mode()__ -> moda/dominanta 132 | - __pstdev()__ -> Calculates the standard deviation from an entire population 133 | - __stdev()__ -> Calculates the standard deviation from a sample of data 134 | - __pvariance()__ -> Calculates the variance of an entire population 135 | - __variance()__ -> Calculates the variance from a sample of data 136 | 137 | ## re 138 | 139 | 140 | RegEx w pythonie. 141 | 142 | ### Funkcje [⬆️](#) 143 | 144 | - __findall()__ -> Returns a list containing all matches 145 | - __search()__ -> Returns a Match object if there is a match anywhere in the string 146 | - __split()__ -> Returns a list where the string has been split at each match 147 | - __sub()__ -> Replaces one or many matches with a string 148 | 149 | ### Metacharacters [⬆️](#) 150 | 151 | 152 | | znak | opis | przykład 153 | | :--: | :--: | :--: 154 | | [] | Zbiór znaków | "[a-m]" 155 | | \ | Sygnał specjalnej sekwencji | "\d" 156 | | . | każdy znak oprócz końca linii | "he..o" 157 | | ^ | Zaczyna się od | "^hello" 158 | | $ | Kończy się na | "world$" 159 | | * | Zero or more occurrences | "aix*" 160 | | + | One or more occurrences | "aix+" 161 | | {} | Wystąpnienia danego znaku | "al{2}" 162 | | "|" | to albo to | "falls|stays" 163 | 164 | ### Specjalne sekwencje 165 | 166 | 167 | | znak | opis | przykład 168 | | :--: | :--: | :--: 169 | | \A | Zwraca dopasowanie, jeżeli ciąg jest na początku stringa | "\AThe" 170 | | \b | Zwraca dopasowanie, jeżeli ciąg jest na początku lub na końcu stringa (r - raw string) | r"\bain" r"ain\b" 171 | | \B | Zwraca dopasowanie, jeżeli ciąg jest w stringu lecz nie na końcu ani początku. (r - raw string) | r"\Bain" r"ain\B" 172 | | \d | Zwraca dopasowanie liczb w ciągu | "\d" 173 | | \D | Zwraca dopasowanie, gdzie nie ma liczb | "\D" 174 | | \s | Zwraca dopasowanie białych znaków | "\s" 175 | | \S | Zwraca dopasowanie, gdzie nie ma białych znaków | "\S" 176 | | \w | Zwraca dopasowanie, gdzie ciąg znaków zawiera litery alfabetu angielskiegu, liczby i podłogę | "\w" 177 | | \W | Zwraca dopasowanie gdzie nie ma tego co up | "\W" 178 | | \Z | Zwraca dopasowanie, jeżeli ciąg jest na końcu stringa | "Spain\Z" 179 | 180 | ### Zbiory 181 | 182 | 183 | | zbiór | opis 184 | | :--: | :--: 185 | | [arn] | Zwraca dopasowanie gdzie jakis z elementów znajduje się w stringu 186 | | [a-n] | Zwraca dopasowanie wszystkiego co ma małe litery od a do n 187 | | [^arn] | Wszystko bez wymienionych 188 | | [0123] | Zwraca dopasowanie wymienionych liczb 189 | | [0-9] | Zwraca dopasowanie liczb od 0 do 9 190 | | [0-5][0-9] | zwraca wszystko od 00 do 59 191 | | [a-zA-Z] | Zwraca wszsytko co w alfabecie czy duże czy małe 192 | | [+] | Zwraca szukane znaki tutaj + 193 | 194 | ### Białe znaki 195 | 196 | | znak | opis 197 | | :--: | :--: 198 | | \' | Pojedyńczy cytat 199 | | \\ | Backslash 200 | | \n | enter 201 | | \r | Carriage Return 202 | | \t | tabulator 203 | | \b | Backspace 204 | | \f | Form Feed 205 | | \ooo | liczba ósemkowa 206 | | \xhh | liczba szesnastkowa 207 | 208 | ## fractions [⬆️](#) 209 | 210 | 211 | class fractions.Fraction(numerator=0, denominator=1) 212 | 213 | ```python 214 | from fractions import Fraction 215 | Fraction(16, -10) 216 | #Fraction(-8, 5) 217 | >>> Fraction(123) 218 | #Fraction(123, 1) 219 | >>> Fraction() 220 | #Fraction(0, 1) 221 | >>> Fraction('3/7') 222 | #Fraction(3, 7) 223 | >>> Fraction(' -3/7 ') 224 | #Fraction(-3, 7) 225 | ``` 226 | 227 | ## itertools [⬆️](#) 228 | 229 | 230 | ### count() 231 | ```python 232 | data = [100,200,300,400] 233 | 234 | data2 = list(zip(itertools.count(start = 0, step = 1), data)) 235 | 236 | #Output: [(0, 100), (1, 200), (2, 300), (3,400)] 237 | ``` 238 | 239 | ### zip_longest() 240 | 241 | 242 | zip -> iteruje tyle razy ile wynosi długość krótszego obiektu 243 | 244 | zip_longest -> iteruje tyle razy ile wynosi długość dłuższego obiektu 245 | 246 | ```python 247 | #normal zip 248 | 249 | data = [100,200,300,400] 250 | 251 | data2 = list(zip(range(10), data)) 252 | 253 | #Output: [(0, 100), (1, 200), (2, 300), (3,400)] 254 | ``` 255 | 256 | ```python 257 | #itertools zip 258 | 259 | data = [100,200,300,400] 260 | 261 | data2 = list(itertools.zip_longest(range(10), data)) 262 | 263 | #Output: [(0, 100), (1, 200), (2, 300), (3, 400), (4, None), (5, None), (6, None), (7, None), (8, None), (9, None)] 264 | ``` 265 | 266 | ### cycle() 267 | 268 | 269 | ```python 270 | data = itertools.cycle([0,1]) 271 | 272 | for _ in range(6): 273 | print(next(data)) 274 | 275 | #Output: 0 1 0 1 0 1 276 | ``` 277 | 278 | ### repeat() 279 | 280 | 281 | ```python 282 | data = itertools.repeat(2, times=3) 283 | 284 | for _ in range(6): 285 | print(next(data)) 286 | 287 | #Output: 2 2 2 StopIteration 288 | 289 | print(list(map(pow, range(5), itertools.repeat(2))) 290 | 291 | # Output: [0, 1, 4, 9, 16] 292 | ``` 293 | 294 | ### starmap() 295 | 296 | 297 | ```python 298 | 299 | print(list(itertools.starmap(pow, [(0,2), (1,2), (2,2)] ))) 300 | 301 | # Output: [0, 1, 4] 302 | ``` 303 | 304 | ### combinations() 305 | 306 | 307 | Wszystkie możliwe sposoby na zgrupowanie pewnej ilości znaków, gdzie kolejność nie ma znaczenia. 308 | 309 | ```python 310 | chars = ['a', 'b', 'c', 'd'] 311 | 312 | result = itertools.combinations(chars, 2) 313 | 314 | for i in result: 315 | print(i) 316 | ''' 317 | ('a', 'b') nie ma powtórzeń np ('b', 'a') bo to to samo 318 | ('a', 'c') 319 | ('a', 'd') 320 | ('b', 'c') 321 | ('b', 'd') 322 | ('c', 'd') 323 | ''' 324 | ``` 325 | 326 | ### permutations() 327 | 328 | 329 | Wszystkie możliwe sposoby na zgrupowanie pewnej ilości znaków, gdzie kolejność MA znaczenie. 330 | 331 | ```python 332 | chars = ['a', 'b', 'c', 'd'] 333 | 334 | result = itertools.permutations(chars, 2) 335 | 336 | for i in result: 337 | print(i) 338 | ''' 339 | ('a', 'b') 340 | ('a', 'c') 341 | ('a', 'd') 342 | ('b', 'a') 343 | ('b', 'c') 344 | ('b', 'd') 345 | ('c', 'a') 346 | ('c', 'b') 347 | ('c', 'd') 348 | ('d', 'a') 349 | ('d', 'b') 350 | ('d', 'c') 351 | ''' 352 | ``` 353 | 354 | ### product() 355 | 356 | 357 | Wszystkie możliwe sposoby na zgrupowanie pewnej ilości liczb, gdzie kolejność MA znaczenie wraz z powtórzeniami tych znaków. 358 | 359 | ```python 360 | numbers = [0, 1, 2, 3] 361 | 362 | result = itertools.product(numbers, repeat=2) 363 | 364 | for i in result: 365 | print(i) 366 | ''' 367 | (0, 0) 368 | (0, 1) 369 | (1, 0) 370 | (1, 1) 371 | ''' 372 | ``` 373 | 374 | ### chain() 375 | 376 | 377 | Iteracja po kilku obiektach na raz 378 | 379 | ```python 380 | numbers = [0, 1, 2, 3] 381 | chars = ['a', 'b', 'c', 'd'] 382 | es = ['first', 'second', 'third', 'fourth'] 383 | 384 | result = itertools.chain(numbers, chars, es) 385 | 386 | for i in result: 387 | print(i) 388 | ''' 389 | 0 390 | 1 391 | 2 392 | 3 393 | a 394 | b 395 | c 396 | d 397 | first 398 | second 399 | third 400 | fourth 401 | ''' 402 | ``` 403 | 404 | ### islice() 405 | 406 | 407 | Slice obiektu bez wykorzystywania kopii jak np podczas krojenia list. 408 | 409 | ```python 410 | # islice(object,start,stop,step) 411 | result = itertools.islice(range(10), 1, 5, 2) 412 | 413 | for i in result: 414 | print(i) 415 | ''' 416 | 1 417 | 3 418 | ''' 419 | ``` 420 | 421 | ### accumulate() 422 | 423 | 424 | Operacje podczas iteracji 425 | 426 | ```python 427 | import itertools, operator 428 | 429 | numbers = [1, 5, 4, 3] 430 | 431 | print(list(itertools.accumulate(numbers))) # [1, 6, 10, 13], dodawanie 432 | print( list(itertools.accumulate(numbers, operator.mul))) # [1, 5, 20, 60], mnożenie 433 | ``` 434 | 435 | ### groupby() 436 | 437 | 438 | Grupowanie obiektów. 439 | 440 | Obiekt musi być posortowany po grupowanej wartości inaczej dane te zostaną pominiete. 441 | 442 | ```python 443 | itertools.groupby(object,key) # moze kiedys 444 | ``` 445 | -------------------------------------------------------------------------------- /dzialy/zadania_arkusze.md: -------------------------------------------------------------------------------- 1 |

Zadania z arkuszy

2 | 3 | ## Zbiór zadań od CKE - > Arkusz -- dane -- rozwiązania CPP 4 | 5 | - ![py] ![c++] ![nojava] [Zadanie 58. Systemy liczbowe - str. 106](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_zbior/58.md) 6 | 7 | - ![py] ![c++] ![nojava] [Zadanie 59. Ciekawe liczby - str. 112](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_zbior/59.md) 8 | 9 | - ![py] ![c++] ![nojava] [Zadanie 60. Dzielniki - str. 117](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_zbior/60.md) 10 | 11 | - ![py] ![c++] ![nojava] [Zadanie 61. Ciągi arytmetyczne - str. 118](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_zbior/61.md) 12 | 13 | - ![py] ![c++] ![nojava] [Zadanie 62. Liczby ósemkowe - str. 119](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_zbior/62.md) 14 | 15 | - ![notpy] ![c++] ![nojava] [Zadanie 63. Ciągi zerojedynkowe - str. 120](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_zbior/63.md) 16 | 17 | - ![notpy] ![c++] ![nojava] [Zadanie 64. Obrazki - str.121](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_zbior/64.md) 18 | 19 | ## Matura 20 | 21 | - ![py] ![excel] ![access] ![noc++] ![nojava] [11 maja 2020 r.](https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2020_maj/2020_maj.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-informatyka-2020-czerwiec-poziom-rozszerzony/) 22 | 23 | - ![py] ![noexcel] ![access] ![noc++] ![nojava] [7 czerwca 2019 r.](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2019_czerwiec/2019_czerwiec.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-informatyka-2019-czerwiec-poziom-rozszerzony/) 24 | 25 | - ![notpy] ![excel] ![access] ![noc++] ![nojava] [13 maja 2019](https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2019_maj/2019_maj.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-informatyka-2019-maj-poziom-rozszerzony/) 26 | 27 | - ![py] ![noexcel] ![noaccess] ![noc++] ![nojava] [7 czerwca 2018](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2018_czerwiec.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-informatyka-2018-czerwiec-poziom-rozszerzony/) 28 | 29 | - ![py] ![excel] ![access] ![noc++] ![nojava] [11 maja 2018](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2018_maj/2018_maj.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-informatyka-2018-maj-poziom-rozszerzony/) 30 | 31 | - ![py] ![noexcel] ![noaccess] ![noc++] ![nojava] [6 czerwca 2017](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2017_czerwiec.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-informatyka-2017-czerwiec-poziom-rozszerzony/) 32 | 33 | - ![notpy] ![noexcel] ![noaccess] ![noc++] ![nojava] [Maj 2017](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2017_maj.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-informatyka-2017-maj-poziom-rozszerzony/) 34 | 35 | - ![py] ![noexcel] ![noaccess] ![noc++] ![nojava] [Maj 2017 Matura stara](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2017_maj_stare.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-stara-informatyka-2017-maj-poziom-rozszerzony/) 36 | 37 | - ![py] ![noexcel] ![noaccess] ![noc++] ![nojava] [Czerwiec 2016](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2016_czerwiec.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-informatyka-2016-czerwiec-poziom-rozszerzony/) 38 | 39 | - ![py] ![noexcel] ![noaccess] ![noc++] ![nojava] [Maj 2016](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2016_maj.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-informatyka-2016-maj-poziom-rozszerzony/) 40 | 41 | - ![notpy] ![noexcel] ![noaccess] ![noc++] ![nojava] [Maj 2016 Matura stara](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2016_maj_stare.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-stara-informatyka-2016-maj-poziom-rozszerzony/) 42 | 43 | - ![py] ![noexcel] ![noaccess] ![noc++] ![nojava] [Czerwiec 2015](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2015_czerwiec.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-informatyka-2015-czerwiec-poziom-rozszerzony/) 44 | 45 | - ![py] ![noexcel] ![noaccess] ![noc++] ![nojava] [Maj 2015](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2015_maj.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-informatyka-2015-maj-poziom-rozszerzony/) 46 | 47 | - ![notpy] ![noexcel] ![noaccess] ![noc++] ![nojava] [Maj 2015 Matura stara](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2015_maj_stare.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-stara-informatyka-2015-maj-poziom-rozszerzony/) 48 | 49 | - ![py] ![noexcel] ![noaccess] ![noc++] ![nojava] [Maj 2014](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2014_maj.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-informatyka-2014-maj-poziom-rozszerzony/) 50 | 51 | - ![py] ![noexcel] ![noaccess] ![noc++] ![nojava] [Maj 2013](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2013_maj.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-informatyka-2013-maj-poziom-rozszerzony/) 52 | 53 | - ![notpy] ![noexcel] ![noaccess] ![noc++] ![nojava] [Maj 2012](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2012_maj.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-informatyka-2012-maj-poziom-rozszerzony/) 54 | 55 | - ![py] ![noexcel] ![noaccess] ![noc++] ![nojava] [Maj 2011](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2011_maj.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-informatyka-2011-maj-poziom-rozszerzony/) 56 | 57 | - ![py] ![noexcel] ![noaccess] ![noc++] ![nojava] [Maj 2010](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2010_maj.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-informatyka-2010-maj-poziom-rozszerzony/) 58 | 59 | - ![notpy] ![noexcel] ![noaccess] ![noc++] ![nojava] [Maj 2009](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2009_maj.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-informatyka-2009-maj-poziom-rozszerzony/) 60 | 61 | - ![notpy] ![noexcel] ![noaccess] ![noc++] ![nojava] [Maj 2008](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2008_maj.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-informatyka-2008-maj-poziom-rozszerzony/) 62 | 63 | - ![notpy] ![noexcel] ![noaccess] ![noc++] ![nojava] [Maj 2007](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2007_maj.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-informatyka-2007-maj-poziom-rozszerzony/) 64 | 65 | - ![notpy] ![noexcel] ![noaccess] ![noc++] ![nojava] [Maj 2006](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2006_maj.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-informatyka-2006-maj-poziom-rozszerzony/) 66 | 67 | - ![notpy] ![noexcel] ![noaccess] ![noc++] ![nojava] [Maj 2005](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2005_maj.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-informatyka-2005-maj-poziom-rozszerzony/) 68 | 69 | ## Matura próbna 70 | 71 | - ![py] ![noexcel] ![noaccess] ![noc++] ![nojava] [Marzec 2021 Matura próbna](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2021_marzec_pr.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-probna-informatyka-2021-marzec-poziom-rozszerzony/) 72 | 73 | - ![py] ![noexcel] ![noaccess] ![noc++] ![nojava] [Kwiecień 2020 Matura próbna](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2020_kwiecien_pr.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-probna-informatyka-2020-kwiecien-poziom-rozszerzony/) 74 | 75 | - ![notpy] ![noexcel] ![noaccess] ![noc++] ![nojava] [Grudzień 2014 Matura Przykładowa](https://github.com/wernexnrs123/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2014_grudzien_pr.md) --- [POBIERZ ARKUSZ](https://drive.google.com/file/d/1093cRHeTPFGILJO-iSE-Owjsd-bX10ij/view?usp=sharing) 76 | 77 | - ![py] ![noexcel] ![noaccess] ![noc++] ![nojava] [6 kwietnia 2021 r.](https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2021_kwiecen/2021_kwiecien.md) --- [POBIERZ ARKUSZ](https://drive.google.com/file/d/1jRFgzeqdPOqBCcRVf907akEmmPQj88Qc/view?usp=sharing) 78 | 79 | ## Matura Podstawowa 80 | 81 | - ![py] ![noexcel] ![noaccess] ![noc++] ![nojava] [Maj 2017](https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2017_maj_podstawa/2017_maj_podstawa.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-stara-informatyka-2017-maj-poziom-podstawowy/) 82 | 83 | - ![py] ![noexcel] ![noaccess] ![noc++] ![nojava] [Maj 2016](https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2016_maj_podstawa/2016_maj_podstawa.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-stara-informatyka-2016-maj-poziom-podstawowy/) 84 | 85 | - ![py] ![noexcel] ![noaccess] ![noc++] ![nojava] [Maj 2015](https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2015_maj_podstawa/2015_maj_podstawa.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-stara-informatyka-2015-maj-poziom-podstawowy/) 86 | 87 | - ![py] ![noexcel] ![noaccess] ![noc++] ![nojava] [Maj 2014](https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2014_maj_podstawa/2014_maj_podstawa.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-informatyka-2014-maj-poziom-podstawowy/) 88 | 89 | - ![py] ![noexcel] ![noaccess] ![noc++] ![nojava] [Maj 2013](https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2013_maj_podstawa/2013_maj_podstawa.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-informatyka-2013-maj-poziom-podstawowy/) 90 | 91 | - ![py] ![noexcel] ![noaccess] ![noc++] ![nojava] [Maj 2012](https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2012_maj_podstawa/2012_maj_podstawa.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-informatyka-2012-maj-poziom-podstawowy/) 92 | 93 | - ![py] ![noexcel] ![noaccess] ![noc++] ![nojava] [Maj 2011](https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2011_maj_podstawa/2011_maj_podstawa.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-informatyka-2011-maj-poziom-podstawowy/) 94 | 95 | - ![py] ![noexcel] ![noaccess] ![noc++] ![nojava] [Maj 2010](https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2010_maj_podstawa/2010_maj_podstawa.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-informatyka-2010-maj-poziom-podstawowy/) 96 | 97 | - ![py] ![noexcel] ![noaccess] ![noc++] ![nojava] [Maj 2009](https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze/2009_maj_podstawa/2009_maj_podstawa.md) --- [POBIERZ ARKUSZ](https://arkusze.pl/matura-informatyka-2009-maj-poziom-podstawowy/) 98 | 99 | [py]: https://img.shields.io/badge/Python-%E2%9C%94-green?style=flat-square&logo=python 100 | [notpy]: https://img.shields.io/badge/Python-%E2%9C%98-red?style=flat-square&logo=python 101 | 102 | [excel]: https://img.shields.io/badge/Excel-%E2%9C%94-green?style=flat-square&logo=Microsoft-Excel&logoColor=green 103 | [noexcel]: https://img.shields.io/badge/Excel-%E2%9C%98-red?style=flat-square&logo=Microsoft-Excel&logoColor=green 104 | 105 | [access]: https://img.shields.io/badge/Access-%E2%9C%94-green?style=flat-square&logo=Microsoft-Access&logoColor=red 106 | [noaccess]: https://img.shields.io/badge/Access-%E2%9C%98-red?style=flat-square&logo=Microsoft-Access&logoColor=red 107 | 108 | [java]: https://img.shields.io/badge/Java-%E2%9C%94-green?style=flat-square&logo=Java&logoColor=yellow 109 | [nojava]: https://img.shields.io/badge/Java-%E2%9C%98-red?style=flat-square&logo=Java&logoColor=yellow 110 | 111 | [c++]: https://img.shields.io/badge/C++-%E2%9C%94-green?style=flat-square&logo=c%2B%2B&logoColor=blue 112 | [noc++]: https://img.shields.io/badge/C++-%E2%9C%98-red?style=flat-square&logo=c%2B%2B&logoColor=blue 113 | -------------------------------------------------------------------------------- /docs/README.md: -------------------------------------------------------------------------------- 1 | ## 📊 Repository Stats 2 | 3 |

4 | 5 | 6 | 7 | 8 |

9 | 10 |

11 | 12 | 13 | 14 |

15 | 16 |

17 | 18 | 19 | 20 | 21 |

22 | 23 |

MATURA 2021

24 | 25 |

Projekt powstał w celu zgromadzenia pomocnych zagadnień na mature rozszerzoną z informatyki.
26 | Algorytmy wymienione w wymaganiach przez CKE są jedynie przykładem.
27 | Polecam ciemny motyw github'a

28 | 29 | ### Serwery Discord 30 | - [![_do-matury]][do-matury] 31 | Wspólna nauka do matury, nie tylko z informatyki 32 | 33 | - [![_ee08]][ee08] 34 | Przygotowanie do egzaminów zawodowych EE.08 i EE.09 35 | 36 | ### Zachęcam: 37 | - Rozwiązania arkuszy - [TUTAJ](https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze.md) 38 | - Lista algorytmów wymienionych przez CKE - [TUTAJ](https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/dzialy/algorytmy_wymagania.md) 39 | - Listy dodatkowych algorytmów - [TUTAJ](https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/dzialy/dodatkowe_algorytmy.md) 40 | 41 | ## Przydatne linki 42 | 43 | * [Pixel48/getLearn](https://github.com/Pixel48/getLearn) - opracowane przez społeczność materiały do nauki 44 | * [POLSKI SPOJ](https://pl.spoj.com/) - pełno problemów algorytmicznych do rozwiązania 45 | * [Wymagania maturalne na rok 2021](http://cke.gov.pl/images/_EGZAMIN_MATURALNY_OD_2015/Informatory/2015/aneks/Aneks_2021_informatyka_EM_niewidomi.pdf) 46 | * [Arkusz](https://cke.gov.pl/images/_EGZAMIN_MATURALNY_OD_2015/Materialy/Zbiory_zadan/Matura_Zbi%C3%B3r_zada%C5%84_Informatyka.pdf) -- [dane](https://cke.gov.pl/images/_EGZAMIN_MATURALNY_OD_2015/Materialy/Zbiory_zadan/inf-pr-dane.zip) -- [rozwiązania](https://cke.gov.pl/images/_EGZAMIN_MATURALNY_OD_2015/Materialy/Zbiory_zadan/inf-pr-rozwiazania.zip) - Zadania do ćwiczeń od CKE 47 | * [Wszystkie arkusze](https://arkusze.pl/informatyka-matura-poziom-rozszerzony/) 48 | * [Tutor](http://pythontutor.com/) - wizualizacja kodu 49 | 50 | ## Algorytmika 51 | 52 | * [Algorytmy i struktury danych - mgr. Jerzy Wałaszek](https://eduinf.waw.pl/inf/alg/001_search/index.php) - Pełno algorytmów z opisami i zadań. Ponad program. 53 | * [Algorytmy.edu.pl](http://www.algorytm.edu.pl/algorytmy-maturalne.html) - Niepełna lista algorytmów maturalnych z wyjaśnieniem 54 | * [Algorytm.org](http://www.algorytm.org/algorytmy/) - Lista algorytmów 55 | * [Algorytmy z podstawy programowej](https://www.youtube.com/playlist?list=PLpEP9TjZ__-Ff6YYZSZ0EAd54AdVFXOf5) - YT 56 | * [pl.khanacademy.org](https://pl.khanacademy.org/computing/computer-science/algorithms) - algorytmy z wyjaśnieniami 57 | * [binarnie.pl](https://binarnie.pl/category/matura-z-informatyki-nauka/) - dużo teorii, algorytmów 58 | * [Repozytorium c++/excel](https://github.com/mazxaxz/matura-informatyka-all-in-one) 59 | * [Kanał o wszystkim](https://www.youtube.com/watch?v=uySyv8St9aw&list=PL6aekdNhY7DAK6UraEDhxhMng89wrO9y9) - sortowania 60 | * [Kanał o wszystkim](https://www.youtube.com/watch?v=UFOqUCpAUZY&list=PL6aekdNhY7DCOVVTixns3ZfOfw9xFn-Rx) - Rozwiązania z polskiego Spoja [C#] 61 | * [Rekurencja](https://www.youtube.com/watch?v=Pd7blw4A0qg&list=PLikGmVz62acwbr4aohYmEpv1YX7DWJnmP) - YT 62 | * [Selection sort](https://www.youtube.com/watch?v=Ns4TPTC8whw&list=PLikGmVz62acwaYlZymm3mgPsN9Ogr4m1x) - YT 63 | * [Quick sort](https://www.youtube.com/watch?v=ywWBy6J5gz8&list=PLikGmVz62acx1SbJ8UUYkniRo2HbVpIOw) - YT 64 | * [Merge sort](https://www.youtube.com/watch?v=XaqR3G_NVoo&list=PLikGmVz62acwGzui7mSFReGzpbuF1IPaM) - YT 65 | * [Insertion sort](https://www.youtube.com/watch?v=ROalU379l3U&list=PLikGmVz62acywhDHJy-91TA4HXGc5cqz1) - YT 66 | * [Bubble sort](https://www.youtube.com/watch?v=uJLwnsLn0_Q&list=PLikGmVz62aczkKRmociYK8Uzix1Mnf21p) - YT 67 | 68 | ## EXCEL 69 | 70 | * [Wprowadzenie i troszke teorii](https://www.korepetycjezinformatyki.pl/arkusz-kalkulacyjny/) 71 | * [Podstawowe funkcje](https://calculatic.pl/poradnik/podstawowe-funkcje-excela/) 72 | * [Wszystkie funkcje](https://support.microsoft.com/pl-pl/office/funkcje-programu-excel-wed%C5%82ug-kategorii-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb) 73 | * [Excel i Adam](https://www.youtube.com/playlist?list=PL16E33B75DED3E944) - kurs YT 74 | * [WebCrew Tomasz Jaśniewski](https://www.youtube.com/playlist?list=PLKmH7u1gA9hr0U59uCEDhr_G2Yn2yV0M5) - kurs YT 75 | * [Kanał o wszystkim](https://www.youtube.com/watch?v=msEff53_htw&list=PL6aekdNhY7DAh6BDzprcOWo0qj9J7-vdH) - kurs YT 76 | * [PMSOCHO Piotr Majcher](https://www.youtube.com/channel/UC0v0AUvV3vy0WFTkGl28wMA/videos) - kurs YT 77 | * [Pełno kursów YT](https://www.youtube.com/watch?v=PU8ACyYxJBk&list=PLikGmVz62aczV-1qWC2oQtL_Tod8bkXGv) 78 | * [Jeszcze więcej kursów](https://www.youtube.com/watch?v=tuk99Sgc6Fw&list=PLoyECfvEFOjbdwpIOtm_8PFzB_CPAD2_H) 79 | 80 | ## ACCESS 81 | 82 | * [Informacje](https://support.microsoft.com/pl-pl/access) 83 | * [w3schools - SQL](https://www.w3schools.com/sql/) - Zagadnienia w przystępnej formie 84 | * [Niepełny kurs "do matury"](https://www.youtube.com/playlist?list=PLKmH7u1gA9hpm3ZqWhsn2XvGAeX3b9SM0) 85 | * [Kurs "do matury"](https://www.youtube.com/playlist?list=PLiG7bZwihoShBM1xR0K_st-QyxJyq5iWl) 86 | * [informatykaplus.edu.pl](http://www.informatykaplus.edu.pl/infp.php/bazy_danych_wyklady.html) - wykłady z jakiegoś projektu 87 | * [Kursy YT](https://www.youtube.com/watch?v=vrtNPp2r6qQ&list=PLikGmVz62aczN2wx5NFGtJxRgux0lXuCM) 88 | * [Pasja informatyki](https://www.youtube.com/watch?v=99JAI24Zd24&list=PLOYHgt8dIdoymv-Wzvs8M-OsKFD31VTVZ) - kurs mysql 89 | 90 | ## PYTHON 91 | 92 | * [Algorytmy wymienione w wymaganiach na rok 2021](https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/dzialy/algorytmy_wymagania.md) 93 | * [Rozwiązania zadań z arkuszy i zbiorów zadań](https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/dzialy/zadania_arkusze.md) #zachęcam do wstawiania swoich 94 | * [Dodatkowe algorytmy](https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/dzialy/dodatkowe_algorytmy.md) 95 | * [Najważniejsze funkcje wbudowane](https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/dzialy/funkcje_wbudowane.md) 96 | * [Przydatne moduły](https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/dzialy/biblioteki.md) #to trzeba rozwinąć, nie mam siły 97 | * [Przydatne metody](https://github.com/wernexnrs/MATURA-INFORMATYKA/tree/master/dzialy/metody.md) 98 | * [Dokumentacja pythona](https://docs.python.org/3/) 99 | * [w3schools](https://www.w3schools.com/python/default.asp) - Zagadnienia w przystępnej formie 100 | * [Kanał o wszystkim](https://www.youtube.com/watch?v=vek4MqPGvVU&list=PL6aekdNhY7DBGiMXnmBYjImq_vW32QftK) - kurs python, YT 101 | 102 | ## C++ / Pascal 103 | 104 | * [cpp0x.pl](https://cpp0x.pl/kursy/) - kurs C++ 105 | * [informatykaplus.edu.pl](http://informatykaplus.edu.pl/infp.php/algorytmika_programowanie_kursy.html) - wykłady z jakiegoś projektu 106 | * [Kanał o wszystkim](https://www.youtube.com/watch?v=cMtg4bpKI9w&list=PL6aekdNhY7DAkl9D3i55ppfwOpeSqIsh9) - kurs c++, YT 107 | * [allinonebyplucek.blogspot.com](https://allinonebyplucek.blogspot.com/p/informatyka-c.html) - skrót teorii do c++ 108 | * [Pasja informatyki](https://www.youtube.com/watch?v=ErOzmh3BiXU&list=PLOYHgt8dIdoxx0Y5wzs7CFpmBzb40PaDo) - kurs C++ 109 | 110 | ## Rozwiązania zadań maturalnych 111 | 112 | * [Konrad Buzak](https://www.youtube.com/user/genek72gmail/videos) - YT 113 | * [infomatura](https://www.youtube.com/channel/UClzG_Qs0EPVJnbPEoVuDrZA/videos) - YT 114 | * [codeminator](https://www.youtube.com/channel/UC_2wsz5jrtHBixjGTKupBSg/videos) - YT 115 | * [encodeme](https://www.youtube.com/channel/UCAgkC-bNToPAUqHZXRCuUUA/videos) - YT 116 | * [Małgorzata Piekarska](https://www.youtube.com/channel/UCdQEVPEepyZC0ewLTNrknOA/videos) - Rozwiązania z zakresu SQL, Access, Excel 117 | * [Matura export](https://www.youtube.com/channel/UCXgCS0R1YH60P51jkrq1FsQ/playlists) - YT 118 | * [maturainformatyka.buz.info.pl](https://maturainformatyka.buz.info.pl/) - zadania z arkuszy z wyjaśnieniami na yt, gorąco polecam 119 | * [informatura.pl](http://informatura.pl/rozwiazania) - Rozwiązania zadań z arkuszy 120 | * [Jack477](https://github.com/Jack477/Arkusze_informatyka_Python) - Rozwiązania arkuszy na GitHub 121 | 122 | ## Licencja 123 | Projekt objęty jest licencją [GNU GPL 3](https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/LICENSE) 124 | 125 | [contributors-shield]: https://img.shields.io/github/contributors/wernexnrs/MATURA-INFORMATYKA.svg?style=for-the-badge 126 | [contributors-url]: https://github.com/wernexnrs/MATURA-INFORMATYKA/graphs/contributors 127 | 128 | [forks-shield]: https://img.shields.io/github/forks/wernexnrs/MATURA-INFORMATYKA.svg?style=for-the-badge 129 | [forks-url]: https://github.com/wernexnrs/MATURA-INFORMATYKA/network/members 130 | 131 | [stars-shield]: https://img.shields.io/github/stars/wernexnrs/MATURA-INFORMATYKA.svg?style=for-the-badge 132 | [stars-url]: https://github.com/wernexnrs/MATURA-INFORMATYKA/stargazers 133 | 134 | [issues-shield]: https://img.shields.io/github/issues/wernexnrs/MATURA-INFORMATYKA.svg?style=for-the-badge 135 | [issues-url]: https://github.com/wernexnrs/MATURA-INFORMATYKA/issues 136 | 137 | [build-shield]: https://img.shields.io/badge/build-in%20progress-yellow?style=for-the-badge 138 | 139 | [license-shield]: https://img.shields.io/github/license/wernexnrs/MATURA-INFORMATYKA.svg?style=for-the-badge 140 | [license-url]: https://github.com/wernexnrs/MATURA-INFORMATYKA/blob/master/LICENSE 141 | 142 | [_do-matury]: https://shields.io/discord/796048059507015732?label=Do%20matury&logo=discord&style=social&link=https://discord.gg/3hyj3kXQkt 143 | [do-matury]: https://discord.gg/3hyj3kXQkt 144 | 145 | [_ee08]: https://shields.io/discord/723560181996191914?label=EE.08%2FEE.09&logo=discord&style=social&link=https://discord.gg/RJMZQEC 146 | [ee08]: https://discord.gg/RJMZQEC 147 | 148 | [commit]: https://github.com/wernexnrs/MATURA-INFORMATYKA/commit 149 | [commits]: https://github.com/wernexnrs/MATURA-INFORMATYKA/commits/master 150 | 151 | [_commit-activity-m]: https://img.shields.io/github/commit-activity/m/wernexnrs/MATURA-INFORMATYKA.svg?style=for-the-badge 152 | [_commit-activity-w]: https://img.shields.io/github/commit-activity/w/wernexnrs/MATURA-INFORMATYKA.svg?style=for-the-badge 153 | [_commit-activity-y]: https://img.shields.io/github/commit-activity/y/wernexnrs/MATURA-INFORMATYKA.svg?style=for-the-badge 154 | [_contributors]: https://img.shields.io/github/all-contributors/wernexnrs/MATURA-INFORMATYKA.svg?style=for-the-badge 155 | [_last-commit]: https://shields.io/github/last-commit/wernexnrs/MATURA-INFORMATYKA.svg?style=for-the-badge 156 | [_repo-size]: https://shields.io/github/repo-size/wernexnrs/MATURA-INFORMATYKA.svg?style=for-the-badge 157 | [zip]: https://github.com/wernexnrs/MATURA-INFORMATYKA/archive/master.zip 158 | 159 | -------------------------------------------------------------------------------- /dzialy/algorytmy_wymagania.md: -------------------------------------------------------------------------------- 1 | 2 |

Algorytmy wymienione w wymaganiach

3 | 4 | 1. __algorytmy na liczbach całkowitych:__ 5 | - ![py] ![noc++] ![nojava] [reprezentacja liczb w dowolnym systemie pozycyjnym, w tym w dwójkowym i szesnastkowym,](#konwersja) 6 | - ![py] ![noc++] ![nojava] [sprawdzanie, czy liczba jest liczbą pierwszą,](#is_prime) 7 | - ![py] ![noc++] ![nojava] [sprawdzanie, czy liczba jest liczbą doskonała,](#is_perfect) 8 | - ![py] ![noc++] ![nojava] [rozkładanie liczby na czynniki pierwsze,](#prime_factors) 9 | - ![py] ![noc++] ![nojava] [iteracyjna i rekurencyjna realizacja algorytmu Euklidesa + NWW,](#nwd) 10 | - ![py] ![noc++] ![nojava] [iteracyjne i rekurencyjne obliczanie wartości liczb Fibonacciego,](#fib) 11 | - ![py] ![noc++] ![nojava] [wydawanie reszty metodą zachłanną,](#zachlanna) 12 | 13 | 2. __algorytmy wyszukiwania i porządkowania (sortowania):__ 14 | - ![py] ![c++] ![nojava] [bąbelkowy, ](#bob) 15 | - ![py] ![noc++] ![nojava] [przez wybór, ](#wybor) 16 | - ![py] ![noc++] ![nojava] [przez wstawianie liniowe, ](#lin) 17 | - ![py] ![noc++] ![nojava] [przez scalanie,](#scalanie) 18 | - ![py] ![noc++] ![nojava] [szybki,](#fast) 19 | - ![py] ![noc++] ![nojava] [kubełkowy,](#box) 20 | 21 | 3. __algorytmy numeryczne__ 22 | - ![py] ![noc++] ![nojava] [szybkie podnoszenie do potęgi,](#fast_power) 23 | - ![py] ![noc++] ![nojava] [wyznaczanie miejsc zerowych funkcji metodą połowienia,](#bisekcja) 24 | 25 | 4. __algorytmy na tekstach__ 26 | - ![py] ![noc++] ![nojava] [sprawdzanie, czy dany ciąg znaków tworzy palindrom,](#palindrom) 27 | - ![py] ![noc++] ![nojava] [sprawdzanie, czy dany ciąg znaków tworzy anagram,](#anagram) 28 | - ![py] ![noc++] ![nojava] [porządkowanie alfabetyczne, (leksykograficzne)](#alfa) 29 | - ![py] ![noc++] ![nojava] [wyszukiwanie wzorca w tekście,](#pattern) 30 | 31 | 5. __algorytmy kompresji i szyfrowania__ 32 | - kody znaków o zmiennej długości, 33 | * ![py] ![noc++] ![nojava] [Kompresja danych](#len) 34 | * ![py] ![c++] ![nojava] [Alfabet Morse’a](#morse) 35 | - szyfry przestawieniowe, 36 | * ![py] ![noc++] ![nojava] [Transpozycyjny](#przes) 37 | * ![py] ![noc++] ![nojava] [Szyfr AtBash](#atbash) 38 | * ![py] ![c++] ![nojava] [Szyfr Cezara](#cezar) 39 | ### Rzeczy, które nie są zwinięte w jakis sposób potrzebują poprawy 40 | 41 | 42 | ## Reprezentacja liczb w dowolnym systemie pozycyjnym, w tym w dwójkowym i szesnastkowym [⬆️](#) 43 |
Rozwiń 44 | 45 | ```python 46 | #int("number_string",base) ANY --> DEC 47 | 48 | dec_numbers = [15, 12, 2, 4, 7, 8] 49 | 50 | dec_TO_bin = [bin(i)[2:] for i in dec_numbers] 51 | dec_TO_oct = [oct(i)[2:] for i in dec_numbers] 52 | dec_TO_hex = [hex(i)[2:] for i in dec_numbers] 53 | 54 | bin_TO_dec = [int(i, 2) for i in dec_TO_bin] 55 | oct_TO_dec = [int(i, 8) for i in dec_TO_oct] 56 | hex_TO_dec = [int(i, 16) for i in dec_TO_hex] 57 | ``` 58 | 59 | ```python 60 | #recursive one-liner version DEC --> ANY 61 | 62 | BS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" 63 | 64 | 65 | def to_base(n, b): # to_base(number,base) 66 | return BS[n] if n < b else to_base(n // b, b) + BS[n % b] 67 | ``` 68 | 69 | ```python 70 | #recursive version DEC --> ANY 71 | 72 | BS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" 73 | 74 | def to_base(n, b): # to_base(number,base) 75 | if n < b: 76 | return BS[n] 77 | return to_base(n // b, b) + BS[n % b] 78 | ``` 79 | 80 | 81 | ``` 82 | BS -> "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" 83 | 84 | def to_base(n, b): 85 | Jeżeli n < b: 86 | Zwróć BS[n] 87 | W innym wypadku: 88 | Zwróć to_base(n // b, b) + BS[n % b] 89 | ``` 90 | 91 | 92 | ```python 93 | #iterated version with slices DEC --> ANY 94 | 95 | BS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" 96 | 97 | 98 | def to_base(n, b): 99 | res = "" 100 | while n: 101 | res += BS[n % b] 102 | n //= b 103 | return res[::-1] 104 | ``` 105 |
106 | 107 | 108 | ## Sprawdzanie, czy liczba jest liczbą pierwszą [⬆️](#) 109 |
Rozwiń 110 | 111 | ```python 112 | def is_prime(x): 113 | if x <= 1: 114 | return False 115 | for i in range(2, int(x**0.5) + 1): 116 | if x % i == 0: 117 | return False 118 | return True 119 | ``` 120 | 121 | 122 | ``` 123 | Funkcja is_prime(x): 124 | Jeżeli x <= 1 125 | Zwróć Fałsz 126 | Koniec jeżeli 127 | 128 | Dla i od 2 do całkowitej wartości (pierwiastek kwadratowy z x) + 1: 129 | Jeżeli x mod i == 0 130 | Zwróć Fałsz 131 | Koniec jeżeli 132 | Koniec dla 133 | 134 | Zwróć Prawda 135 | Koniec funkcji 136 | ``` 137 | 138 |
139 | 140 | 141 | ## Sprawdzanie, czy liczba jest liczbą doskonała [⬆️](#) 142 |
Rozwiń 143 | 144 | ```python 145 | def is_perfect(n): 146 | s = 1 147 | for i in range(2, n): 148 | if n % i == 0: 149 | s += i 150 | if n == s and n != 1: 151 | return True 152 | return False 153 | ``` 154 | 155 | 156 | ``` 157 | A = [1,2 … n] 158 | 159 | Dla i = 1,2 … n 160 | s <- 1 161 | Dla j = [2, 3, n] 162 | Jeżeli i mod j == 0 163 | s <- s + 1 164 | Jeżeli n == s oraz n != 1 165 | Zwróć Prawde 166 | Zwróć Fałsz 167 | ``` 168 | 169 |
170 | 171 | 172 | ## Rozkładanie liczby na czynniki pierwsze [⬆️](#) 173 |
Rozwiń 174 | 175 | ```python 176 | def prime_factors(n): 177 | k = 2 178 | while n != 1: 179 | while n % k == 0: 180 | n //= k 181 | print(k) # albo do tablicy sobie wrzucać 182 | k += 1 183 | ``` 184 | 185 | 186 | ``` 187 | n = liczba całkowita 188 | div - operator dzielenia całkowitego 189 | 190 | k <- 2 191 | 192 | Dopóki n != 1 193 | Dopóki n mod k == 0 194 | n <- n div k # dzielenie całkowite 195 | Wypisz k 196 | k <- k + 1 197 | ``` 198 | 199 |
200 | 201 | 202 | ## Iiteracyjna i rekurencyjna realizacja algorytmu Euklidesa + NWW [⬆️](#) 203 |
Rozwiń 204 | 205 | ```python 206 | #recursive one-liner version 207 | 208 | def nwd(a, b): return nwd(b, a % b) if b else a 209 | ``` 210 | 211 | ```python 212 | #recursive version 213 | 214 | def nwd(a, b): 215 | if b > 0: 216 | return nwd(b, a % b) 217 | return a 218 | ``` 219 | 220 | 221 | ``` 222 | a - liczba całkowita 223 | b - liczba całkowita 224 | 225 | def nwd(a, b): 226 | Jeżeli b > 0: 227 | Zwróc nwd(b, a % b) 228 | W innym wypadku 229 | Zwróć a 230 | ``` 231 | 232 | 233 | ```python 234 | #iterated version 235 | 236 | def nwd(a, b): 237 | while b: 238 | a, b = b, a % b 239 | return a 240 | ``` 241 | 242 | 243 | ``` 244 | a - liczba całkowita 245 | b - liczba całkowita 246 | 247 | def nwd(a, b): 248 | Dopóki b != 0 249 | t <- a 250 | a <- b 251 | b <- t mod b 252 | Zwróć a 253 | ``` 254 | 255 | 256 | ```python 257 | #Najmniejsza wspólna wielokrotność 258 | 259 | def nww(a, b): return a * b // nwd(a, b) 260 | ``` 261 | 262 | 263 | ``` 264 | a - liczba całkowita 265 | b - liczba całkowita 266 | div - dzielenie całkowite 267 | 268 | def nww(a, b): 269 | Zwróć a * b div nwd(a,b) 270 | ``` 271 | 272 |
273 | 274 | 275 | ## Iteracyjne i rekurencyjne obliczanie wartości liczb Fibonacciego [⬆️](#) 276 |
Rozwiń 277 | 278 | ```python 279 | #Iterated version 280 | 281 | def f(n): 282 | a, b = 0, 1 283 | for i in range(0, n): 284 | a, b = b, a + b 285 | return a 286 | ``` 287 | 288 | 289 | ``` 290 | a <- 0 291 | b <- 1 292 | n - n'ty wyraz ciągu 293 | 294 | Dla i = 1,2 ... n 295 | t <- a 296 | a <- b 297 | b <- t + b 298 | ``` 299 | 300 | 301 | ```python 302 | #Recursive version 303 | 304 | def f(n): 305 | if n <= 1: 306 | return n 307 | return f(n - 1) + f(n - 2) 308 | ``` 309 | 310 | 311 | ``` 312 | def f(n) 313 | Jeżeli n <= 1 314 | Zwróć n 315 | W innym wypadku 316 | Zwróć f(n-1) + f(n-2) 317 | ``` 318 | 319 |
320 | 321 | 322 | ## Wydawanie reszty metodą zachłanną [⬆️](#) 323 |
Rozwiń 324 | 325 | ```python 326 | do_wydania = 6 327 | monety = [1, 2, 5] 328 | 329 | def wydawanie(do_wydania, monety): 330 | count = 0 331 | historia = [] 332 | 333 | while do_wydania > 0: 334 | nominal = 0 335 | for i in range(len(monety)): 336 | if do_wydania >= monety[i] > nominal: 337 | nominal = monety[i] 338 | do_wydania -= nominal 339 | 340 | historia.append(nominal) 341 | count += 1 342 | 343 | return f'Reszte wydasz w {count} monetach, te monety to {historia}' 344 | 345 | print(wydawanie(do_wydania, monety)) 346 | ``` 347 | 348 | 349 | ``` 350 | do_wydania <- 6 351 | monety <- [1, 2, 5] 352 | count <- 0 353 | historia <- [] 354 | 355 | Dopóki do_wydania > 0: 356 | nominal <- 0 357 | 358 | Dla i = 1,2,3, ... , rozmiar tablicy (bedzie podany, najczesciej n) 359 | Jeżeli do_wydania >= monety[i] > nominal: 360 | nominal <- monety[i] 361 | historia[i] <- nominal 362 | do_wydania <- do_wydania - nominal 363 | count <- count + 1 364 | ``` 365 | 366 |
367 | 368 | 369 | ## Sortowanie bąbelkowe [⬆️](#) 370 | 371 |
Rozwiń C++ 372 | 373 | ```cpp 374 | void babelkowe(int* tab, int rozmiar) { 375 | int k { 0 }; 376 | 377 | for (int i = 0; i < rozmiar; i++) { 378 | for (int j = 0; j < rozmiar - i - 1; j++) { 379 | if (tab[j] < tab[j + 1]) { 380 | k = tab[j + 1]; 381 | tab[j + 1] = tab[j]; 382 | tab[j] = k; 383 | } 384 | } 385 | } 386 | 387 | for (int i = 0; i < rozmiar; i++) cout << tab[i] << " "; 388 | } 389 | ``` 390 |
391 | 392 |
Rozwiń Python 393 | 394 | ```python 395 | #In place 396 | 397 | def bubble_sort(tab): 398 | for i in range(len(tab)): 399 | for j in range(len(tab) - i - 1): 400 | if tab[j] > tab[j + 1]: 401 | tab[j + 1], tab[j] = tab[j], tab[j + 1] 402 | ``` 403 | 404 | 405 | ``` 406 | A = [1,2 … n] 407 | 408 | Dla i = 1,2 … n 409 | Dla j = 1,2 ... n – i – 1 410 | Jeżeli A[j] > A[j + 1] 411 | t <- A[j + 1] 412 | A[j + 1] <- A[j] 413 | A[j] <- t 414 | ``` 415 | 416 | ```py 417 | # Wersja zoptymalizowana 418 | arr = [1,1,1,1,1,1,2] 419 | 420 | 421 | def swap(arr,x,y): #to albo swap jak wyżej 422 | temp = arr[x] 423 | arr[x] = arr[y] 424 | arr[y] = temp 425 | 426 | def bubblesort(arr): 427 | 428 | for i in range(len(arr)): 429 | issorted = True 430 | for j in range(1,len(arr)-i): 431 | if arr[j] < arr[j-1]: 432 | swap(arr,j ,j-1) 433 | issorted = False 434 | if issorted: 435 | break 436 | 437 | bubblesort(arr) 438 | print(arr) 439 | ``` 440 | 441 |
442 | 443 | 444 | ## Sortowanie przez wybór [⬆️](#) 445 |
Rozwiń 446 | 447 | ```python 448 | #In place 449 | 450 | def selection_sort(tab): 451 | for i in range(len(tab)): 452 | mini = i 453 | for j in range(i+1, len(tab)): 454 | if tab[mini] > tab[j]: 455 | mini = j 456 | tab[i], tab[mini] = tab[mini], tab[i] 457 | ``` 458 | 459 | 460 | ``` 461 | A <- [1,2 … n] 462 | n <- ilość liczb 463 | 464 | Dla i = 1,2 … n 465 | mini = i 466 | Dla j = i + 1, ... n 467 | Jeżeli A[mini] > A[j] 468 | mini <- j 469 | t <- A[i] 470 | A[i] <- A[mini] 471 | A[mini] <- t 472 | ``` 473 | 474 |
475 | 476 | 477 | ## Sortowanie przez wstawianie liniowe [⬆️](#) 478 |
Rozwiń 479 | 480 | ```python 481 | #In place 482 | 483 | def insertion_sort(A): 484 | for i in range(1, len(A)): 485 | liczba = A[i] 486 | 487 | while i > 0 and A[i - 1] > liczba: 488 | A[i] = A[i - 1] 489 | i -= 1 490 | A[i] = liczba 491 | ``` 492 | 493 | 494 | ``` 495 | n <- liczba całkowita 496 | A <- [1,2 ... n] 497 | 498 | Dla i = 1, 2, ... , n 499 | liczba <- A[i] 500 | 501 | Dopóki i > 0 oraz A[i - 1] > liczba 502 | A[i] <- A[i - 1] 503 | i <- i - 1 504 | A[i] <- liczba 505 | ``` 506 | 507 |
508 | 509 | 510 | ## Sortowanie przez scalanie [⬆️](#) 511 |
Rozwiń 512 | 513 | ```python 514 | #In place 515 | 516 | def merge_sort(tab): 517 | if len(tab) < 2: 518 | return tab 519 | 520 | i = j = k = 0 521 | mid = len(tab) // 2 522 | L, R = tab[:mid], tab[mid:] 523 | merge_sort(L) 524 | merge_sort(R) 525 | 526 | while i < len(L) and j < len(R): 527 | if L[i] < R[j]: 528 | tab[k] = L[i] 529 | i += 1 530 | else: 531 | tab[k] = R[j] 532 | j += 1 533 | k += 1 534 | 535 | while i < len(L): 536 | tab[k] = L[i] 537 | i += 1 538 | k += 1 539 | 540 | while j < len(R): 541 | tab[k] = R[j] 542 | j += 1 543 | k += 1 544 | ``` 545 | 546 | 547 | ``` 548 | n <- długość tablicy 549 | div <- dzielenie całkowite 550 | len() <- długość obiektu 551 | mid <- n // 2 552 | // -> operator dzielenia całkowitego 553 | 554 | def merge_sort(tab): 555 | Jeżeli n < 2: 556 | Zwróć tab 557 | i <- 0 558 | j <- 0 559 | k <- 0 560 | 561 | L <- tab[:mid] 562 | R <- tab[mid:] 563 | merge_sort(L) 564 | merge_sort(R) 565 | 566 | Dla i = 1, 2, .. 567 | 568 | Dopóki i < len(L) oraz j < len(R) 569 | Jeżeli L[i] < R[i] 570 | i <- i + 1 571 | k <- k + 1 572 | 573 | Dopóki i < len(L) 574 | tab[k] = L[i] 575 | i <- i + 1 576 | k <- k + 1 577 | 578 | Dopóki j < len(R) 579 | tab[k] = R[j] 580 | j <- j + 1 581 | k <- k + 1 582 | ``` 583 | 584 |
585 | 586 | 587 | ## Sortowanie szybkie [⬆️](#) 588 |
Rozwiń 589 | 590 | ```python 591 | def quicksort(t): 592 | # jeżeli tablica jest pusta lub ma jeden element, to nie trzeba nic robić, można ją zwrócić. 593 | if len(t) <= 1: 594 | return t 595 | 596 | # wybierasz pivot (tutaj na końcu) 597 | pivot = t[-1] 598 | smaller = [] 599 | greater = [] 600 | 601 | # wszystkie mniejsze lub równe wartości od pivota idą do listy smaller a większe do greater. 602 | # len(t) - 1, bo pracujemy na elementach bez ostatniego, którym jest pivot. 603 | for i in range(0, len(t) - 1): 604 | if t[i] <= pivot: 605 | smaller.append(t[i]) 606 | else: 607 | greater.append(t[i]) 608 | 609 | # zwracasz tablicę, gdzie wszystkie mniejsze wartości są po lewej, a większe po prawej od pivota, 610 | # a pivot trafia na miejsce końcowe w tablicy wyjściowej. 611 | return quicksort(smaller) + [pivot] + quicksort(greater) 612 | 613 | 614 | if __name__ == '__main__': 615 | arr = [60, 20, 11, 122, 214, 345, 1324, 1, 2, 3, 6, 74, 3, 9] 616 | print(quicksort(arr)) 617 | 618 | ``` 619 | 620 | 621 | ``` 622 | tab[1..n] - tablica wejściowa 623 | dł() - funkcja zwracająca rozmiar tablicy 624 | 625 | def quicksort(tab) 626 | Jeżeli dł(tab) <= 1: 627 | Zwróć tab 628 | 629 | pivot <- tab[dł(tab)] 630 | smaller <- [] 631 | greater <- [] 632 | 633 | Dla i = 1,2,3, ... , dł(tab) - 1 634 | Jeżeli tab[i] <= pivot 635 | Dodaj element tab[i] na koniec smaller 636 | W innym wypadku 637 | Dodaj element tab[i] na koniec greater 638 | 639 | Zwróć quicksort(smaller) + [pivot] + quicksort(greater) 640 | ``` 641 | 642 |
643 | 644 | 645 | ## Sortowanie kubełkowe [⬆️](#) 646 |
Rozwiń 647 | 648 | ```python 649 | # Not in place 650 | 651 | def insertion_sort(A): 652 | for i in range(1, len(A)): 653 | liczba = A[i] 654 | 655 | while i > 0 and A[i - 1] > liczba: 656 | A[i] = A[i - 1] 657 | i -= 1 658 | A[i] = liczba 659 | 660 | 661 | def bucket_sort(arr): 662 | buckets = [[] for _ in range(len(arr))] 663 | output = [] 664 | 665 | for i in range(len(arr)): 666 | 667 | j = int(arr[i] / (max(arr) / len(arr))) 668 | if j != len(arr): 669 | buckets[j].append(arr[i]) 670 | else: 671 | buckets[len(arr) - 1].append(arr[i]) 672 | 673 | for z in range(len(arr)): 674 | insertion_sort(buckets[z]) 675 | 676 | for x in range(len(arr)): 677 | output += buckets[x] 678 | return output 679 | ``` 680 | 681 | 682 | ``` 683 | n <- dlugość tablicy 684 | 685 | def BucketSort(arr): 686 | Dla 687 | ``` 688 | 689 |
690 | 691 | 692 | ## Szybkie podnoszenie do potęgi [⬆️](#) 693 |
Rozwiń 694 | 695 | ### Potęgowanie modularne (Metoda euklidesa. Szybko znajduje wartość base ^ power mod 1000000007). 696 | ```python 697 | #Iterated version 698 | 699 | def fast_power(base, power): 700 | result, m = 1, 1000000007 701 | while power > 0: 702 | if power % 2 == 1: 703 | result = (result * base) % m 704 | power //= 2 705 | base = (base * base) % m 706 | return result 707 | ``` 708 | 709 | 710 | ``` 711 | mod - reszta z dzielenia 712 | div - dzielenie całkowite 713 | 714 | def fast_power(base,power): 715 | result <- 1 716 | mod <- 1000000007 717 | Dopóki power > 0: 718 | Jeżeli power mod 2 == 1: 719 | result <- (result * base) mod m 720 | power <- power div 2 721 | base = (base * base) mod m 722 | Zwróć result 723 | ``` 724 | 725 | ### Potęgowanie metodą poprzez podnoszenie do kwadratu (wolniejsze od potęgowania modularnego, ale znajduje wartości większe niż a^n mod wartość). 726 | ```python 727 | def fast_pow(a, n): 728 | if n == 0: 729 | return 1 * (a != 0) 730 | # jeżeli wykładnik jest nieparzysty, to zmniejsz o jeden, by stał się parzysty, 731 | # a następnie oblicz potęgę a do parzystego wykładnika i pomnóż to przez a, 732 | # aby dostać a * a^parzysty_wykładnik. 733 | # na przykład: a^5 = a^4 * a 734 | if n % 2 == 1: 735 | return fast_pow(a, n - 1) * a 736 | # dla parzystego wykładnika szukamy potęgę z wykładnikiem o połowę mniejszym. 737 | # robiąc to, można dojść do a^2, co potem się składa na a^4 itd... 738 | # np. a^4 = a^2 * a^2. 739 | # kiedy n == 2, to funkcja szuka a^1, bo 2 div 2 == 1. 740 | # kiedy n == 1, to funkcja szuka a^0 * a, bo 1 jest liczbą nieparzystą, więc trafia do drugiego warunku. 741 | a = fast_pow(a, n // 2) 742 | return a * a 743 | ``` 744 | 745 | 746 | ``` 747 | a - podstawa 748 | n - wykładnik 749 | mod - reszta z dzielenia 750 | div - dzielenie całkowite 751 | 752 | funkcja fast_pow(a, n) 753 | Jeżeli n == 0 754 | Jeżeli a != 0 755 | Zwróć 1 756 | Zwróć 0 757 | Jeżeli n mod 2 == 1 758 | Zwróć fast_pow(a, n - 1) * a 759 | a = fast_pow(a, n div 2) 760 | Zwróć a * a 761 | ``` 762 | 763 |
764 | 765 | 766 | 767 | ## Wyznaczanie miejsc zerowych funkcji metodą połowienia - bisekcja [⬆️](#) 768 |
Rozwiń 769 | 770 | ```python 771 | def f(x): 772 | return -4 * x + 2 773 | 774 | 775 | # bisection(od,do) 776 | def bisection(a, b, precyzja=0.0001): 777 | if f(a) * f(b) >= 0: 778 | return None 779 | c = a 780 | while b - a >= precyzja: 781 | c = (a + b) / 2 782 | if f(c) == 0.0: 783 | break 784 | if f(c) * f(a) < 0: 785 | b = c 786 | else: 787 | a = c 788 | return c 789 | ``` 790 | 791 | 792 | ``` 793 | def f(x): 794 | Zwróć -4 * x + 2 795 | 796 | 797 | def bisection(a, b, precyzja=0.0001): 798 | 799 | Jeżeli f(a) * f(b) >= 0: 800 | Zwróć None 801 | c <- a 802 | Dopóki b - a >= precyzja: 803 | c -< (a + b) / 2 804 | Jeżeli f(c) == 0.0: 805 | break 806 | Jeżeli f(c) * f(a) < 0: 807 | b <- c 808 | else: 809 | a <- c 810 | Zwróć c 811 | ``` 812 | 813 |
814 | 815 | 816 | ## Sprawdzanie, czy dany ciąg znaków tworzy palindrom [⬆️](#) 817 |
Rozwiń 818 | 819 | ```python 820 | #With list and slices 821 | 822 | def is_palindrom(string): 823 | lista = list(string) 824 | if lista == lista[::-1]: 825 | return True 826 | return False 827 | ``` 828 | 829 | ```python 830 | #With 2 strings 831 | 832 | def is_palindrom(string): 833 | wynik = "" 834 | for i in string[::-1]: 835 | wynik += i 836 | if wynik == string: 837 | return True 838 | return False 839 | ``` 840 | 841 | ```python 842 | # Recursive version 843 | 844 | def isPalindrom(string): 845 | if len(string) == 1: 846 | return True 847 | if len(string) == 2: 848 | if string[0] == string[1]: 849 | return True 850 | return False 851 | return isPalindrom(string[1:-1]) if string[0] == string[-1] else False 852 | 853 | # This code is contributed by Pixel 854 | ``` 855 | 856 | ```python 857 | #Iterated version 858 | 859 | def is_palindrom(string, pal): 860 | if len(string) != len(pal): 861 | return None 862 | 863 | for i in range(len(string)): 864 | for j in range(len(pal) - 1, -1, -1): 865 | if string[i] == pal[i]: 866 | return True 867 | return False 868 | ``` 869 | 870 | 871 | ``` 872 | n - długość tablicy 873 | 874 | def is_palindrom(string, pal): 875 | Dla i = 1, 2, ... n 876 | Dla j = n, n-1, n-2 ... n-n 877 | Jeżeli string[i] == pal[i] 878 | Zwróć Prawdę 879 | W innym wypadku 880 | Zwróc Fałsz 881 | ``` 882 | 883 |
884 | 885 | 886 | ## Sprawdzanie, czy dany ciąg znaków tworzy anagram [⬆️](#) 887 |
Rozwiń 888 | 889 | ```python 890 | #With sorting 891 | 892 | def is_anagram(string,string2): 893 | if sorted(string) == sorted(string2): 894 | return True 895 | return False 896 | ``` 897 | 898 | ```python 899 | def sort_1(string): 900 | string = list(string) 901 | for i in range(len(string)): 902 | for j in range(len(string) - i - 1): 903 | if string[j] > string[j + 1]: 904 | string[j], string[j + 1] = string[j + 1], string[j] 905 | return "".join(string) 906 | 907 | 908 | def is_anagram(string, pattern): 909 | if len(string) != len(pattern): 910 | return False 911 | 912 | string = sort_1(string) 913 | pattern = sort_1(pattern) 914 | for i in range(len(string)): 915 | if string[i] != pattern[i]: 916 | return False 917 | return True 918 | ``` 919 | 920 | 921 | ``` 922 | Pseudocode 923 | ``` 924 | 925 | 926 | ```python 927 | 928 | def isIn(char, string): 929 | charInside = False 930 | for i in range(len(string)): 931 | if char == string[i]: 932 | charInside = True 933 | return True if charInside else False 934 | 935 | 936 | def isAnagram(string, pattern): 937 | if len(string) != len(pattern): 938 | return False 939 | 940 | for i in range(len(string)): 941 | if not isIn(string[i], pattern): 942 | return False 943 | 944 | for i in range(len(pattern)): 945 | if not isIn(pattern[i], string): 946 | return False 947 | return True 948 | 949 | # This code is contributed by Pixel 950 | ``` 951 | 952 | 953 | ``` 954 | Pseudocode 955 | ``` 956 | 957 |
958 | 959 | 960 | ## Porządkowanie alfabetyczne [⬆️](#) 961 |
Rozwiń 962 | 963 | ```python 964 | #Sortowanie liter bąbelkowo 965 | 966 | slowo = "niezdammatury" 967 | 968 | 969 | def bubble_sort(tab): 970 | tab = list(tab) 971 | for i in range(len(tab)): 972 | for j in range(len(tab) - i - 1): 973 | if tab[j] > tab[j + 1]: 974 | tab[j + 1], tab[j] = tab[j], tab[j + 1] 975 | return "".join(tab) 976 | 977 | 978 | print(bubble_sort(slowo)) 979 | ``` 980 |
981 | 982 | 983 | ## Wyszukiwanie wzorca w tekście [⬆️](#) 984 |
Rozwiń 985 | 986 | ```py 987 | def is_pattern(tekst, pattern): 988 | for i in range(len(tekst)): 989 | j = 0 990 | while j < len(pattern) and tekst[i + j] == pattern[j]: 991 | j += 1 992 | if j > 0 and j == len(pattern): 993 | return True 994 | return False 995 | ``` 996 | 997 | 998 | 999 | ``` 1000 | pseudocode 1001 | ``` 1002 | 1003 | 1004 |
1005 | 1006 | 1007 | ## Kompresja danych [⬆️](#) 1008 | 1009 | ### Prefix free 1010 |
Rozwiń 1011 | 1012 | Raczej nie obowiązuje na maturze, ale kto wie. 1013 | 1014 | Kod jest nazywany "prefix (free) code", jeżeli w systemie nie ma kodu słowa, który byłby prefixem innego kodu słowa. 1015 | 1016 | Załóżmy, że mamy plik z 100,000 znakami, jedyne znaki jakie występują w pliku to: a,b,c,d,e,f i chcemy zmniejszyć rozmiar tego pliku kompresją, gdzie każdy kod znaku ma różną długość. 1017 | 1018 | | | a | b | c | d | e | f | 1019 | | ----------------: | :---: | :---: | :---: | :---: | :---: | :---: | 1020 | | Częstość | 45 | 13 | 12 | 16 | 9 | 5 | 1021 | | Fixed-length code | 0 | 101 | 100 | 111 | 1101 | 1100 | 1022 | 1023 | Plik taki zajmnie (45 * 1 + 13 * 3 + 12 * 3 + 16 * 3 + 9 * 4 + 5 * 4) * 1000 = 224,000 bity 1024 | 1025 | ```python 1026 | #Iterated version 1027 | 1028 | text = "010111010011111001001100" 1029 | 1030 | cipher = {'0': 'n', '101': 'i', '100': 'm', '111': 'z', '1101': 'e', '1100': 'd', '1001': 'a', '00': ' '} 1031 | 1032 | 1033 | def decrypt(cipher, text): #brak obsługi błedów, jeżeli zmienna text skonstruowana jest niepoprawnie. 1034 | res = "" 1035 | while text: 1036 | for k in cipher: 1037 | if text.startswith(k): 1038 | res += cipher[k] 1039 | text = text[len(k):] 1040 | return res 1041 | 1042 | 1043 | to_code = "zdam" 1044 | 1045 | 1046 | def encrypt(cipher, text): 1047 | res = "" 1048 | for char in text: 1049 | if char in cipher.values(): 1050 | for k, v in cipher.items(): 1051 | if v == char: 1052 | res += k 1053 | else: 1054 | res += "-" 1055 | return res 1056 | 1057 | 1058 | print(decrypt(cipher, text)) 1059 | print(encrypt(cipher, to_code)) 1060 | ``` 1061 |
1062 | 1063 | 1064 | ## Alfabet Morse’a [⬆️](#) 1065 |
Rozwiń 1066 | 1067 |
Python 1068 | 1069 | ```python 1070 | # define coding dict 1071 | morseEncode = { 1072 | 'a': '.-', 'b': '-...', 'c': '-.-.', ' ': ' ', 1073 | 'd': '-..', 'e': '.', 'f': '..-.', '': '', 1074 | 'g': '--.', 'h': '....', 'i': '..', 1075 | 'j': '.---', 'k': '-.-', 'l': '.-..', 1076 | 'm': '--', 'n': '-.', 'o': '---', 1077 | 'p': '.--.', 'q': '--.-', 'r': '.-.', 1078 | 's': '...', 't': '-', 'u': '..-', 1079 | 'v': '...-', 'w': '.--', 'x': '-..-', 1080 | 'y': '-.--', 'z': '--..', '1': '.----', 1081 | '2': '..---', '3': '...--', '4': '....-', 1082 | '5': '.....', '6': '-....', '7': '--...', 1083 | '8': '---..', '9': '----.', '0': '-----', 1084 | } 1085 | # swap coding table for decoding dict 1086 | morseDecode = {val: key for key, val in morseEncode.items()} 1087 | morseDecode.update({'_': ' '}) 1088 | 1089 | # define coding function 1090 | def morseCode(string, decode=False): 1091 | string = string.lower() 1092 | output = "" 1093 | if not decode: # then encode 1094 | for char in string: 1095 | output += morseEncode.get(char, '') # print '*' for unexpected characters 1096 | if char != ' ': output += ' ' 1097 | else: 1098 | string = string.replace(' ', ' _ ') 1099 | for char in string.split(' '): 1100 | output += morseDecode.get(char, '') # print '*' for unexpected codes 1101 | return output 1102 | 1103 | # test 1104 | string = "Keep learning" 1105 | coded = morseCode(string) 1106 | print("Coded:", coded) 1107 | decoded = morseCode(coded, decode=True) 1108 | print("Decoded:", decoded) 1109 | 1110 | # This code is contributed by Pixel 1111 | ``` 1112 |
1113 |
C++ 1114 | 1115 | ```cpp 1116 | #include 1117 | #include 1118 | 1119 | using namespace std; 1120 | 1121 | map codeTab{ 1122 | {"a", ".-"},{"b", "-..."},{"c", "-.-."},{"d", "-.."}, 1123 | {"e", "."},{"f", "..-."},{"g", "--."},{"h", "...."}, 1124 | {"i", ".."},{"j", ".---"},{"k", "-.-"},{"l", ".-.."}, 1125 | {"m", "--"},{"n", "-."},{"o", "---"},{"p", ".--."}, 1126 | {"q", "--.-"},{"r", ".-."},{"s", "..."},{"t", "-"}, 1127 | {"u", "..-"},{"v", "...-"},{"w", ".--"},{"x", "-..-"}, 1128 | {"y", "-.--"},{"z", "--.."},{"1", ".----"},{"2", "..---"}, 1129 | {"3", "...--"},{"4", "....-"},{"5", "....."},{"6", "-...."}, 1130 | {"7", "--..."},{"8", "---.."},{"9", "----."},{"0", "-----"}, 1131 | {"", ""},{" ", "_"}, {" ", "WDA"} 1132 | }; 1133 | 1134 | string code(string in, bool decode=false){ 1135 | string out = ""; 1136 | if(decode){ 1137 | string val = ""; 1138 | for(int i = 0; i::iterator it; 1140 | if(in[i] != ' '){ 1141 | val += in[i]; 1142 | } 1143 | else{ 1144 | if(in[i-1] == ' ' && in[i+1] == ' ') 1145 | val = "_"; 1146 | for (it = codeTab.begin(); it != codeTab.end(); it++){ 1147 | if(val == it->second){ 1148 | out += it->first; 1149 | } 1150 | } 1151 | val = ""; 1152 | } 1153 | } 1154 | } 1155 | else{ 1156 | for(int i = 0; i 1177 |
1178 | 1179 | 1180 | ## Szyfr AtBash[⬆️](#) 1181 |
Rozwiń 1182 | 1183 | Jest to monoalfabetyczny szyfr podstawieniowy, ograniczony. Zasada jego działania polega na podstawieniu zamiast danej litery, litery leżącej po drugiej stronie alfabetu w takiej samej odległości. Np. zamiast litery A powinniśmy podstawić literę Z, za literę C wstawiamy literę X. 1184 | 1185 | ```python 1186 | txt = "Nie zdam maturki elo" 1187 | 1188 | 1189 | def atbash(txt): 1190 | txt = list(txt) 1191 | for i in range(len(txt)): 1192 | if "A" <= txt[i] <= "Z": # wielkie litery 1193 | txt[i] = chr(ord("Z") - (ord(txt[i]) - ord("A"))) 1194 | 1195 | if "a" <= txt[i] <= "z": # małe litery 1196 | txt[i] = chr(ord("z") - (ord(txt[i]) - ord("a"))) 1197 | 1198 | if txt[i] == " ": 1199 | txt[i] = " " 1200 | 1201 | return "".join(txt) 1202 | 1203 | 1204 | print(atbash(txt)) 1205 | 1206 | ``` 1207 |
1208 | 1209 | 1210 | ## Transpozycyjny [⬆️](#) 1211 |
Rozwiń 1212 | 1213 | Szyfry przestawieniowe dokonują przestawienia znaków w tekście. Tekst zaszyfrowany jest permutacją tekstu jawnego, tzn. zawiera wszystkie znaki tekstu jawnego, jednak ustawione w innej kolejności. Operacja taka nosi nazwę transpozycji. 1214 | 1215 | 1216 | ```python 1217 | tekst = "InEz Dma amTrUy ,b ojsett rdun aes" # jump = 3 to decrypt 1218 | 1219 | 1220 | def przes(tekst, jump): 1221 | tekst = list(tekst) 1222 | for i in range(0, len(tekst)-1, jump): 1223 | tekst[i], tekst[i + 1] = tekst[i + 1], tekst[i] 1224 | return "".join(tekst) 1225 | 1226 | 1227 | print(przes(tekst, 3)) 1228 | ``` 1229 |
1230 | 1231 | 1232 | ## Szyfr Cezara [⬆️](#) 1233 |
Rozwiń 1234 | 1235 |
Python 1236 | 1237 | Jest to rodzaj szyfru podstawieniowego, w którym każda litera tekstu jawnego (niezaszyfrowanego) zastępowana jest inną, oddaloną od niej o stałą liczbę pozycji w alfabecie.
1238 | 1239 | Jeżeli przesunięcie będzie równie 13, uzyskamy szyfr ROT13. 1240 | ```python 1241 | def koduj(wiadomosc, klucz): 1242 | wynik = "" 1243 | wiadomosc = wiadomosc.upper().strip().replace(" ", "") 1244 | for i in wiadomosc: 1245 | wynik += chr((ord(i) + klucz - 65) % 26 + 65) 1246 | return wynik 1247 | 1248 | 1249 | def dekoduj(wiadomosc, klucz): 1250 | klucz *= -1 1251 | return koduj(wiadomosc, klucz) 1252 | ``` 1253 | 1254 | 1255 | ``` 1256 | wiadomosc <- przechowuje ciąg wielkich liter alfabetu angielskiego, bez spacji i znaków specjalnych 1257 | ord() - pokazuje kod znaku w unicode 1258 | chr() - pokazuje znak kodu unicode 1259 | n <- długość ciągu znaków 1260 | klucz <- liczba całkowita z przedziału 1-26 1261 | 1262 | koduj(wiadomosc, klucz): 1263 | wynik = "" 1264 | Dla i = 1, 2, 3 ... n 1265 | wynik += chr((ord(i) + klucz - 65) % 26 + 65) 1266 | Zwróć wynik 1267 | ``` 1268 | 1269 |
1270 |
C++ 1271 | 1272 | ```cpp 1273 | void gr7(string wiadomosc, int klucz) { 1274 | string wynik; 1275 | 1276 | for (char i : wiadomosc) 1277 | if(isupper(i)) wynik += static_cast((static_cast(i + klucz) - 65) % 26 + 65); 1278 | else wynik += static_cast((static_cast(i + klucz) - 97) % 26 + 97); 1279 | 1280 | cout << wynik; 1281 | } 1282 | ``` 1283 |
1284 |
1285 | 1286 | [py]: https://img.shields.io/badge/Python-%E2%9C%94-green?style=flat-square&logo=python 1287 | [notpy]: https://img.shields.io/badge/Python-%E2%9C%98-red?style=flat-square&logo=python 1288 | 1289 | [java]: https://img.shields.io/badge/Java-%E2%9C%94-green?style=flat-square&logo=Java&logoColor=yellow 1290 | [nojava]: https://img.shields.io/badge/Java-%E2%9C%98-red?style=flat-square&logo=Java&logoColor=yellow 1291 | 1292 | [c++]: https://img.shields.io/badge/C++-%E2%9C%94-green?style=flat-square&logo=c%2B%2B&logoColor=blue 1293 | [noc++]: https://img.shields.io/badge/C++-%E2%9C%98-red?style=flat-square&logo=c%2B%2B&logoColor=blue 1294 | --------------------------------------------------------------------------------