Podaj napis, który powstanie po wykonaniu wszystkich instrukcji z pliku instrukcje.txt.

Dla pliku przyklad.txt wynikiem jest napis ALANTURING.

Rozwiązanie (i cały program):

Dla każdej operacji sprawdzamy, która instrukcja została wywołana. DOPISZ jest raczej proste :) W przypadku ZMIEN i USUN slice'ujemy aktualny wynik do ostatniego znaku (nie włączając go - :-1). Dla ZMIEN Dodatkowo dodajemy argument instrukcji.
Dla instrukcji PRZESUN musimy wyznaczyć nową literę. Można to osiągnąć, odejmując od reprezentacji ASCII oryginalnej litery 64 - gdybyśmy odjęli w tym przypadku 65, cała operacja chr(((ord(argument) - 64) % 26) + 65) nie zmieniłaby nic, w tym przypadku różnica 65 - 1 to nasze przesunięcie.
Ważne jest, aby do metody replace, która zwraca kopię, przekazać trzeci parametr mówiący ile wystąpień sekwencji (w naszym przypadku znaku) od lewej należy zastąpić. Dla tego zadania jest to 1.

with open("dane/instrukcje.txt", "r") as f:
    operations = [operation.strip() for operation in f.readlines()]

result = ""

for operation in operations:
    instruction, argument = operation.split(" ")
    if instruction == "DOPISZ":
        result += argument
    elif instruction == "ZMIEN":
        result = result[:-1] + argument
    elif instruction == "USUN":
        result = result[:-1]
    elif instruction == "PRZESUN":
        new_letter = chr(((ord(argument) - 64) % 26) + 65)
        result = result.replace(argument, new_letter, 1)

print(result)

Wynik:

POZNIEJMOWIONOZECZLOWIEKTENNADSZEDLODPOLNOCYODBRAMYPOWROZNICZEJSZEDLPIESZOAOBJUCZONEGOKONIAPROWADZILZAUZDEBYLOPOZNEPOPOLUDNIEIKRAMYPOWROZNIKOWIRYMARZYBYLYJUZZAMKNIETEAULICZKAPUSTABYLOCIEPLOACZLOWIEKTENMIALNASOBIECZARNYPLASZCZNARZUCONYNARAMIONAZWRACALUWAGEZATRZYMALSIEPRZEDGOSPODASTARYNARAKORTPOSTALCHWILEPOSLUCHALGWARUGLOSOWGOSPODAJAKZWYKLEOTEJPORZEBYLAPELNALUDZINIEZNAJOMYNIEWSZEDLDOSTAREGONARAKORTUPOCIAGNALKONIADALEJWDOLULICZKITAMBYLADRUGAKARCZMAMNIEJSZANAZYWALASIEPODLISEMTUBYLOPUSTOKARCZMANIEMIALANAJLEPSZEJSLAWY

Źródło: https://arkusze.pl/matura-informatyka-2021-maj-poziom-rozszerzony/

Oblicz, która litera jest najczęściej dopisywana (najczęściej występuje w instrukcji DOPISZ). Podaj tę literę oraz ile razy jest dopisywana. Istnieje tylko jedna taka litera.

Dla pliku przyklad.txt odpowiedzią jest litera U, dopisywana 3 razy.

Rozwiązanie (i cały program):

W list comprehension poza standardowym .strip() odpowiedzialnym w tym przypadku za usunięcie znaku nowej linii rozdzielam również operację od jej argumentu i zostawiam sam argument, np.:

"DOPISZ E".split(" ")[1]
# taki kod zwróci nam samo "E"

Dodatkowo, przy pomocy if operation.startswith("DOPISZ") odfiltrowuję wszystkie linijki, które nie zaczynają się na DOPISZ.

Jedyne, co pozostało do zrobienia to zliczenie dla każdej liczby ilości jej wystąpień i wypisanie znaku z największą ich liczbą:

from collections import Counter

with open("dane/instrukcje.txt", "r") as f:
    operations = [operation.strip().split(" ")[1] for operation in f.readlines() if operation.startswith("DOPISZ")]

print(Counter(operations).most_common(1))

Counter jest bardzo przydatnym narzędziem umożliwiającym skorzystanie z wbudowanej w bibliotekę standardową abstrakcji. Jego odpowiednik zapisany w postaci pętli w tym przypadku to:

with open("dane/instrukcje.txt", "r") as f:
    operations = [operation.strip().split(" ")[1] for operation in f.readlines() if operation.startswith("DOPISZ")]

counter = {}

for operation in operations:
    counter[operation] = counter.get(operation, 0) + 1

sorted_pairs = sorted(counter.items(), key=lambda pair: pair[1], reverse=True)
print(sorted_pairs[0])

Wynik:

[('Z', 37)]

Źródło: https://arkusze.pl/matura-informatyka-2021-maj-poziom-rozszerzony/

Znajdź najdłuższy ciąg występujących kolejno po sobie instrukcji tego samego rodzaju. Jako odpowiedź podaj rodzaj instrukcji oraz długość tego ciągu. Istnieje tylko jeden taki ciąg.

Dla pliku przyklad.txt odpowiedzią jest: rodzaj instrukcji – DOPISZ, długość ciągu – 5.

