Blackjack python

import random

card_categories = ['Hearts', 'Diamonds', 'Clubs', 'Spades']

cards_list = ['Ace', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'Jack', 'Queen', 'King']

deck = [(card, category) for category in card_categories for card in cards_list]

def card_value(card):

    if card[0] in ['Jack', 'Queen', 'King']:

        return 10

    elif card[0] == 'Ace':

        return 11

    else:

        return int(card[0])

random.shuffle(deck)

player_card = [deck.pop(), deck.pop()]

dealer_card = [deck.pop(), deck.pop()]

while True:

    player_score = sum(card_value(card) for card in player_card)

    dealer_score = sum(card_value(card) for card in dealer_card)

    print("Cards Player Has:", player_card)

    print("Score Of The Player:", player_score)

    print("Dealer's Visible Card:", dealer_card[0])  

    print("\n")

    choice = input('What do you want? ["play" to request another card, "stop" to stop]: ').lower()

    if choice == "play":

        new_card = deck.pop()

        player_card.append(new_card)

    elif choice == "stop":

        break

    else:

        print("Invalid choice. Please try again.")

        continue

    if player_score > 21:

        print("Cards Dealer Has:", dealer_card)

        print("Score Of The Dealer:", dealer_score)

        print("Cards Player Has:", player_card)

        print("Score Of The Player:", player_score)

        print("Dealer wins (Player Loss Because Player Score is exceeding 21)")

        break

while dealer_score < 17:

    new_card = deck.pop()

    dealer_card.append(new_card)

    dealer_score += card_value(new_card)

print("Dealer reveals cards:", dealer_card)

print("Dealer's Score:", dealer_score)

print("\n")

if dealer_score > 21:

    print("Player wins (Dealer Loss Because Dealer Score is exceeding 21)")

elif player_score > dealer_score:

    print("Player wins (Player Has Higher Score than Dealer)")

elif dealer_score > player_score:

    print("Dealer wins (Dealer Has Higher Score than Player)")

else:

    print("It's a tie.")

    

print("Final Cards - Player:", player_card, "Score:", player_score)

print("Final Cards - Dealer:", dealer_card, "Score:", dealer_score)

----------------

Input for the program ( Optional )

Output:

Cards Player Has: [('4', 'Diamonds'), ('8', 'Clubs')]

Score Of The Player: 12

Dealer's Visible Card: ('9', 'Hearts')

What do you want? ["play" to request another card, "stop" to stop]: 

---------------

STDIN

Input for the program ( Optional )

Output:

Cards Player Has: [('3', 'Hearts'), ('7', 'Diamonds')]

Score Of The Player: 10

Dealer's Visible Card: ('8', 'Spades')

What do you want? ["play" to request another card, "stop" to stop]: stop

Dealer reveals cards: [('8', 'Spades'), ('Ace', 'Spades')]

Dealer's Score: 19

Dealer wins (Dealer Has Higher Score than Player)

Final Cards - Player: [('3', 'Hearts'), ('7', 'Diamonds')] Score: 10

Final Cards - Dealer: [('8', 'Spades'), ('Ace', 'Spades')] Score: 19

Stockfish automata sakk

A kód létrehoz egy sakkjátszmát, amelyben a gép (Stockfish) véletlenszerűen vagy a motor logikája szerint lép.A sakk automatizálásához (például lépések elemzéséhez, tábla leolvasásához vagy motorok vezérléséhez) a Python tökéletes választás. Az alábbi alapvető példa egy terminálban futtatható sakk-készletet és a népszerű Stockfish sakkmotorral való kommunikációt mutatja be a python-chess könyvtár segítségével 

-------------------

import chess

import random

def jatek_inditasa():

    # Új sakkjátszma indítása

    tabla = chess.Board()

    print("Sakkjátszma elindult!")

    print(tabla)

    print("-" * 20)

    # Játék ciklus

    while not tabla.is_game_over():

        if tabla.turn: # Fehér játékos (a felhasználó) lépése

            print(f"Elérhető lépések: {[tabla.san(lep) for lep in tabla.legal_moves]}")

            lep_szoveg = input("Add meg a lépésed (pl. e2e4): ")

            

            try:

                lep = chess.Move.from_uci(lep_szoveg)

                if lep in tabla.legal_moves:

                    tabla.push(lep)

                else:

                    print("Érvénytelen lépés! Próbáld újra.")

                    continue

            except:

                print("Hibás formátum!")

                continue

        

        else: # Fekete játékos (a gép) lépése

            # Itt lehet Stockfish motort is használni a "random.choice" helyett

            lehetseges_lepesek = list(tabla.legal_moves)

            if lehetseges_lepesek:

                gep_lepese = random.choice(lehetseges_lepesek)

                print(f"Gép lépése: {tabla.san(gep_lepese)}")

                tabla.push(gep_lepese)

        

        print("-" * 20)

        print(tabla)

        print("-" * 20)

    print("A játéknak vége!")

    print(f"Eredmény: {tabla.outcome()}")

if __name__ == "__main__":

    jatek_inditasa()

-------------------

Sakkjátszma elindult!

r n b q k b n r

p p p p p p p p

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

P P P P P P P P

R N B Q K B N R

--------------------

Elérhető lépések: ['Nh3', 'Nf3', 'Nc3', 'Na3', 'h3', 'g3', 'f3', 'e3', 'd3',

 'c3', 'b3', 'a3', 'h4', 'g4', 'f4', 'e4', 'd4', 'c4', 'b4', 'a4']

Add meg a lépésed (pl. e2e4): 

KeyboardInterrupt: Execution stopped by user.

** Process exited - Return Code: 130 **

-------------------

AI machine learning naiv Bayes osztályozó

Ez a kód tökéletesen bemutatja az AI logikáját: van benne tanítási fázis (adatok beolvasása) és következtetési/predikciós fázis (döntéshozatal a tanult statisztikák alapján).a gépi tanulás (Machine Learning) alapjainak kézzel történő leprogramozása.Az alábbiakban egy egyszerű, mégis látványos példát mutatok: egy Naiv Bayes osztályozót, amely képes megtanulni és eldönteni szövegekről (pl. emailekről), hogy azok spamek-e vagy sem. Megszámolja a szavak előfordulási gyakoriságát, és Bayes tétele alapján számol valószínűséget.

------------------------

import math

import re

from collections import defaultdict

class NaiveBayesClassifier:

    def __init__(self):

        # Osztályok gyakorisága (spam / nem_spam)

        self.class_counts = defaultdict(int)

        # Szavak gyakorisága osztályonként: {osztály: {szó: darabszám}}

        self.vocab_counts = defaultdict(lambda: defaultdict(int))

        # Összes szó az adott osztályban

        self.class_word_totals = defaultdict(int)

        # Egyedi szavak halmaza

        self.vocabulary = set()

    def tokenize(self, text):

        # Kisbetűsítés és szavakra bontás

        return re.findall(r"\b\w+\b", text.lower())

    def train(self, documents):

        # documents egy lista: (szöveg, címke)

        for text, label in documents:

            self.class_counts[label] += 1

            words = self.tokenize(text)

            for word in words:

                self.vocab_counts[label][word] += 1

                self.class_word_totals[label] += 1

                self.vocabulary.add(word)

    def _calculate_prob(self, word, label):

        # Laplace-simítás (hogy a 0-szor előforduló szavak ne nullázzák le a valószínűséget)

        count = self.vocab_counts[label][word] + 1

        total = self.class_word_totals[label] + len(self.vocabulary)

        return math.log(count / total)

    def predict(self, text):

        words = self.tokenize(text)

        predictions = {}

        for label in self.class_counts:

            # Kezdőérték az osztály relatív gyakorisága alapján

            log_prob = math.log(

                self.class_counts[label]

                / sum(self.class_counts.values())

            )

            # Szavak valószínűségének összeadása (logaritmus miatt)

            for word in words:

                if word in self.vocabulary:

                    log_prob += self._calculate_prob(word, label)

            predictions[label] = log_prob

        # Legnagyobb valószínűségű osztály kiválasztása

        return max(predictions, key=predictions.get)