Rozwiązanie (i cały program):

W list comprehension poza standardowym .strip() odpowiedzialnym w tym przypadku za usunięcie znaku nowej linii rozdzielam również operację od jej argumentu i zostawiam samą nazwę operacji, np.:

"DOPISZ E".split(" ")[0]
# taki kod zwróci nam samo "DOPISZ"

Następnie inicjalizuję liczniki - dla największej ilości operacji i dla aktualnej ilości operacji - wraz ze zmiennymi przechowującymi nazwy aktualnej operacji i operacji najczęściej do tej pory spotkanej.
Jeżeli w aktualnej iteracji instrukcja (czyli np.: DOPISZ) równa się wcześniej zapisanej current_instruction_name , to inkrementujemy aktualny licznik. W przeciwnym wypadku natrafiliśmy na koniec lokalnego ciągu tej samej operacji. Zatem trzeba sprawdzić, czy licznik lokalnego ciągu jest większy od najdłuższego spotkanego do tej pory. Jeśli tak - mamy nowy najdłuższy ciąg - zastępujemy zatem zmienne.
Dlaczego current_operations_count jest ustawiony na 1 zamiast na 0 ?
W przeciwnym wypadku zostałaby ominięta wtedy jedna operacja, która przerwała wcześniejszy ciąg :D

with open("dane/instrukcje.txt", "r") as f:
    operations = [operation.strip().split(" ")[0]
                  for operation in f.readlines()]

total_operations_count = 0
total_instruction_name = None

current_operations_count = 0
current_instruction_name = None

for instruction in operations:
    if instruction == current_instruction_name:
        current_operations_count += 1
    else:
        if current_operations_count > total_operations_count:
            total_instruction_name = current_instruction_name
            total_operations_count = current_operations_count
        current_operations_count = 1
        current_instruction_name = instruction


print(f"{total_instruction_name}: {total_operations_count}")

Wynik:

ZMIEN: 7

Źródło: https://arkusze.pl/matura-informatyka-2021-maj-poziom-rozszerzony/

Pewna firma przygotowuje wyświetlanie napisów złożonych z wielkich liter alfabetu angielskiego. Na początku napis jest pusty (nie zawiera liter). W pliku instrukcje.txt podanych jest 2000 instrukcji, które wykonuje automat do generowania napisu. Każda z instrukcji składa się z polecenia, spacji oraz pojedynczego znaku. Polecenia są czterech rodzajów:

DOPISZ litera – oznacza, że na końcu napisu trzeba dopisać pojedynczą literę;

ZMIEN litera – oznacza, że ostatnią literę aktualnego napisu należy zmienić na podaną literę (możesz założyć, że napis jest niepusty);

USUN 1 – oznacza, że należy usunąć ostatnią literę aktualnego napisu (możesz założyć, że napis jest niepusty);

PRZESUN litera – oznacza, że pierwsze od lewej wystąpienie podanej litery w napisie należy zamienić na następną literę w alfabecie (jeśli litera to A, to należy zamienić na B, jeśli B, to na C itd.) Literę Z należy zamienić na A. Jeśli litera nie występuje w napisie, nie należy nic robić.

Oblicz całkowitą długość napisu po wykonaniu wszystkich instrukcji z pliku instrukcje.txt. Dla pliku przyklad.txt długością napisu jest liczba 10.

Rozwiązanie (i cały program):

Dla każdej linii pozbywamy się znaku nowej linii (\n). Deklarujemy licznik operations_count i dla każdej linii w liście sprawdzamy, jaka operacja ma zostać wykonana. Jeśli operacja zaczyna się na DOPISZ - dodajemy 1. Jeśli zaś USUN , odejmujemy. Korzystamy z metody startswith , żeby pominąć parametr operacji (np.: literę).

with open("dane/instrukcje.txt", "r") as f:
    operations = [operation.strip() for operation in f.readlines()]

operations_count = 0

for operation in operations:
    if operation.startswith("DOPISZ"):
        operations_count += 1
    elif operation.startswith("USUN"):
        operations_count -= 1

print(operations_count)

Wynik:

517

Źródło: https://arkusze.pl/matura-informatyka-2021-maj-poziom-rozszerzony/

Ostatnie z haseł zostało ukryte w cyfrach zapisanych w pliku napisy.txt. Aby je odczytać, należy cyfry z każdego wiersza pogrupować po dwie, pomijając ostatnią, jeśli w wierszu jest nieparzysta liczba cyfr. Jeżeli liczba utworzona przez parę cyfr jest mniejsza od 65 lub większa od 90, to ją pomijamy, w przeciwnym przypadku taką liczbę zamieniamy na znak o kodzie ASCII odpowiadającym tej liczbie. Poszukiwanie hasła kończy się po otrzymaniu trzech kolejnych znaków „X”. Odczytaj z pliku tak ukryte hasło.

Dla danych z pliku przyklad.txt wynikiem jest: NAPISANIEMATURYXXX

Rozwiązanie (i cały program):

Dla każdej linii wybieramy tylko te znaki, które są cyframi. Następnie, jeśli hasło kończy się na 3 znaki X (warunek zadania) możemy stwierdzić, że zakończyliśmy szukanie hasła - to nasz warunek bazowy.

W przeciwnym wypadku, dla każdej pary (robimy to przy pomocy podania 2 , jako trzeciego parametru funkcji range, co pozwala nam na "przeskakiwanie" par) sprawdzamy, czy wcześniej wspomniane znaki mieszczą się w zakresie 65 <= 90.

Jeśli tak, dopisujemy je do hasła, a po skończeniu pętli wypisujemy je na ekran!

with open("dane/napisy.txt", "r") as f:
    lines = [line.strip() for line in f.readlines()]

password = ""

for line in lines:
    digits = "".join(character for character in line if character.isdigit())

    if password.endswith("XXX"):
        break

    for index in range(0, len(digits), 2):
        potential_char = int(digits[index:index+2])
        if 65 <= potential_char <= 90:
            password += chr(potential_char)

print(password)

Wynik:

LITWOOJCZYZNOMOJATYJESTESJAKZDROWIEILECIETRZEBACENICTENTYLKOSIEDOWIEKTOCIESTRACILNATENCZASWOJSKICHWYCILNATASMIEPRZYPIETYSWOJROGBAWOLIDLUGICENTKOWANYKRETYJAKWAZBOAXXX

Źródło: https://arkusze.pl/matura-informatyka-2021-czerwiec-poziom-rozszerzony/

Palindromem nazywamy napis, który czytany od początku lub od końca jest taki sam (np. KAJAK). Część napisów zapisanych w wierszach pliku (każdy ma 50 znaków) można w prosty sposób – przez dodanie dokładnie jednego znaku na początku lub na końcu napisu – zamienić na palindrom.

Podaj hasło utworzone przez środkowe litery tak utworzonych palindromów.

Dla danych z pliku przyklad.txt wynikiem jest: INFORMATYKA

Rozwiązanie (i cały program):

Dla każdej linii (po ich wcześniejszym odczytaniu z pliku) tworzymy 2 warianty palindromów:

• pierwszy - z ostatnią literą na początku,

• drugi - z pierwszą literą na końcu.

Wyznaczamy środkowy indeks - można byłoby przypisać bezpośrednio liczbę 25 , ponieważ mamy zapewnienie z zadania, że każdy wiersz ma 50 znaków, a (50 + 1) // 2 = 25 , ale jakoś... dziwnie tak :D
Następnie jeżeli wariant 1 równa się swojej odwrotności [::-1] (opcjonalnie można byłoby użyć funkcji reversed(variant) ), to dopisujemy znak z indeksu 25 do hasła. Jeśli nie, to sprawdzamy jeszcze wariant 2. Na końcu wypisujemy hasło!

with open("dane/napisy.txt", "r") as f:
    lines = [line.strip() for line in f.readlines()]

password = ""

for line in lines:
    variant_1 = f"{line[-1]}{line}"
    variant_2 = f"{line}{line[0]}"

    middle_index = len(variant_1) // 2

    if variant_1 == variant_1[::-1]:
        password += variant_1[middle_index]
    elif variant_2 == variant_2[::-1]:
        password += variant_2[middle_index]

print(password)

Wynik:

ZADANIEMATURALNE

Źródło: https://arkusze.pl/matura-informatyka-2021-czerwiec-poziom-rozszerzony/

W pliku napisy.txt ukryto pewne pięćdziesięcioznakowe hasło w następujący sposób: – w co dwudziestym wierszu (w wierszach o numerach 20, 40, 60, …, 1000), ukryto dokładnie jedną literę hasła;

– ukryta litera w kolejnych wierszach zawsze znajduje się na innej pozycji: w 20 wierszu na pierwszej, w 40 wierszu na drugiej, w 60 wierszu na trzeciej, …, w 1000 na pięćdziesiątej. Podaj to hasło.

Dla danych z pliku przyklad.txt wynikiem jest:

UDALOSIEIZDAJEMYEGZAMINYMATURALNEZWIELUPRZEDMIOTOW

Rozwiązanie (i cały program):

Kolejne krótkie zadanie :D Całość sprowadza się do odczytania linii z pliku, a następnie przeiterowaniu przez co dwudziestą linię od dwudziestej (indeks nr 19 - bo liczymy od zera :P ), pobierając znak o indeksie większym o jeden niż ostatnio.

with open("dane/napisy.txt", "r") as f:
    lines = [line.strip() for line in f.readlines()]

password = ""
offset_num = 0

for line in lines[19::20]:
    password += line[offset_num]
    offset_num += 1

print(password)

Jeśli nie wiesz, co robi podwójny :: przy lines, to jest to tzw. "list slicing". Możesz przeczytać o nim więcej tutaj. W gruncie rzeczy liczba pierwsza od lewej oznacza indeks, od którego zaczynamy pobierać nasz "kawałek" tablicy, kolejna (pomiędzy dwoma dwukropkami - jak widać, można ją pominąć, zostawiając :: ) oznacza indeks, na jakim chcemy się zatrzymać - bez włączania ostatniego, np.:

simple_list = [0,1,2,3,4,5]
print(simple_list[2:4])