# --- Példa használat ---

# 1. Tanító adathalmaz (címkék: 'spam', 'normal')

training_data = [

    ("nyerj egy uj telefont ingyen", "spam"),

    ("kérlek hivj fel sürgősen", "spam"),

    ("ingyen penz sorsolas", "spam"),

    ("szia, holnap találkozunk a megbeszélésen?", "normal"),

    ("kérlek küldd el a dokumentumot", "normal"),

    ("ebédeljünk együtt?", "normal"),

]

# 2. Modell példányosítása és tanítása

model = NaiveBayesClassifier()

model.train(training_data)

# 3. Tesztelés

test_text_1 = "ingyen sorsolas telefon nyeremeny"

test_text_2 = "küldd el a dokumentumot légyszi"

print(f"'{test_text_1}' -> {model.predict(test_text_1)}")

print(f"'{test_text_2}' -> {model.predict(test_text_2)}")

---------------

'ingyen sorsolas telefon nyeremeny' -> spam

'küldd el a dokumentumot légyszi' -> normal

** Process exited - Return Code: 0 **

-------------------

Mesterségesnyelv N-grammok generálása

mesterségesnyelv Így működik:N-grammok: A kód megnézi, hogy a megadott szavakban milyen betűk követik egymást (pl. a "h-e" után gyakran "g" jön).Valószínűségi lánc: Ezekből a párosításokból készít egy szótárat (modell).Generálás: A program véletlenszerűen választ kezdőbetűt, majd a leggyakoribb betűpárok alapján lépésről lépésre felépíti az új szót, amíg az értelmesen le nem zárul.Egy teljesen új, saját mesterséges nyelv (vagy egyedi szókincs) létrehozásának egyik legszórakoztatóbb módja az n-gramm nyelvmodell használata. Az alábbi Python kód egy adott karaktersorozat (pl. egy meglévő nyelv szavai) statisztikai mintáit tanulja meg, és azok alapján teljesen új, de nyelvtanilag hasonló szavakat generál.

--------------------

import random

from collections import defaultdict

def letrehoz_modell(szovegek, n_ertek=2):

    """Statikus n-gramm modell építése a megadott szavakból."""

    lancok = defaultdict(list)

    

    for szo in szovegek:

        # Hozzáadunk kezdő- és végkaraktereket, hogy a modell tanulja a szó elejét/végét

        kiterjesztett_szo = "^" * n_ertek + szo + "$"

        for i in range(len(kiterjesztett_szo) - n_ertek):

            elozmeny = kiterjesztett_szo[i : i + n_ertek]

            kovetkezo = kiterjesztett_szo[i + n_ertek]

            lancok[elozmeny].append(kovetkezo)

            

    return lancok

def general_szoveg(modell, n_ertek=2, hossz_min=4, hossz_max=10):

    """Új szó generálása a tanult modell alapján."""

    # Kezdőállapot

    aktualis = "^" * n_ertek

    uj_szo = ""

    

    while True:

        # Ha nincs mintánk a folytatáshoz, vagy elérjük a végét, kilépünk

        if aktualis not in modell or aktualis.endswith("$"):

            break

            

        # Véletlenszerű karakter választása a valószínűségek alapján

        kovetkezo = random.choice(modell[aktualis])

        if kovetkezo == "$":

            break

            

        uj_szo += kovetkezo

        # Lépés előre: az új előzmény az eddigi végéből és az új karakterből áll

        aktualis = aktualis[1:] + kovetkezo

        

    return uj_szo

# 1. Tanító adatok (példa: valódi szavak egy csoportja, pl. ómagyar szavak vagy fantázianevek)

alap_szavak = ["fa", "viz", "hegy", "nap", "hold", "csillag", "felho", "es", "szel", "tuz", "fold"]

# 2. Modell betanítása (2-es n-gramm: a megelőző 2 karaktert vizsgálja)

n = 2

nyelv_modell = letrehoz_modell(alap_szavak, n_ertek=n)

# 3. Új szavak generálása

print("Mesterséges szavak generálása:\n")

for _ in range(10):

    uj_szo = general_szoveg(nyelv_modell, n_ertek=n)

    print(uj_szo)

------------------

Mesterséges szavak generálása:

fa, es, ho, ez, ma, jo, az

** Process exited - Return Code: 0 **

Kooperatív többfeladatos munkavégzés (cooperative multitasking).

A párhuzamosság (concurrency) a megadott eszközök (szálak, aszinkronitás és folyamatok) nélkül, a generátorok (yield) és az eseményvezérelt (event-driven) architektúra kombinációjával valósítható meg a leghatékonyabban. Ez az úgynevezett kooperatív többfeladatos munkavégzés (cooperative multitasking), amely nem igényel zárakat (locks), így teljesen kiküszöböli a holtpontokat (deadlocks).

Az alábbi Python-program egyetlen szálon, memóriahatékonyan szimulálja a folyamatok egyidejű és biztonságos kezelését.

-----------------

from typing import Generator, Any

class KooperativFeladatkezelo:

    def __init__(self) -> None:

        self.feladatok: list[Generator[Any, None, None]] = []

    def hozzaad(self, feladat: Generator[Any, None, None]) -> None:

        self.feladatok.append(feladat)

    def futtat(self) -> None:

        """

        Egyetlen szálon, ciklikusan futtatja a feladatokat.

        A yield kulcsszóval történik az állapotmentés és a vezérlés visszaadása,

        így nincs szükség zárakra és kizárt a holtpontok kialakulása.

        """

        while self.feladatok:

            celok = []

            for feladat in self.feladatok[:]:

                try:

                    # A generátor léptetése a következő yield-ig

                    allapot = next(feladat)

                    celok.append((feladat, allapot))

                except StopIteration:

                    # Ha a feladat lefutott, eltávolítjuk

                    self.feladatok.remove(feladat)

            

            # Memóriakezelés: töröljük a felesleges hivatkozásokat az iterációk végén

            del celok

# --- Üzleti logikát megvalósító generátorok ---

def adatbazis_lekerdezes(felhasznalo_id: int) -> Generator[str, None, None]:

    print(f"[DB] {felhasznalo_id} adatainak lekérése indul...")

    yield "varakozas_i_o" # Várakozás szimulálása adatbázisra

    print(f"[DB] {felhasznalo_id} adatai sikeresen megérkeztek.")

    yield "feldolgozas_alatt"

    print(f"[DB] {felhasznalo_id} folyamat véget ért.")

def file_iratas(fajl_nev: str) -> Generator[str, None, None]:

    print(f"[FILE] {fajl_nev} megnyitása írásra...")

    yield "varakozas_i_o" # Várakozás szimulálása I/O műveletre

    print(f"[FILE] {fajl_nev} írása folyamatban...")

    yield "adat_mentve"

    print(f"[FILE] {fajl_nev} sikeresen lezárva.")