Da nam cyfry [2,3] - bo zaczynamy od indeksu 2 i kończymy na 4, nie włączając go.

Ostatnia liczba oznacza krok iteracji, w naszym przypadku "co dwudziesty element".

W przypadku:

simple_list = [0,1,2,3,4,5]
print(simple_list[::2])

Otrzymamy [0, 2, 4] skacząc co drugie pole, a dla:

simple_list = [0,1,2,3,4,5]
print(simple_list[1::2])

Otrzymamy [1,3,5] , gdyż zaczęliśmy od indeksu nr 1 :)

Wynik:

SZYBKOROZWIAZUJEPROGRAMISTYCZNEZADANIAZINFORMATYKI

Źródło: https://arkusze.pl/matura-informatyka-2021-czerwiec-poziom-rozszerzony/

W pliku napisy.txt znajduje się 1000 wierszy po 50 znaków (dużych liter angielskiego alfabetu oraz cyfr).

Napisz program(y), który(e) da(dzą) odpowiedzi do poniższych zadań. Odpowiedzi zapisz w pliku wyniki4.txt, a każdą odpowiedź poprzedź numerem oznaczającym odpowiednie zadanie.
Uwaga: Plik przyklad.txt zawiera dane przykładowe spełniające warunki zadania. Odpowiedzi dla danych z pliku przyklad.txt są podane pod pytaniami.

Podaj łączną liczbę cyfr we wszystkich napisach z pliku napisy.txt

Dla danych z pliku przyklad.txt wynikiem jest: 46504

Rozwiązanie (i cały program):

Zadanie typowo rozgrzewkowe, sprowadza się do odczytania linii z pliku i sprawdzeniu, ile cyfr znajduje się w każdej z nich. można to osiągnąć wywołując metodę .isdigit() :

with open("dane/napisy.txt", "r") as f:
    lines = [line.strip() for line in f.readlines()]


num_counter = 0

for line in lines:
    for character in line:
        if character.isdigit():
            num_counter += 1

print(num_counter)

Wynik:

11844

Źródło: https://arkusze.pl/matura-informatyka-2021-czerwiec-poziom-rozszerzony/

Znajdź w pliku liczby.txt:

• liczbę, która ma w rozkładzie najwięcej czynników pierwszych (podaj tę liczbę oraz liczbę jej czynników pierwszych)

• liczbę, która ma w rozkładzie najwięcej różnych czynników pierwszych (podaj tę liczbę oraz liczbę jej różnych czynników pierwszych).

Przykład: liczba 420=2·2·3·5·7 ma w rozkładzie 5 czynników pierwszych, w tym 4 różne czynniki pierwsze (2, 3, 5, 7).

Odpowiedź dla danych z pliku przyklad.txt: 144 6 210 4

(Liczba 144 ma najwięcej czynników pierwszych; liczba czynników pierwszych liczby 144 wynosi 6. Liczba 210 ma najwięcej różnych czynników pierwszych; liczba różnych czynników pierwszych liczby 210 wynosi 4).

Rozwiązanie:

Odczytujemy dane z pliku i konwertujemy je na int'y:

with open("dane/liczby.txt", "r") as f:
    nums = [int(num) for num in f.readlines()]

Następnie definiujemy funkcję get_prime_factors , której zadaniem jest zwrócenie listy czynników pierwszych

def get_prime_factors(n: int) -> list[int]:
    current_divider = 2
    factors = []
    while n > 1:
        if n % current_divider == 0:
            factors.append(current_divider)
            n = n / current_divider
        else:
            current_divider += 1

    return factors

Jej działanie opiera się na podobieństwie z sitem Eratostenesa. Więcej o algorytmie możesz przeczytać tutaj.

Z treści zadania wynika:

W pliku liczby.txt danych jest 200 różnych liczb całkowitych z zakresu [10, 100000]. Każda z tych liczb zapisana jest w osobnym wierszu. , że liczby są w zakresie [10, 100000], więc można bezpiecznie założyć, że naszymi minimami mogą być 0 i puste listy:

prime_factors = 0
prime_factors_list = []

unique_prime_factors = 0
unique_prime_factors_list = []

Dla każdej liczby wyznaczamy jej listę czynników pierwszych i tą listę bez duplikatów. Kolejne linijki sprowadzają się do porównania z poprzednimi wynikami i wypisaniem ich na ekran:

for num in nums:
    prime_factors_result = get_prime_factors(num)
    unique_prime_factors_result = set(prime_factors_result)
    if len(prime_factors_result) > len(prime_factors_list):
        prime_factors = num
        prime_factors_list = prime_factors_result
    if len(unique_prime_factors_result) > len(unique_prime_factors_list):
        unique_prime_factors = num
        unique_prime_factors_list = unique_prime_factors_result

print(f"{prime_factors} {len(prime_factors_list)}")
print(f"{unique_prime_factors} {len(unique_prime_factors_list)}")

Cały program:

with open("dane/liczby.txt", "r") as f:
    nums = [int(num) for num in f.readlines()]

def get_prime_factors(n: int) -> list[int]:
    current_divider = 2
    factors = []
    while n > 1:
        if n % current_divider == 0:
            factors.append(current_divider)
            n = n / current_divider
        else:
            current_divider += 1

    return factors

prime_factors = 0
prime_factors_list = []

unique_prime_factors = 0
unique_prime_factors_list = []

for num in nums:
    prime_factors_result = get_prime_factors(num)
    unique_prime_factors_result = set(prime_factors_result)
    if len(prime_factors_result) > len(prime_factors_list):
        prime_factors = num
        prime_factors_list = prime_factors_result
    if len(unique_prime_factors_result) > len(unique_prime_factors_list):
        unique_prime_factors = num
        unique_prime_factors_list = unique_prime_factors_result

print(f"{prime_factors} {len(prime_factors_list)}")
print(f"{unique_prime_factors} {len(unique_prime_factors_list)}")

Wynik:

99792 10
62790 6

Źródło: https://arkusze.pl/matura-informatyka-2022-maj-poziom-rozszerzony/

Podaj, ile jest w pliku liczby.txt takich liczb, których cyfry pierwsza i ostatnia są takie same.

Zapisz tę z nich, która występuje w pliku liczby.txt jako pierwsza.

W pliku z danymi jest co najmniej jedna taka liczba.

Odpowiedź dla danych z pliku przyklad.txt: 26 626

(26 takich liczb, które mają pierwszą i ostatnią cyfrę taką samą; pierwszą z nich w pliku przykładowym jest 626)

Rozwiązanie:

Odczytujemy dane z pliku - tym razem nie konwertujemy ich na int , ponieważ będziemy sprawdzać pierwszy i ostatni znak cyfry. Warto pamiętać o usunięciu białych znaków przy pomocy metody strip() .

with open("dane/liczby.txt", "r") as f:
    nums = [num.strip() for num in f.readlines()]

total = 0
first_num = None

Następnie w prostej pętli sprawdzamy, czy pierwszy znak równa się ostatniemu. Jeśli tak - zwiększamy licznik. Gdy first_num jest None , możemy uznać, że spotkaliśmy pierwszą taką liczbę w pliku - zapisujemy ją do zmiennej.

for str_num in nums:
    if str_num[0] == str_num[-1]:
        total += 1
        if first_num is None:
            first_num = str_num

print(f"{total} {first_num}")

Dlaczego użyłem is zamiast == ? Można poczytać o tym np.: tutaj.

Cały program:

with open("dane/liczby.txt", "r") as f:
    nums = [num.strip() for num in f.readlines()]

total = 0
first_num = None

for str_num in nums:
    if str_num[0] == str_num[-1]:
        total += 1
        if first_num is None:
            first_num = str_num

print(f"{total} {first_num}")

Wynik:

18 93639

Źródło: https://arkusze.pl/matura-informatyka-2022-maj-poziom-rozszerzony/

Podaj:

• ile różnych liczb zapisano w pliku liczby.txt

• ile liczb powtarza się dokładnie dwa razy w pliku liczby.txt

• ile liczb powtarza się dokładnie trzy razy w pliku liczby.txt. Dla pliku przyklad.txt odpowiedzią jest 10 1 0.

Rozwiązanie:

Zadanie sprowadza się do kilku podstawowych operacji - użycia set do wydobycia niepowtarzających się liczb i następnie wyświetlenie ilości tych, które powtarzają się 2 i 3 razy.

with open("dane/liczby.txt", "r") as f:
    nums = [int(num) for num in f.readlines()]

unique_nums = set(nums)

# counted_nums = {num: nums.count(num) for num in unique_nums}
counted_nums = {}
for num in unique_nums:
    counted_nums[num] = nums.count(num)

W pętli, dla każdego unikalnego numeru, wstawiamy do dict'a jego ilość wystąpień w liście nums . W komentarzu powyżej użyłem odpowiednika jako dict comprehension - zarówno dla list jak i słowników, w wielu przypadkach potrafi skrócić kod o kilka linijek i zapisać operacje nieco zwięźlej :)

repeated_2_nums = [
    num for num, occurences in counted_nums.items() if occurences == 2
]
repeated_3_nums = [
    num for num, occurences in counted_nums.items() if occurences == 3
]

Tym razem używamy już list comprehension do stworzenia list, które zawierają w sobie cyfry występujące w słowniku counted_nums odpowiednio 2 i 3 razy. counted_nums.items() przekształca słownik na listę w postaci [(klucz, wartosc), (klucz, wartosc)] .

Cały program:

with open("dane/liczby.txt", "r") as f:
    nums = [int(num) for num in f.readlines()]

unique_nums = set(nums)

# counted_nums = {num: nums.count(num) for num in unique_nums}
counted_nums = {}
for num in unique_nums:
    counted_nums[num] = nums.count(num)

repeated_2_nums = [
    num for num, occurences in counted_nums.items() if occurences == 2
]
repeated_3_nums = [
    num for num, occurences in counted_nums.items() if occurences == 3
]

print(f"ilosc roznych liczb: {len(unique_nums)}")
print(f"powtarzaja sie dokladnie 2 razy: {len(repeated_2_nums)}")
print(f"powtarzaja sie dokladnie 3 razy: {len(repeated_3_nums)}")