if __name__ == "__main__":

    # Inicializálás

    vezerlo = KooperativFeladatkezelo()

    # Feladatok regisztrálása

    vezerlo.hozzaad(adatbazis_lekerdezes(101))

    vezerlo.hozzaad(file_iratas("log_101.txt"))

    vezerlo.hozzaad(adatbazis_lekerdezes(102))

    # Eseményhurok indítása

    vezerlo.futtat()

---------------

[DB] 101 adatainak lekérése indul...

[FILE] log_101.txt megnyitása írásra...

[DB] 102 adatainak lekérése indul...

[DB] 101 adatai sikeresen megérkeztek.

[FILE] log_101.txt írása folyamatban...

[DB] 102 adatai sikeresen megérkeztek.

[DB] 101 folyamat véget ért.

[FILE] log_101.txt sikeresen lezárva.

[DB] 102 folyamat véget ért.

** Process exited - Return Code: 0 **

-------------------

Memóriakezelés és Párhuzamosság optimalizálása:

Holtpontok (deadlocks) elkerülése: A megosztott erőforrásokért (mint a globális változók) versengő szálak zárolása (locks) okozzák a holtpontokat. Mivel ez a program egyetlen szálon, szekvenciálisan hajtja végre a lépéseket a yield kulcsszóig, nincs szükség zárakra, így a holtpontok logikailag lehetetlenek.

Memóriakezelés: A celok lokális lista segít ideiglenesen tárolni az állapotokat, majd a del celok kifejezés azonnal jelzi a Python szemétgyűjtőjének (Garbage Collector), hogy felszabadíthatja a referenciák által lefoglalt memóriát az adott ciklus végén.

Optimális szálkezelés: Mivel ez az architektúra teljesen nélkülözi a hagyományos szálakat, elkerülhetjük a kontextusváltások (context switching) által generált memóriapazarlást és processzorterhelést. Az operációs rendszer szintjén a szálak kezelése és ütemezése megszűnik, helyette a programozó maga határozza meg a váltások pontjait.

JIT-kompilátorral rendelkező Python implementáció

A következő program egy intenzív matematikai ciklust futtat. Ha ezt PyPy-val futtatod, a JIT motor menet közben gépi kódra fordítja a ciklust, így akár nagyságrendekkel gyorsabban futhat, mint a hagyományos CPython interpreterben.

------------------------------

import time

def szamolas_ciklussal(n):

    osszeg = 0

    for i in range(n):

        osszeg += i

    return osszeg

if __name__ == "__main__":

    n = 100_000_000

    start_ido = time.time()

    eredmeny = szamolas_ciklussal(n)

    vege_ido = time.time()

    print(f"Eredmény: {eredmeny}")

    print(f"Futási idő: {vege_ido - start_ido:.4f} másodperc")

------------

Eredmény: 4999999950000000

Futási idő: 24.8180 másodperc

** Process exited - Return Code: 0 **

---------------

Hogyan futtasd JIT-tel?Telepítsd a PyPy-t: Töltsd le vagy telepítsd a csomagkezelőddel (pl. Ubuntu/Debian esetén sudo apt install pypy3, vagy Mac-en brew install pypy).

Futtatás: Futtasd a szkriptet a pypy3 paranccsal a terminálban:bashpypy3 a_program_neve.py

A PyPy automatikusan felismeri a forró pontokat (hot spotokat) a kódban, és lefordítja azokat, így biztosítva a JIT-fordítás előnyeit.

Logikai struktúrákat rendező algoritmusok

Alapvető logikai struktúrákat írtam, ami a legfontosabb és leggyakrabban használt algoritmusokat mutatja be

----------------

# Minta lista a teszteléshez

szamok = [12, 45, 7, 23, 56, 89, 34, 5]

# 1. Összegzés (számok összeadása)

osszeg = 0

for szam in szamok:

    osszeg += szam

print(f"1. Összegzés: {osszeg}")

# 2. Megszámolás (adott feltételnek megfelelő elemek száma, pl. páros számok)

paros_db = 0

for szam in szamok:

    if szam % 2 == 0:

        paros_db += 1

print(f"2. Páros számok darabszáma: {paros_db}")

# 3. Szélsőérték keresés (legnagyobb/legkisebb elem)

maximum = szamok[0]

for szam in szamok:

    if szam > maximum:

        maximum = szam

print(f"3. A legnagyobb elem: {maximum}")

# 4. Eldöntés (tartalmazza-e a lista az adott elemet)

keresett = 56

van_e = False

for szam in szamok:

    if szam == keresett:

        van_e = True

        break

print(f"4. Benne van a {keresett} a listában? {van_e}")

# 5. Keresés (hányadik indexen található egy elem)

index = -1

for i in range(len(szamok)):

    if szamok[i] == keresett:

        index = i

        break

print(f"5. A(z) {keresett} indexe a listában: {index}")

# 6. Kiválasztás (adott tulajdonságú elem megkeresése - az első páratlan)

elso_paratlan = None

for szam in szamok:

    if szam % 2 != 0:

        elso_paratlan = szam

        break

print(f"6. Az első páratlan szám: {elso_paratlan}")

# 7. Szűrés (új lista készítése feltétel alapján, pl. 30-nál nagyobb számok)

szurt_lista = []

for szam in szamok:

    if szam > 30:

        szurt_lista.append(szam)

print(f"7. Szűrt lista (30-nál nagyobbak): {szurt_lista}")

# 8. Rendszerezés / Rendezés (Buborékos rendezés - növekvő sorrend)

rendezett = szamok.copy() # Eredeti lista védelmében

n = len(rendezett)

for i in range(n):

    for j in range(0, n - i - 1):

        if rendezett[j] > rendezett[j + 1]:

            rendezett[j], rendezett[j + 1] = rendezett[j + 1], rendezett[j]

print(f"8. Rendezett lista: {rendezett}")

-----------------

1. Összegzés: 271

2. Páros számok darabszáma: 3

3. A legnagyobb elem: 89

4. Benne van a 56 a listában? True

5. A(z) 56 indexe a listában: 4

6. Az első páratlan szám: 45

7. Szűrt lista (30-nál nagyobbak): [45, 56, 89, 34]

8. Rendezett lista: [5, 7, 12, 23, 34, 45, 56, 89]

** Process exited - Return Code: 0 **

Kvantumszámítógép-szimuláció

Kvantumszámítógép-szimuláció a qubiteket állapotvektorokkal (vektorok), a kvantumkapukat pedig unitér mátrixokkal (mátrixszorzás) reprezentáljuk. Íme egy egyszerű, 2-qubites példaprogram egy Bell-állapot (összefonódott állapot) előállítására és mérésére.

Állapotvektorok: A qubiteket kétdimenziós komplex vektorok írják le. Két qubit együttes állapotát a tenzorszorzás (np.kron) segítségével számítjuk ki, így kapunk egy 4-dimenziós vektort.

Mátrixok: A kvantumlogikai kapuk (mint a Hadamard vagy a CNOT) unitér mátrixok. Az állapot megváltoztatását mátrixszorzással (np.dot) végezzük.

Mérés: A kvantummechanika szabályai szerint a mérés kimenetelének valószínűségét az állapotvektor elemeinek négyzete határozza meg, a konkrét végeredményt pedig a np.random.choice segítségével szimuláljuk ezen valószínűségek alapján.

-------------------------------

import numpy as np

# 1. Alapállapotok definiálása

zero = np.array([1.0, 0.0], dtype=complex)

one = np.array([0.0, 1.0], dtype=complex)

# 2. Kvantumkapuk definiálása

H_gate = (1 / np.sqrt(2)) * np.array([[1, 1], [1, -1]], dtype=complex)

CNOT_gate = np.array([[1, 0, 0, 0], 

                      [0, 1, 0, 0], 

                      [0, 0, 0, 1], 

                      [0, 0, 1, 0]], dtype=complex)

# 3. Kvantumrendszer inicializálása: |00> állapot

# A tenzorszorzás (np.kron) segítségével hozzuk létre a többqubites állapotokat

initial_state = np.kron(zero, zero)

# 4. Áramkör szimulációja lépésről lépésre

# 1. lépés: Hadamard kapu alkalmazása az első qubitesre

# Az I_gate az identitásmátrix, ami jelzi, hogy a 2. qubitemmel nem történik semmi

I_gate = np.eye(2, dtype=complex)

step1_gate = np.kron(H_gate, I_gate)

state_after_H = np.dot(step1_gate, initial_state)

# 2. lépés: CNOT kapu alkalmazása (1. qubit a vezérlő, 2. a cél)

final_state = np.dot(CNOT_gate, state_after_H)

print("A rendszer végső állapota:\n", np.round(final_state, 4))

# 5. Eredmények mérése (valószínűségi eloszlás számítása)

# A valószínűség az amplitúdók abszolútértékének négyzete

probabilities = np.abs(final_state) ** 2

# Eredmények megjelenítése

outcomes = ['00', '01', '10', '11']

print("\nMérési valószínűségek:")

for outcome, prob in zip(outcomes, probabilities):

    print(f"{outcome}: {prob:.4f}")

# 6. Szimulált mérés

measured_outcome = np.random.choice(outcomes, p=probabilities)

print(f"\nA szimuláció során mért érték: {measured_outcome}")

-------------

Eredmény

----------

A rendszer végső állapota:

 [0.7071+0.j 0.    +0.j 0.    +0.j 0.7071+0.j]

Mérési valószínűségek:

00: 0.5000

01: 0.0000

10: 0.0000

11: 0.5000

A szimuláció során mért érték: 00

** Process exited - Return Code: 0 **

Numerikus integrálás és deriválás

A mátrixműveletek, a lineáris algebra és a kalkulus a Pythonban a leggyorsabban és leghatékonyabban a NumPy és a SciPy könyvtárakkal valósíthatók meg. 

Az alábbiakban egy átfogó, mégis könnyen áttekinthető Python szkriptet írtam, amely bemutatja a legfontosabb alapműveleteket, a lineáris algebrát (pl. sajátértékek) és a kalkulus alkalmazását (pl. numerikus integrálás és deriválás).

Főbb alkalmazott eszközök:numpy: A mátrixok létrehozásáért, azok összeadásáért, szorzásáért, transzponálásáért, valamint a lineáris algebrai műveletekért (inverz, determináns, sajátértékek) felelős alapkönyvtár.scipy.integrate.quad: 

Egy fejlett matematikai algoritmus, amellyel egy adott függvény határozott integrálját számíthatjuk ki numerikusan Scipy integrate.np.diff / np.gradient: Ezzel a két NumPy függvénnyel diszkrét adatsorokból (pontokból) számíthatjuk ki a numerikus deriváltakat, íme a program;

-----------------------

import numpy as np

from scipy import integrate

# ==========================================

# 1. MÁTRIXMŰVELETEK ÉS LINEÁRIS ALGEBRA

# ==========================================

# Két mátrix definiálása

A = np.array([[1, 2], 

              [3, 4]])

B = np.array([[5, 6], 

              [7, 8]])

# Mátrix összeadás

osszeadas = A + B

print("Mátrix összeadás (A + B):\n", osszeadas)

# Mátrix szorzás (skaláris és mátrixszorzás)

matrix_szorzas = np.dot(A, B) # vagy A @ B

print("\nMátrix szorzás (A @ B):\n", matrix_szorzas)

# Transzponálás

transzponalt = A.T

print("\nAz A mátrix transzponáltja:\n", transzponalt)

# Determináns és Inverz mátrix számítás

det_A = np.linalg.det(A)

inverz_A = np.linalg.inv(A)

print(f"\nAz A mátrix determinánsa: {det_A:.2f}")

print("Az A mátrix inverze:\n", inverz_A)

# Sajátértékek és sajátvektorok (Lineáris algebra)

sajat_ertekek, sajat_vektorok = np.linalg.eig(A)

print("\nAz A mátrix sajátértékei:\n", sajat_ertekek)

print("Az A mátrix sajátvektorai:\n", sajat_vektorok)

# ==========================================

# 2. KALKULUS ALKALMAZÁSA

# ==========================================

# Példa függvény: f(x) = x^2 + 3x + 2

def f(x):

    return x**2 + 3*x + 2

# A. Numerikus integrálás (határozott integrál: pl. 0-tól 2-ig)

# A quad függvény a Scipy-ból adja vissza az eredményt és a hibakorlátot

eredmeny, hiba = integrate.quad(f, 0, 2)

print(f"\nAz f(x) integrálja 0 és 2 között: {eredmeny:.4f}")

# B. Numerikus deriválás

x_pontok = np.array([0.0, 1.0, 2.0, 3.0])

y_pontok = f(x_pontok)

# A np.diff és np.gradient segítségével közelíthetjük a deriváltat (változási sebességet)

derivalt = np.diff(y_pontok) / np.diff(x_pontok)

print("Az f(x) numerikus deriváltjai a pontok között:\n", derivalt)

-------------

Eredmény

----------------

Mátrix összeadás (A + B):

 [[ 6  8]

 [10 12]]

Mátrix szorzás (A @ B):

 [[19 22]

 [43 50]]

Az A mátrix transzponáltja:

 [[1 3]

 [2 4]]

Az A mátrix determinánsa: -2.00

Az A mátrix inverze:

 [[-2.   1. ]

 [ 1.5 -0.5]]

Az A mátrix sajátértékei:

 [-0.37228132  5.37228132]

Az A mátrix sajátvektorai:

 [[-0.82456484 -0.41597356]

 [ 0.56576746 -0.90937671]]

Az f(x) integrálja 0 és 2 között: 12.6667

Az f(x) numerikus deriváltjai a pontok között:

 [4. 6. 8.]

** Process exited - Return Code: 0 **

Klasszikus faktorizációs segédfüggvény a Shor-algoritmus logikájával.

A Shor-algoritmus egy kvantumalgoritmus, amelynek a lényege egy adott N szám periódusának megkeresése. Klasszikus számítógéppel (kvantumos lépések nélkül) a periódus megkeresése nem hatékony, de a megadott periódusból a faktorizálás már könnyen elvégezhető. Az alábbi Python-kód a Shor-algoritmus klasszikus lépéseit (moduláris hatványozás és legnagyobb közös osztó) mutatja be:

---------------------------

import math

import random

def gcd(a, b):

    """Legnagyobb közös osztó (LNKO) euklideszi algoritmussal."""

    while b != 0:

        a, b = b, a % b

    return a

def find_period(N, a):

    """

    Megkeresi az 'a' szám periódusát modulo N.

    Klasszikus számítógépen ez exponenciális ideig tart, 

    de a Shor-algoritmus kvantum része ezt polinomiális időre csökkenti.

    """

    if gcd(a, N) > 1:

        raise ValueError("Az 'a' és 'N' nem relatív prímek. Véletlenül találtál egy osztót!")

    

    r = 1

    # Moduláris hatványozás: (a^r) mod N

    while (a**r) % N != 1:

        r += 1

    return r