Wynik:

85
13
1

Źródło: https://arkusze.pl/matura-informatyka-2022-czerwiec-poziom-rozszerzony/

Wypisz wszystkie liczby pierwsze z pliku liczby.txt, których odbicia również są liczbami pierwszymi, każdą w oddzielnym wierszu.

Dla pliku przyklad.txt odpowiedź to:

13

131

(odbiciem liczby 13 jest 31 – obie są liczbami pierwszymi, odbiciem 131 jest 131)

Rozwiązanie:

Na początku zdefiniujmy funkcję, która powie nam, czy dana funkcja jest liczbą pierwszą. Liczba pierwsza , jest liczbą naturalną większą od 1 oraz dzieli się przez 1 i samą siebie.

def is_prime(n: int) -> bool:
    if n < 2:
        return False

    range_limit = int(sqrt(n)) + 1

    for i in range(2, range_limit):
        if n % i == 0:
            return False
    return True

Nie ma sensu szukać zatem liczby pierwszej w zbiorze liczb mniejszych od 2. Zakładam, że do funkcji zostanie podana tylko liczba naturalna. Szukanie dzielnika liczby można ograniczyć do zakresu pierwiastka kwadratowego +1 - dla pewności :)

Następnie dla każdej odczytanej liczby sprawdzamy, czy jest ona i jej odbicie liczbą pierwszą - jeśli tak - wypisujemy ją :)

with open("dane/liczby.txt", "r") as f:
    nums = [int(num) for num in f.readlines()]

for num in nums:
    reflection = int(str(num)[::-1])
    if is_prime(num) and is_prime(reflection):
        print(num)

Cały program:

from math import sqrt


def is_prime(n: int) -> bool:
    if n < 2:
        return False

    range_limit = int(sqrt(n)) + 1

    for i in range(2, range_limit):
        if n % i == 0:
            return False
    return True


with open("dane/liczby.txt", "r") as f:
    nums = [int(num) for num in f.readlines()]

for num in nums:
    reflection = int(str(num)[::-1])
    if is_prime(num) and is_prime(reflection):
        print(num)

Źródło: https://arkusze.pl/matura-informatyka-2022-czerwiec-poziom-rozszerzony/

Dla każdej liczby z pliku liczby.txt oblicz wartość bezwzględną różnicy tej liczby i jej odbicia.

Wyznacz taką liczbę n, dla której wartość bezwzględna różnicy tej liczby i jej odbicia jest największa. Podaj tę liczbę oraz wartość bezwzględną różnicy tej liczby i jej odbicia.

W pliku liczby.txt jest tylko jedna taka liczba.

Dla pliku przyklad.txt odpowiedzią jest 741 594.

Rozwiązanie:

Z treści zadania wynika, że:

W pliku liczby.txt zapisano 100 nieparzystych liczb całkowitych z przedziału [10, 9999]. Liczby w pliku mogą się powtarzać.

minimalna liczba wynosi 10, więc można bezpiecznie założyć początkową wartość największej liczby i największej różnicy jako 0:

with open("dane/przyklad.txt", "r") as f:
    nums = [int(num) for num in f.readlines()]

biggest_num = 0
biggest_diff = 0

Następnie przy pomocy prostej pętli obliczamy dla każdej liczby jej absolutną różnicę z jej odbiciem i wypisujemy wynik:

for num in nums:
    reflection = int(str(num)[::-1])
    diff = abs(num - reflection)
    if diff > biggest_diff:
        biggest_num = num
        biggest_diff = diff


print(f"{biggest_num} {biggest_diff}")

Cały program:

with open("dane/liczby.txt", "r") as f:
    nums = [int(num) for num in f.readlines()]

biggest_num = 0
biggest_diff = 0

for num in nums:
    reflection = int(str(num)[::-1])
    diff = abs(num - reflection)
    if diff > biggest_diff:
        biggest_num = num
        biggest_diff = diff


print(f"{biggest_num} {biggest_diff}")

Wynik:

1129 8082

Źródło: https://arkusze.pl/matura-informatyka-2022-czerwiec-poziom-rozszerzony/

Wyznacz odbicia wszystkich liczb z pliku liczby.txt. Wypisz te odbicia, które są podzielne przez 17.

Dla pliku przyklad.txt odpowiedzią jest 51.

Rozwiązanie:

Program jest typowo rozgrzewkowy i mieści się w kilka linijek. Jedyną "trudnością" może być odwrócenie cyfry :)

Cały program:

with open("dane/liczby.txt", "r") as f:
    nums = [int(num) for num in f.readlines()]

for num in nums:
    reflection = str(num)[::-1]
    if int(reflection) % 17 == 0:
        print(reflection)

Wynik:

1156
102
51
765
119
119
731

Źródło: https://arkusze.pl/matura-informatyka-2022-czerwiec-poziom-rozszerzony/

Dla każdej liczby z pliku liczby.txt znajdź jej reprezentację w systemie szesnastkowym. Dla każdej cyfry szesnastkowej podaj, ile razy występuje ona łącznie w zapisach szesnastkowych wszystkich liczb z pliku liczby.txt.

Rozwiązanie:

Najpierw odczytajmy liczby w systemie dziesiętnym z pliku:

with open("dane/liczby_przyklad.txt", "r") as file:
    nums = [int(n) for n in file.readlines()]

Następnie przekształcamy liczbę z systemu dziesiętnego na szesnastkowy, pamiętając, żeby usunąć przedrostek 0x - domyślnie funkcja hex dodaje go przed wlaściwą liczbą, np.: 0x123 . Metoda upper spowoduje zamienienie małych liter na duże, np.: a -> A itd. Wszystkie te przekształcenia można byłoby przerzucić do momentu, w którym odczytujemy dane z pliku, ale to może poprawić trochę czytelność :)

hex_nums = [hex(n).replace("0x", "").upper() for n in nums]

Generujemy słownik z cyframi w systemie szesnastkowym:

hex_digits = "0123456789ABCDEF"

results = {num: 0 for num in hex_digits}

domyślnie ustawiając im zero, jako wartość :)

Następne linijki to czysta formalność - dla każdej liczby i dla każdej jej cyfry zliczamy jej łączne wystąpienie. results.get(digit, 0) zapewnia pobranie wartości pod danym kluczem, a jeśli ta nie występuje, domyślnie będzie to 0 - tak dla pewności :)

for num in hex_nums:
    for digit in num:
        results[digit] = results.get(digit, 0) + 1

Pod kolejne klucze ("0", "1"... , "E", "F") przypisujemy wartość danego klucza + 1, żeby zliczyć wystąpienie kolejnej cyfry.

Teoretycznie od tego momentu mamy już rozwiązanie, ale możemy je jeszcze posortować i wyświetlić w oczekiwanym formacie, zamiast robić to ręcznie:

sorted_results = sorted(results.items(), key=lambda item: item[0])
for key, value in sorted_results:
    print(f"{key}:{value}")

Cały program:

with open("dane/liczby_przyklad.txt", "r") as file:
    nums = [int(n) for n in file.readlines()]

hex_nums = [hex(n).replace("0x", "").upper() for n in nums]

hex_digits = "0123456789ABCDEF"

results = {num: 0 for num in hex_digits}

for num in hex_nums:
    for digit in num:
        results[digit] = results.get(digit, 0) + 1

sorted_results = sorted(results.items(), key=lambda item: item[0])
for key, value in sorted_results:
    print(f"{key}:{value}")

Wynik:

0:32
1:26
2:37
3:31
4:43
5:25
6:28
7:23
8:38
9:28
A:45
B:33
C:29
D:23
E:44
F:10

Źródło arkusza: https://arkusze.pl/matura-probna-informatyka-2022-grudzien-poziom-rozszerzony/

Hipoteza Goldbacha głosi, że każda liczba parzysta większa od 2 jest sumą dwóch liczb pierwszych. Nie wiemy, czy ta hipoteza jest prawdziwa dla wszystkich liczb parzystych dodatnich, ale została potwierdzona dla wszystkich liczb „rozsądnej wielkości”, zwłaszcza dla nie przekraczających 1018. Oczywiście liczba może mieć więcej niż jeden rozkład na sumę dwóch liczb pierwszych, np. 22 = 19 + 3 = 17 + 5 = 11 + 11. Dla każdej z liczb z pliku liczby.txt rozstrzygnij, na ile różnych sposobów da się ją przedstawić jako sumę dwóch liczb pierwszych.

Podaj:

• liczbę, która ma najwięcej różnych rozkładów na sumę dwóch liczb pierwszych, oraz liczbę takich rozkładów

• liczbę, która ma najmniej różnych rozkładów na sumę dwóch liczb pierwszych, oraz liczbę takich rozkładów.

Uwaga: przyjmujemy, że dwa rozkłady są różne, jeśli nie zawierają takiej samej pary składników. Przykładowo: rozkłady 22 = 19 + 3 i 22 = 3 + 19 są takie same.

Dla pliku liczby_przyklad.txt odpowiedzią jest: 996 37 4 1 (liczba 996 ma 37 rozkładów, a 4 tylko jeden)

Rozwiązanie:

Na początku zdefiniujmy funkcję, która powie nam, czy dana funkcja jest liczbą pierwszą. Liczba pierwsza , jest liczbą naturalną większą od 1 oraz dzieli się przez 1 i samą siebie.

def is_prime(n: int) -> bool:
    if n < 2:
        return False

    range_limit = int(sqrt(n)) + 1

    for i in range(2, range_limit):
        if n % i == 0:
            return False
    return True

Nie ma sensu szukać zatem liczby pierwszej w zbiorze liczb mniejszych od 2. Zakładam, że do funkcji zostanie podana tylko liczba naturalna. Szukanie dzielnika liczby można ograniczyć do zakresu pierwiastka kwadratowego +1 - dla pewności :)

Później zdefiniujmy funkcję o nazwie goldbach, która zwróci nam listę z wszystkimi parami liczb pierwszych, których suma wynosi liczbę z parametru. Szukamy par do połowy + 1 liczby - gdybyśmy szukali do końca, wartości zaczęłbyby się powtarzać (w odwrotnej kolejności, np.: [3, 5] <=> [5,3] co nie jest różnym składnikiem).