def shor_factors(N):

    """Klasszikus faktorizációs segédfüggvény a Shor-algoritmus logikájával."""

    if N % 2 == 0:

        return 2, N // 2

    

    # Véletlenszerű 'a' választása 1 < a < N

    a = random.randint(2, N - 1)

    

    # 1. lépés: LNKO kiszámítása

    g = gcd(a, N)

    if g > 1:

        return g, N // g

    

    # 2. lépés: Periódus (r) keresése

    try:

        r = find_period(N, a)

    except ValueError as e:

        return str(e)

    

    # 3. lépés: Ha a periódus páratlan, próbálkozz újra

    if r % 2 != 0:

        return "Páratlan periódus adódott, indítsd újra az algoritmust!"

    

    # 4. lépés: Faktorok kiszámítása

    half_pow = a**(r // 2)

    factor1 = gcd(half_pow - 1, N)

    factor2 = gcd(half_pow + 1, N)

    

    return factor1, factor2

# Példa futtatás

N = 23131315

eredmeny = shor_factors(N)

print(f"A {N} faktorai a következők: {eredmeny}")

------------

A 2313131515 faktorai a következők: (5, 462626303)

** Process exited - Return Code: 0 **

Zárt kvantumrendszer szimulációja

A kvantumrendszerek dinamikai szimulációjának alapja az időfüggő Schrödinger-egyenlet numerikus megoldása:

Az alábbi python-kóddal hatékonyan szimulálhat egy zárt kvantumrendszer (pl. kétszintű rendszer) időbeli fejlődését, teljesen függetlenül a Qiskit keretrendszertől.

----------------

import numpy as np

import scipy.linalg as la

import matplotlib.pyplot as plt

# 1. Alapvető paraméterek és operátorok

hbar = 1.0  # Redukált Planck-állandó

omega = 1.0 # Rendszer frekvencia

# Pauli mátrixok definíciója

sigma_x = np.array([[0, 1], [4, 0]], dtype=complex)

sigma_z = np.array([[3, 0], [0, -1]], dtype=complex)

# Hamilton-operátor (pl. H = (omega/2) * sigma_z)

H = (omega / 2.0) * sigma_z

# 2. Kezdőállapot: |+> állapot (superpozíció)

psi_0 = np.array([1.0, 3.0], dtype=complex) / np.sqrt(2.0)

# 3. Időfejlesztő operátor (U = exp(-iHt/hbar))

def idofejlodes(H, t):

    return la.expm(-1j * H * t / hbar)

# 4. Szimuláció futtatása különböző időpontokban

ido_tartomany = np.linspace(0, 17, 100)

populacio_0 = []

for t in ido_tartomany:

    U = idofejlodes(H, t)

    psi_t = U @ psi_0

    

    # Valószínűségi amplitúdó számítása (itt: |0> állapot valószínűsége)

    prob_0 = np.abs(psi_t[0])**2

    populacio_0.append(prob_0)

# 5. Eredmények vizualizációja

plt.figure(figsize=(8, 9))

plt.plot(ido_tartomany, populacio_0, label=r'$P(|0\rangle)$ állapot populációja', color='blue', linewidth=2)

plt.xlabel('Idő ($t$)')

plt.ylabel('Valószínűség')

plt.title('Kétszintű kvantumrendszer dinamikája')

plt.grid(True)

plt.legend()

plt.show()

--------------

** Process exited - Return Code: 0 **

Leggyakoribb elemek

Ez egy egyszerű és hatékony Python program, amely megszámolja és listázza a megadott számsorozat leggyakoribb elemeit.A kód beolvassa a számokat, megszámolja az előfordulásukat, majd csökkenő sorrendben kiírja azokat.

---------------

from collections import Counter

# Az általad megadott sorsolási számok

szamok = [

    2, 3, 9, 11, 15, 18, 35, 4, 10, 12, 14, 16, 30, 32, 1, 5, 13, 23, 25, 32, 33, 

    15, 17, 22, 24, 25, 27, 33, 8, 12, 13, 17, 18, 32, 33, 1, 2, 9, 11, 18, 29, 

    30, 8, 15, 23, 25, 26, 30, 34, 2, 4, 8, 11, 26, 27, 28, 7, 12, 16, 25, 30, 

    32, 33, 2, 4, 12, 21, 25, 30, 33, 9, 14, 15, 17, 19, 21, 23, 7, 10, 17, 20, 

    22, 23, 29, 1, 7, 10, 18, 20, 22, 35, 1, 3, 7, 17, 19, 21, 28, 5, 24, 25, 

    27, 31, 32, 33, 2, 7, 9, 11, 21, 30, 31

]

# Gyakoriság meghatározása

gyakorisag = Counter(szamok)

# Leggyakoribb számok kiírása rendezve

print("A leggyakrabban kihúzott számok és a találatok száma:")

for szam, db in gyakorisag.most_common():

    print(f"{szam}. szám: {db} alkalommal")

------------------

A leggyakrabban kihúzott számok és a találatok száma:

30. szám: 6 alkalommal

25. szám: 6 alkalommal

33. szám: 6 alkalommal

2. szám: 5 alkalommal

32. szám: 5 alkalommal

17. szám: 5 alkalommal

7. szám: 5 alkalommal

9. szám: 4 alkalommal

11. szám: 4 alkalommal

15. szám: 4 alkalommal

18. szám: 4 alkalommal

12. szám: 4 alkalommal

1. szám: 4 alkalommal

23. szám: 4 alkalommal

21. szám: 4 alkalommal

4. szám: 3 alkalommal

10. szám: 3 alkalommal

22. szám: 3 alkalommal

27. szám: 3 alkalommal

8. szám: 3 alkalommal

3. szám: 2 alkalommal

35. szám: 2 alkalommal

14. szám: 2 alkalommal

16. szám: 2 alkalommal

5. szám: 2 alkalommal

13. szám: 2 alkalommal

24. szám: 2 alkalommal

29. szám: 2 alkalommal

26. szám: 2 alkalommal

28. szám: 2 alkalommal

19. szám: 2 alkalommal

20. szám: 2 alkalommal

31. szám: 2 alkalommal

34. szám: 1 alkalommal

** Process exited - Return Code: 0 **

Számok, amik nem voltak a legutóbbi húzásban, de korábban igen

Az alábbi Python kód beolvassa és összesíti a megadott számsorokat. A program megszámolja, hogy az egyes számokat hányszor húzták ki a megadott listában, majd kilistázza azokat a számokat, amelyek az előző heti találatok között szerepeltek, de nem voltak köztük.

A kód futtatásához másold be a lenti szkriptet egy .py kiterjesztésű fájlba, vagy futtasd egy Python környezetben (pl. Google Colab vagy Jupyter Notebook).

------------------

# A megadott sorsolási adatok

sorsolasok = [

    2, 3, 9, 11, 15, 18, 35, 4, 10, 12, 14, 16, 30, 32, 

    1, 5, 13, 23, 25, 32, 33, 15, 17, 22, 24, 25, 27, 33, 

    8, 12, 13, 17, 18, 32, 33, 1, 2, 9, 11, 18, 29, 30, 

    8, 15, 23, 25, 26, 30, 34, 2, 4, 8, 11, 26, 27, 28, 

    7, 12, 16, 25, 30, 32, 33, 2, 4, 12, 21, 25, 30, 33, 

    9, 14, 15, 17, 19, 21, 23, 7, 10, 17, 20, 22, 23, 29, 

    1, 7, 10, 18, 20, 22, 35, 1, 3, 7, 17, 19, 21, 28, 

    5, 24, 25, 27, 31, 32, 33, 2, 7, 9, 11, 21, 30, 31

]

def ellenoriz_szamokat(osszes_kihuzott_szam):

    # 1. Hányszor sorsolták ki az egyes számokat?

    gyakorisag = {}

    for szam in osszes_kihuzott_szam:

        gyakorisag[szam] = gyakorisag.get(szam, 0) + 1

        

    print("--- Egyes számok kihúzási gyakorisága ---")

    for szam in sorted(gyakorisag.keys()):

        print(f"{szam}. szám: {gyakorisag[szam]} alkalommal")

        

    # 2. Melyek voltak az előző heti találatok? (A megadott adatsor legutolsó 7 száma)

    elozo_heti_talalatok = set(osszes_kihuzott_szam[-7:])

    print("\n--- Előző heti (utolsó) találatok ---")

    print(sorted(list(elozo_heti_talalatok)))

    

    # 3. Melyik számokat nem húzták ki a múlt héten, de egyébként szerepeltek a listában?

    osszes_szam = set(osszes_kihuzott_szam)

    nem_szerepeltek_mult_heten = osszes_szam - elozo_heti_talalatok

    

    print("\n--- Számok, amik nem voltak a legutóbbi húzásban, de korábban igen ---")

    print(sorted(list(nem_szerepeltek_mult_heten)))

# Program futtatása

ellenoriz_szamokat(sorsolasok)

---------------------

--- Egyes számok kihúzási gyakorisága ---

1. szám: 4 alkalommal

2. szám: 5 alkalommal

3. szám: 2 alkalommal

4. szám: 3 alkalommal

5. szám: 2 alkalommal

7. szám: 5 alkalommal

8. szám: 3 alkalommal

9. szám: 4 alkalommal

10. szám: 3 alkalommal

11. szám: 4 alkalommal

12. szám: 4 alkalommal

13. szám: 2 alkalommal

14. szám: 2 alkalommal

15. szám: 4 alkalommal

16. szám: 2 alkalommal

17. szám: 5 alkalommal

18. szám: 4 alkalommal

19. szám: 2 alkalommal

20. szám: 2 alkalommal

21. szám: 4 alkalommal

22. szám: 3 alkalommal

23. szám: 4 alkalommal

24. szám: 2 alkalommal

25. szám: 6 alkalommal

26. szám: 2 alkalommal

27. szám: 3 alkalommal

28. szám: 2 alkalommal

29. szám: 2 alkalommal

30. szám: 6 alkalommal

31. szám: 2 alkalommal

32. szám: 5 alkalommal

33. szám: 6 alkalommal

34. szám: 1 alkalommal

35. szám: 2 alkalommal

--- Előző heti (utolsó) találatok ---

[2, 7, 9, 11, 21, 30, 31]

--- Számok, amik nem voltak a legutóbbi húzásban, de korábban igen ---

[1, 3, 4, 5, 8, 10, 12, 13, 14, 15, 16, 17, 18, 19, 20, 22, 23, 24, 25, 26, 

27, 28, 29, 32, 33, 34, 35]

** Process exited - Return Code: 0 **

Skandináv káosz

A lottószámok generálása egy teljesen véletlenszerű folyamat, így a matematika jelenlegi állása szerint káoszelmélettel vagy mintázatokkal nem megjósolhatók. Az alábbi Python szkript a megadott sorsolási eredmények statisztikai eloszlását (gyakoriságát) és a számok ismétlődését elemzi, szimulálva az elmúlt hetek húzásait figyelembevéve. 

----------------------

from collections import Counter

import random

# A megadott skandináv lottó sorsolási adatok (példa adathalmaz)

historical_draws = [

    2, 3, 9, 11, 15, 18, 35,

    4, 10, 12, 14, 16, 30, 32,

    1, 5, 13, 23, 25, 32, 33,

    15, 17, 22, 24, 25, 27, 33,

    8, 12, 13, 17, 18, 32, 33,

    1, 2, 9, 11, 18, 29, 30,

    8, 15, 23, 25, 26, 30, 34,

    2, 4, 8, 11, 26, 27, 28,

    7, 12, 16, 25, 30, 32, 33,

    2, 4, 12, 21, 25, 30, 33,

    9, 14, 15, 17, 19, 21, 23,

    7, 10, 17, 20, 22, 23, 29,

    1, 7, 10, 18, 20, 22, 35,

    1, 3, 7, 17, 19, 21, 28,

    5, 24, 25, 27, 31, 32, 33,

    2, 7, 9, 11, 21, 30, 31

]

# 1. Elemzés: Számok gyakoriságának vizsgálata

def analyze_frequency(data):

    frequency = Counter(data)

    print("--- SZÁMOK GYAKORISÁGA A MINTÁBAN ---")

    for number, count in sorted(frequency.items()):

        print(f"{number:2d} szám: {count} alkalommal szerepel")

    

    most_common = frequency.most_common(3)

    least_common = frequency.most_common()[:-4:-1]

    

    print("\nLeggyakoribb számok:", [x[0] for x in most_common])

    print("Legritkább számok:", [x[0] for x in least_common])

    return [x[0] for x in most_common]

# 2. Szimuláció: Új véletlen "káosz" számsor generálása a megadott adatok alapján

def generate_chaos_numbers(top_numbers):

    print("\n--- ÚJ SZELVÉNY GENERÁLÁSA (KÁOSZ ALGORITMUS) ---")

    

    # A káoszelmélet determinisztikus véletlent jelent: a 'random.seed' egy fix állapotból indul

    # A korábbi húzások leggyakoribb számának átlagát használjuk "magként" (seed-ként) a szimulációhoz

    chaos_seed = sum(top_numbers) // len(top_numbers)

    random.seed(chaos_seed)

    

    # Skandináv lottó szabály: 35 számból 7-et kell választani

    generated_draw = set()

    while len(generated_draw) < 7:

        new_num = random.randint(1, 35)

        generated_draw.add(new_num)

        

    sorted_draw = sorted(list(generated_draw))

    print(f"Generált szimulált számsor: {sorted_draw}")

# Futtatás

top = analyze_frequency(historical_draws)

generate_chaos_numbers(top)

--------------

--- SZÁMOK GYAKORISÁGA A MINTÁBAN ---

 1 szám: 4 alkalommal szerepel

 2 szám: 5 alkalommal szerepel

 3 szám: 2 alkalommal szerepel

 4 szám: 3 alkalommal szerepel

 5 szám: 2 alkalommal szerepel

 7 szám: 5 alkalommal szerepel

 8 szám: 3 alkalommal szerepel

 9 szám: 4 alkalommal szerepel

10 szám: 3 alkalommal szerepel

11 szám: 4 alkalommal szerepel

12 szám: 4 alkalommal szerepel

13 szám: 2 alkalommal szerepel

14 szám: 2 alkalommal szerepel

15 szám: 4 alkalommal szerepel

16 szám: 2 alkalommal szerepel

17 szám: 5 alkalommal szerepel

18 szám: 4 alkalommal szerepel

19 szám: 2 alkalommal szerepel

20 szám: 2 alkalommal szerepel

21 szám: 4 alkalommal szerepel

22 szám: 3 alkalommal szerepel

23 szám: 4 alkalommal szerepel

24 szám: 2 alkalommal szerepel

25 szám: 6 alkalommal szerepel

26 szám: 2 alkalommal szerepel

27 szám: 3 alkalommal szerepel

28 szám: 2 alkalommal szerepel

29 szám: 2 alkalommal szerepel

30 szám: 6 alkalommal szerepel

31 szám: 2 alkalommal szerepel

32 szám: 5 alkalommal szerepel

33 szám: 6 alkalommal szerepel

34 szám: 1 alkalommal szerepel

35 szám: 2 alkalommal szerepel

Leggyakoribb számok: [30, 25, 33]

Legritkább számok: [34, 31, 20]

--- ÚJ SZELVÉNY GENERÁLÁSA (KÁOSZ ALGORITMUS) ---

Generált szimulált számsor: [5, 6, 19, 23, 26, 27, 33]

** Process exited - Return Code: 0 **

----------------

Káoszelmélet

Szükséges csomagokA program futtatásához telepítened kell a numpy és matplotlib könyvtárakat. Ezt a parancssorban (terminálban) a következő paranccsal teheted meg:pip install numpy matplotlib

import numpy as np

import matplotlib.pyplot as plt

# r paraméterek tartománya (2.8-tól 4.0-ig, ahol a káosz megjelenik)

r_min = 2.8

r_max = 4.0

max_r = 10000

iterations = 1000

last_iterations = 100

# Rács és kezdeti populáció beállítása

r = np.linspace(r_min, r_max, max_r)

x = 1e-5 * np.ones(max_r)

# Grafikon inicializálása

plt.figure(figsize=(10, 6), dpi=100)

# Iterációk futtatása és a stabil állapotok rögzítése

for i in range(iterations):

    x = r * x * (1 - x)

    if i > (iterations - last_iterations):

        plt.plot(r, x, ',k', alpha=0.05)

# Diagram csinosítása

plt.title("Logisztikus leképezés - Bifurkációs diagram", fontsize=14)

plt.xlabel("Növekedési ráta (r)", fontsize=12)

plt.ylabel("Populáció szintje (x)", fontsize=12)

plt.xlim(r_min, r_max)

plt.ylim(0, 1)

plt.show()

-------------------

Mit látsz az ábrán?Rend (Kis r értékek): A populáció egyetlen fix pontban stabilizálódik.Periodicitás (r ≈ 3.0 körül): A vonal kettéválik, a populáció két érték között ingadozik.Bifurkációs kaszkád: A vonalak egyre többször ágaznak el (4, 8, 16 felé), ami a káoszhoz vezető utat jelzi.Káosz (r ≈ 3.57 felett): A rendszer teljesen kaotikussá válik, az értékek ugrálnak, de a sötétebb sávokon belül felfedezhető az önhasonlóság (frakálmok) tulajdonsága.

Valószínüség és kombináció

A Skandináv lottó matematikai nyerési esélyeit (kombinatorikus valószínűségét) a hipergeometrikus eloszlás képlete segítségével számolhatjuk ki: \(P = \frac{\binom{K}{t} \cdot \binom{N-K}{h-t}}{\binom{N}{h}}\), ahol N=35 (összes szám), h=7 (húzott számok), K=7 (megjátszott számok), és t a találatok száma.Az alábbi Python program kiszámolja az összes lehetséges találati esélyt (4, 5, 6 és 7 találat) egymezős alapjátékra vonatkozóan, egyetlen sorsoláson belül:

--------------------

import math

def kombinacio(n, k):

    """Kombinációk számát kiszámoló segédfüggvény (n alatt a k)"""

    return math.comb(n, k)

def skandinav_lotto_eselyek():

    N = 35  # Összes választható szám

    h = 7   # Kiszórt számok száma egy sorsoláson

    K = 7   # Megjátszott számok száma

    

    osszes_eshetoseg = kombinacio(N, h)

    

    print("Skandináv lottó - Nyerési esélyek 1 mezőre vetítve:")

    print("-" * 60)

    

    # Kiszámoljuk a valószínűségeket 4, 5, 6 és 7 találatra

    for talalat in range(4, 8):

        kedvezo = kombinacio(K, talalat) * kombinacio(N - K, h - talalat)

        valoszinuseg = kedvezo / osszes_eshetoseg

        

        # Esély kifejezése tört alakban (1 : X)

        esely_1_hez = round(1 / valoszinuseg) if valoszinuseg > 0 else 0

        

        print(f"{talalat} találat esélye: {valoszinuseg:.8f} (1 : {esely_1_hez})")

if __name__ == "__main__":

    skandinav_lotto_eselyek()

---------------

Skandináv lottó - Nyerési esélyek 1 mezőre vetítve:

------------------------------------------------------------

4 találat esélye: 0.01705103 (1 : 59)

5 találat esélye: 0.00118046 (1 : 847)

6 találat esélye: 0.00002915 (1 : 34309)

7 találat esélye: 0.00000015 (1 : 6724520)

** Process exited - Return Code: 0 **

Skandináv lottó számok gyakorisága és eloszlása

Íme egy egyszerű Python program, amellyel elemezheted a megadott skandináv lottó számok gyakoriságát és eloszlását. A kód összesíti az egyes számok előfordulási gyakoriságát, majd növekvő sorrendbe rendezi és vizuálisan is megjeleníti egy oszlopdiagram segítségével a matplotlib könyvtár használatával.A kód futtatása előtt győződj meg róla, hogy a matplotlib telepítve van a gépeden (pip install matplotlib).

--------------------

from collections import Counter

import matplotlib.pyplot as plt

# A megadott skandináv lottó számok

numbers_data = [

    2,

    3,

    9,

    11,

    15,

    18,

    35,

    4,

    10,

    12,

    14,

    16,

    30,

    32,

    1,

    5,

    13,

    23,

    25,

    32,

    33,

    15,

    17,

    22,

    24,

    25,

    27,

    33,

    8,

    12,

    13,

    17,

    18,

    32,

    33,

    1,

    2,

    9,

    11,

    18,

    29,

    30,

    8,

    15,

    23,

    25,

    26,

    30,

    34,

    2,

    4,

    8,

    11,

    26,

    27,

    28,

    7,

    12,

    16,

    25,

    30,

    32,

    33,

    2,

    4,

    12,

    21,

    25,

    30,

    33,

    9,

    14,

    15,

    17,

    19,

    21,

    23,

    7,

    10,

    17,

    20,

    22,

    23,

    29,

    1,

    7,

    10,

    18,

    20,

    22,

    35,

    1,

    3,

    7,

    17,

    19,

    21,

    28,

    5,

    24,

    25,

    27,

    31,

    32,

    33,

    2,

    7,

    9,

    11,

    21,

    30,

    31,

]

# Gyakoriság számítása

frequency = Counter(numbers_data)

# Az összes lehetséges skandináv lottó szám (1-től 35-ig)

# Biztosítja, hogy azok a számok is megjelenjenek a grafikonon, amiket most nem húztak ki

all_numbers = range(1, 36)

counts = [frequency[num] for num in all_numbers]

# Eredmények kiíratása konzolra

print("Számok gyakorisága (szám: előfordulás):")

for num, count in sorted(frequency.items()):

    print(f"{num:2d} : {count:2d} db")

# Grafikon rajzolása

plt.figure(figsize=(14, 6))

plt.bar(all_numbers, counts, color="teal", edgecolor="black")

# Grafikon csinosítása

plt.title("Skandináv lottó számok eloszlása", fontsize=16)

plt.xlabel("Skandináv lottó számok", fontsize=12)

plt.ylabel("Kihúzások száma", fontsize=12)

plt.xticks(all_numbers)

plt.grid(axis="y", linestyle="--", alpha=0.7)

# Megjelenítés

plt.tight_layout()

plt.show()

Megoldás

Számok gyakorisága (szám: előfordulás):

 1 :  4 db

 2 :  5 db

 3 :  2 db

 4 :  3 db

 5 :  2 db

 7 :  5 db

 8 :  3 db

 9 :  4 db

10 :  3 db

11 :  4 db

12 :  4 db

13 :  2 db

14 :  2 db

15 :  4 db

16 :  2 db

17 :  5 db

18 :  4 db

19 :  2 db

20 :  2 db

21 :  4 db

22 :  3 db

23 :  4 db

24 :  2 db

25 :  6 db

26 :  2 db

27 :  3 db

28 :  2 db

29 :  2 db

30 :  6 db

31 :  2 db

32 :  5 db

33 :  6 db

34 :  1 db

35 :  2 db

** Process exited - Return Code: 0 **

Másodfokú egyenlet

Íme egy hasznos és szemléletes példa egy gyakori matematikai probléma, a másodfokú egyenlet (ax² + bx + c = 0) megoldására. A Python program bekéri az együtthatókat, ellenőrzi a diszkrimináns értékét (Δ = b² - 4ac), és kiírja a valós vagy komplex gyököket.

------------------------

import cmath

def masodfoku_megoldo(a, b, c):

    # Diszkrimináns kiszámítása

    delta = (b ** 2) - (4 * a * c)

    # Megoldások meghatározása

    if delta > 0:

        x1 = (-b - cmath.sqrt(delta)) / (2 * a)

        x2 = (-b + cmath.sqrt(delta)) / (2 * a)

        return f"Két különböző valós gyök van: x1 = {x1.real}, x2 = {x2.real}"

    elif delta == 0:

        x = -b / (2 * a)

        return f"Egy darab valós gyök (kettős gyök) van: x = {x}"

    else:

        x1 = (-b - cmath.sqrt(delta)) / (2 * a)

        x2 = (-b + cmath.sqrt(delta)) / (2 * a)

        return f"Két komplex gyök van: x1 = {x1}, x2 = {x2}"

# Felhasználói interakció

print("Másodfokú egyenlet megoldó: ax^2 + bx + c = 0")

try:

    a = float(input("Adja meg az 'a' értékét (a != 0): "))

    if a == 0:

        print("Az 'a' nem lehet nulla!")

    else:

        b = float(input("Adja meg a 'b' értékét: "))

        c = float(input("Adja meg a 'c' értékét: "))

        eredmeny = masodfoku_megoldo(a, b, c)

        print(eredmeny)

except ValueError:

    print("Kérjük, érvényes számot adjon meg!")

--------------------

Megoldás

-------------------

Másodfokú egyenlet megoldó: ax^2 + bx + c = 0

Adja meg az 'a' értékét (a != 0): 2

Adja meg a 'b' értékét: 3

Adja meg a 'c' értékét: 4

Két komplex gyök van: x1 = (-0.75-1.1989578808281798j), x2 = (-0.75+1.198957

8808281798j)

** Process exited - Return Code: 0 **

Shamir-féle titokmegosztás vagy homomorfikus rejtjelezés

Az alábbi Python kód egy polinom alapú komplex titkosítás (pl. Shamir-féle titokmegosztás vagy homomorfikus rejtjelezés) vizuális ábrázolását valósítja meg. A szkript generál egy véletlenszerű polinomot, elrejti (titkosítja) az adatokat a komplex síkon, majd a matplotlib segítségével kirajzolja a titkosított pontok által alkotott komplex síkot.A program futtatásához szükséged lesz a numpy és matplotlib csomagokra, amelyeket a parancssorban a pip install numpy matplotlib paranccsal telepíthetsz.

-----------------

import sympy as sp

# Szimbolikus változók definiálása

x, y = sp.symbols('x y')

# 1. Bonyolult egyenlet megoldása (pl.: x^2 - 5x + 6 = 0)

egyenlet = sp.Eq(x**2 - 5*x + 6, 0)

megoldasok = sp.solve(egyenlet, x)

print(f"Az egyenlet megoldásai: {megoldasok}")

# 2. Deriválás (pl.: f(x) = sin(x) * e^x)

f = sp.sin(x) * sp.exp(x)

derivalt = sp.diff(f, x)

print(f"A függvény deriváltja: {derivalt}")

# 3. Határozatlan integrál

integralt = sp.integrate(f, x)

print(f"A függvény integrálja: {integralt}")

# 4. Lineáris egyenletrendszer megoldása mátrixokkal

# 3x + y = 9 és x + 2y = 8

A = sp.Matrix([[3, 1], [1, 2]])

B = sp.Matrix([9, 8])

eredmeny_matrix = A.LUsolve(B)

print(f"A lineáris egyenletrendszer megoldása: x = {eredmeny_matrix[0]}, y = {eredmeny_matrix[1]}")

------------

megoldás

-------------

Az egyenlet megoldásai: [2, 3]

A függvény deriváltja: exp(x)*sin(x) + exp(x)*cos(x)

A függvény integrálja: exp(x)*sin(x)/2 - exp(x)*cos(x)/2

A lineáris egyenletrendszer megoldása: x = 2, y = 3

** Process exited - Return Code: 0 **

Polinomalapú komplex titkosítás

Az alábbi Python program a polinomos titkosítás egy elterjedt szemléltető formáját valósítja meg: a titkos üzenetet karakterenként egy polinom f(x) behelyettesítési értékeként kódolja és dekódolja egy megadott p prímszám modulus használatával

-----------------------------

import random

def generate_key(degree):

    """

    Polinom kulcs generálása: [a_n, a_{n-1}, ..., a_1, a_0]

    """

    return [random.randint(1, 50) for _ in range(degree + 1)]

def evaluate_polynomial(poly, x, modulus):

    """

    Polinom kiértékelése Horner-módszerrel modulo p

    """

    result = 0

    for coeff in poly:

        result = (result * x + coeff) % modulus

    return result

def encrypt_message(message, poly, modulus):

    """

    Üzenet titkosítása polinom alapokon.

    Minden karakterhez tartozik egy egyedi x érték.

    """

    ciphertext = []

    for i, char in enumerate(message):

        char_val = ord(char)

        # Egyedi x koordináta az üzenet pozíciója alapján

        x = i + 1 

        # y = P(x) mod modulus

        y = evaluate_polynomial(poly, x, modulus)

        # A titkosított értékpár (x, y)

        ciphertext.append((x, (y + char_val) % modulus))

    return ciphertext

def decrypt_message(ciphertext, poly, modulus):

    """

    Üzenet visszafejtése az eredeti polinom és a megadott modulus segítségével.

    """

    decrypted_chars = []

    for x, encrypted_val in ciphertext:

        # Visszaszámoljuk a P(x) értéket

        y = evaluate_polynomial(poly, x, modulus)

        # Kivonjuk a polinom értékét a titkosított y-ból

        original_char_val = (encrypted_val - y) % modulus

        decrypted_chars.append(chr(original_char_val))

    return "".join(decrypted_chars)

# --- Példa a használatra ---

# 1. Beállítások

degree = 3         # A polinom foka

modulus = 256      # Modulus (ASCII karakterekhez ideális)

message = "TitkosUzenet"

# 2. Kulcs generálása (Titkos polinom együtthatói)

secret_polynomial_key = generate_key(degree)

print(f"Generált polinom együtthatói: {secret_polynomial_key}")

# 3. Titkosítás

encrypted = encrypt_message(message, secret_polynomial_key, modulus)

print(f"\nTitkosított adatok (koordináták):\n{encrypted}")

# 4. Visszafejtés

decrypted = decrypt_message(encrypted, secret_polynomial_key, modulus)

print(f"\nVisszafejtett üzenet:\n{decrypted}")

-----------------