def goldbach(n: int) -> list[[int, int]]:
    results = []
    for i in range(2, n // 2 + 1):
        difference = n - i
        if is_prime(i) and is_prime(difference):
            results.append([i, difference])

    return results

Ważnym warunkiem jest sprawdzenie, czy obydwie liczby są liczbami pierwszymi :)

with open("dane/liczby.txt", "r") as file:
    nums = [int(n) for n in file.readlines()]

Następnie otwieramy plik z danymi i każdy wiersz przekształcamy na int.

unique_nums = set(nums)
even_nums = filter(lambda x: x % 2 == 0, unique_nums)

W dwóch kolejnych linijkach używamy set , co pozwoli nam pozbyć się duplikatów z listy nums a następnie dla zmiennej even_nums filtrujemy listę unique_nums , żeby zawierała tylko wartości parzyste.

goldbach_results = map(
    lambda num: {"number": num, "total_sums": len(goldbach(num))}, even_nums)

sorted_goldbach_results = sorted(
    goldbach_results, key=lambda res: res['total_sums'])

print(f"lower goldbach result: {sorted_goldbach_results[0]}")
print(f"higher goldbach result: {sorted_goldbach_results[-1]}")

Następnie dla każdego numeru w even_nums zwracamy dict o strukturze:

{"number": num, "total_sums": len(goldbach(num))}

gdzie do number jest przypisywany aktualny numer, a do total_sums ilość par, które sumują się do wskazanej liczby pod właściwością number.

Sortujemy wyniki po właściwości total_sums, żeby móc łatwo wydobyć
liczbę, która ma najmniej / najwięcej różnych rozkładów na sumę dwóch liczb pierwszych, oraz liczbę takich rozkładów , co robimy w print 'ach :)

Cały program:

from math import sqrt


def is_prime(n: int) -> bool:
    if n < 2:
        return False

    range_limit = int(sqrt(n)) + 1

    for i in range(2, range_limit):
        if n % i == 0:
            return False
    return True


def goldbach(n: int) -> list[[int, int]]:
    results = []
    for i in range(2, n // 2 + 1):
        difference = n - i
        if is_prime(i) and is_prime(difference):
            results.append([i, difference])

    return results


with open("dane/liczby.txt", "r") as file:
    nums = [int(n) for n in file.readlines()]

unique_nums = set(nums)
even_nums = filter(lambda x: x % 2 == 0, unique_nums)

goldbach_results = map(
    lambda num: {"number": num, "total_sums": len(goldbach(num))}, even_nums)

sorted_goldbach_results = sorted(
    goldbach_results, key=lambda res: res['total_sums'])

print(f"lower goldbach result: {sorted_goldbach_results[0]}")
print(f"higher goldbach result: {sorted_goldbach_results[-1]}")

Wymaga na pewno optymalizacji czasowej, ale na pewno nie można powiedzieć, że "nie działa" :)

Wynik:

(liczba | ilość rozkładów)

910620 9932
18676 195

Źródło arkusza: https://arkusze.pl/matura-probna-informatyka-2022-grudzien-poziom-rozszerzony/

Dla każdej liczby x z pliku liczby.txt sprawdź, czy liczba x – 1 jest liczbą pierwszą. Podaj, ile liczb z pliku liczby.txt po pomniejszeniu o 1 daje liczbę pierwszą.

Dla pliku liczby_przyklad.txt odpowiedzią jest 94.

Rozwiązanie:

Na początku zdefiniujmy funkcję, która powie nam, czy dana funkcja jest liczbą pierwszą. Liczba pierwsza , jest liczbą naturalną większą od 1 oraz dzieli się przez 1 i samą siebie.

def is_prime(n: int) -> bool:
    if n < 2:
        return False

    range_limit = int(sqrt(n)) + 1

    for i in range(2, range_limit):
        if n % i == 0:
            return False
    return True

Nie ma sensu szukać zatem liczby pierwszej w zbiorze liczb mniejszych od 2. Zakładam, że do funkcji zostanie podana tylko liczba naturalna. Szukanie dzielnika liczby można ograniczyć do zakresu pierwiastka kwadratowego +1 - dla pewności :)

with open("dane/liczby.txt", "r") as file:
    nums = [int(n) for n in file.readlines()]

Następnie otwieramy plik z danymi i każdy wiersz przekształcamy na int.

total = 0

for num in nums:
    if is_prime(num - 1):
        total += 1

print(total)

Zostaje nam tylko zliczyć, ile liczb, od których zostało odjęte 1, jest liczbami pierwszymi!

Cały program:

from math import sqrt


def is_prime(n: int) -> bool:
    if n < 2:
        return False

    range_limit = int(sqrt(n)) + 1

    for i in range(2, range_limit):
        if n % i == 0:
            return False
    return True


with open("dane/liczby.txt", "r") as file:
    nums = [int(n) for n in file.readlines()]

total = 0

for num in nums:
    if is_prime(num - 1):
        total += 1

print(total)

Wynik:

21 liczb - uruchom program poniżej!

Źródło arkusza: https://arkusze.pl/matura-probna-informatyka-2022-grudzien-poziom-rozszerzony/