Riasztó vezérlés

try:

    from gpiozero import MotionSensor, Buzzer

    from time import sleep, time

    pir = MotionSensor(17)

    buzzer = Buzzer(27)

    print("A riasztó élesedik...")

    sleep(5)

    print("Riasztó éles!")

    try:

        start = time()

        while time() - start < 10:

            if pir.motion_detected:

                print("Mozgás észlelve! Riasztás!!!")

                buzzer.on()

                sleep(1)

                buzzer.off()

            sleep(0.1)

        print("A program lejárt.")

    except KeyboardInterrupt:

        print("\nProgram leállítva.")

        buzzer.off()

except ImportError:

    from time import sleep

    import random

    print("A gpiozero nem elérhető, szimulált mód indul...")

    print("A riasztó élesedik...")

    sleep(2)

    print("Riasztó éles!")

    for _ in range(10):

        if random.random() < 0.2:

            print("Mozgás észlelve! Riasztás!!!")

        sleep(1)

    print("A szimuláció véget ért.")

except Exception as e:

    print(f"Hiba történt: {e}")

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

Input for the program ( Optional )

Output:

Time limit exceeded

Optimalizálás, Jelfeldolgozás (Szűrés), Differenciálegyenlet megoldása, Numerikus integrálás

import numpy as np

import matplotlib.pyplot as plt

from scipy.integrate import quad, solve_ivp

from scipy.optimize import minimize

from scipy.signal import butter, lfilter

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

# 1. Numerikus integrálás

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

# Határozott integrál kiszámítása: int_0^2 (x^2) dx

def integrand(x):

    return x**2

integral_ertek, hiba = quad(integrand, 0, 2)

print(f"1. Integrálás eredménye: {integral_ertek:.4f} (Hiba: {hiba:.2e})")

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

# 2. Differenciálegyenlet megoldása

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

# Egy elsőrendű diff.egyenlet: dy/dt = -2y, y(0) = 1

def dydt(t, y):

    return -2 * y

t_span = (0, 5)            # Intervallum

t_eval = np.linspace(0, 5, 100) # Kiértékelési pontok

y0 = [1.0]                 # Kezdeti feltétel

megoldas = solve_ivp(dydt, t_span, y0, t_eval=t_eval)

print(f"2. Diff. egyenlet megoldva. Utolsó érték t={megoldas.t[-1]}: {megoldas.y[0][-1]:.4f}")

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

# 3. Optimalizálás

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

# Minimum keresés: f(x) = x^2 - 3x + 2

def celFuggveny(x):

    return x**2 - 3*x + 2

x_kezdo = [0.0] # Kezdőbecslés a kereséshez

eredmeny = minimize(celFuggveny, x_kezdo, method='BFGS')

print(f"3. Optimalizálás minimuma: x = {eredmeny.x[0]:.4f}, f(x) = {eredmeny.fun:.4f}")

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

# 4. Jelfeldolgozás (Szűrés)

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

# Mintajel generálása (1 Hz és 10 Hz keveréke)

fs = 100.0  # Mintavételi frekvencia

t = np.linspace(0, 1, fs, endpoint=False)

jel = np.sin(2 * np.pi * 1 * t) + 0.5 * np.sin(2 * np.pi * 10 * t)

# Aluláteresztő szűrő tervezése (levágási frekvencia: 5 Hz)

nyq = 0.5 * fs

cutoff = 5 / nyq

b, a = butter(4, cutoff, btype='low')

szurt_jel = lfilter(b, a, jel)

print("4. Jelfeldolgozás: Szűrés sikeresen végrehajtva.")

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

1. Integrálás eredménye: 2.6667 (Hiba: 2.96e-14)

2. Diff. egyenlet megoldva. Utolsó érték t=5.0: 0.0000

3. Optimalizálás minimuma: x = 1.5000, f(x) = -0.2500

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

from sympy import symbols, integrate

x = symbols('x')

# Példa: az f(x) = 2*x^2 + 3*x + 1 integrálása x szerint

f = 2 * x**2 + 3 * x + 1

# Határozatlan integrál

hatarozatlan_integral = integrate(f, x)

print(f"Határozatlan integrál: {hatarozatlan_integral}")

# Határozott integrál [0, 2] intervallumon

hatarozott_integral = integrate(f, (x, 0, 2))

print(f"Határozott integrál: {hatarozott_integral}")

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

Határozatlan integrál: 2*x**3/3 + 3*x**2/2 + x

Határozott integrál: 40/3

** Process exited - Return Code: 0 **

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

import numpy as np

import matplotlib.pyplot as plt

from scipy.signal import butter, filtfilt

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

# Mintajel generálása (1 Hz és 10 Hz keveréke)

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

fs = 100.0  # Mintavételi frekvencia

t = np.linspace(0, 1, int(fs), endpoint=False)

jel = np.sin(2 * np.pi * 1 * t) + 0.5 * np.sin(2 * np.pi * 10 * t)

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

# Aluláteresztő szűrő tervezése és szűrés

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

levagasi_frekvencia = 5.0  # Levágási frekvencia: 5 Hz

rend = 4                 # A szűrő rendje

# Szűrő együtthatók tervezése

b, a = butter(rend, levagasi_frekvencia, btype='low', fs=fs)

# Zéró fázistolású szűrés alkalmazása (a fázistorzítás elkerülésére)

szurt_jel = filtfilt(b, a, jel)

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

# Eredmények ábrázolása

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

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

plt.plot(t, jel, label='Eredeti jel (1 Hz + 10 Hz)', color='gray', alpha=0.5)

plt.plot(t, szurt_jel, label='Szűrt jel (aluláteresztő < 5 Hz)', color='blue', linewidth=2)

plt.title('Digitális Butterworth aluláteresztő szűrő hatása')

plt.xlabel('Idő [másodperc]')

plt.ylabel('Amplitúdó')

plt.grid(True)

plt.legend()

plt.tight_layout()

plt.show()

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

import numpy as np

import matplotlib.pyplot as plt

# Mintavételi frekvencia és időtartam

fs = 200 # Hz (elegendő a 10 Hz-es jel visszaadásához)

t = np.linspace(0, 2, 2 * fs, endpoint=False) # 2 másodperc

# 1 Hz és 10 Hz frekvenciájú szinuszjelek generálása és összeadása

f1, f2 = 1, 10

signal = np.sin(2 * np.pi * f1 * t) + np.sin(2 * np.pi * f2 * t)

# A jel ábrázolása

plt.figure(figsize=(10, 5))

plt.plot(t, signal, label='1 Hz és 10 Hz keveréke')

plt.title('Kevert mintajel (1 Hz és 10 Hz)')

plt.xlabel('Idő (másodperc)')

plt.ylabel('Amplitúdó')

plt.grid(True)

plt.legend()

plt.show()

----------

Szűrés

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

# Eredeti lista

szamok = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 1. módszer: Lista-kifejezés (List comprehension)

# Ez a legelterjedtebb és leginkább olvasható Pythonos módszer.

paros_szamok = [szam for szam in szamok if szam % 2 == 0]

print("Páros számok (lista-kifejezéssel):", paros_szamok)

# 2. módszer: A filter() függvény és egy lambda (névtelen) függvény használata

# A filter egy szűrő objektumot ad vissza, amit listává kell alakítanunk.

paros_szamok_filter = list(filter(lambda x: x % 2 == 0, szamok))

print("Páros számok (filter függvénnyel):", paros_szamok_filter)

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

Páros számok (lista-kifejezéssel): [2, 4, 6, 8, 10]

Páros számok (filter függvénnyel): [2, 4, 6, 8, 10]

** Process exited - Return Code: 0 **

Tömb- és mátrixműveletek

import numpy as np

# 1. Tömbök létrehozása (1D, 2D)

egy_dimenzios = np.array([1, 2, 3, 4])

ket_dimenzios = np.array([[1, 2, 3], 

                          [4, 5, 6]])

print("2D Mátrix:\n", ket_dimenzios)

print("A mátrix dimenziói:", ket_dimenzios.shape) # (sorok száma, oszlopok száma)

# 2. Mátrix inicializálása nullákkal vagy egyesekkel

nullas_matrix = np.zeros((3, 3)) # 3x3-as nullmátrix

egyes_matrix = np.ones((2, 4))   # 2x4-es egyesekből álló mátrix

# 3. Alapvető mátrixműveletek (Skaláris)

hozzadas = ket_dimenzios + 10    # Minden elemhez hozzáad 10-et

szorzas = ket_dimenzios * 2      # Minden elemet megszoroz 2-vel

# 4. Elem-szintű (element-wise) műveletek két mátrix között

a = np.array([[1, 2], [3, 4]])

b = np.array([[5, 6], [7, 8]])

osszeadas = a + b    # Elem szerinti összeadás

kivonas = a - b      # Elem szerinti kivonás

elem_szorzas = a * b # Elem szerinti szorzás (Hadamard-szorzat)

# 5. Valódi mátrixszorzás (Dot product)

m_szorzas_1 = np.dot(a, b) # Hagyományos szintaxis

m_szorzas_2 = a @ b        # Modern, átláthatóbb szintaxis

# 6. Transzponálás (sorok és oszlopok cseréje)

transzponalt = a.T

# 7. Determináns és inverz mátrix számítás

# A linalg almodult használjuk lineáris algebrához

determinans = np.linalg.det(a)

inverz = np.linalg.inv(a)

print("\nMátrix A:\n", a)

print("Mátrix B:\n", b)

print("A @ B (Mátrixszorzás):\n", m_szorzas_2)

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

print("A determinánsa:", determinans)

Csillapított rezgés ábrázolása

Egy egyszerű fizikai vagy matematikai függvény (pl. egy csillapított rezgés: \(y = e^{-t} \cos(2\pi t)\)) ábrázolásához írt program;

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

import numpy as np

import matplotlib.pyplot as plt

# Időadatok generálása 0 és 5 másodperc között

t = np.linspace(0, 5, 100)

# Függvényértékek kiszámítása

y = np.exp(-t) * np.cos(2 * np.pi * t)

# Grafikon beállítása és kirajzolása

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

plt.plot(t, y, label='Csillapított rezgés', color='blue')

plt.title('Tudományos folyamat modellezése')

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

plt.ylabel('Kitérés (y)')

plt.legend()

plt.grid(True)

plt.show()

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

A kettős inga szimulációja python prg.

A szimuláció futtatásához szükséges a numpy és matplotlib csomagok telepítése (pip install numpy matplotlib scipy).

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

import numpy as np

import matplotlib.pyplot as plt

from scipy.integrate import odeint

from matplotlib.animation import FuncAnimation

# Paraméterek és kezdeti feltételek

G = 9.81  # Gravitációs gyorsulás ($m/s^2$)

L1, L2 = 1.0, 1.0  # Inga karok hossza (m)

m1, m2 = 1.0, 1.0  # Inga testek tömege (kg)

def dX_dt(t, X):

    theta1, z1, theta2, z2 = X

    

    delta = theta1 - theta2

    

    # Egyenletek a szöggyorsulásokra

    den1 = (m1 + m2) * L1 - m2 * L1 * np.cos(delta)**2

    d2theta1 = (m2 * L1 * z1**2 * np.sin(delta) * np.cos(delta) +

                m2 * G * np.sin(theta2) * np.cos(delta) +

                m2 * L2 * z2**2 * np.sin(delta) -

                (m1 + m2) * G * np.sin(theta1)) / den1

                

    den2 = (m1 + m2) * L2 - m2 * L2 * np.cos(delta)**2

    d2theta2 = (-m2 * L2 * z2**2 * np.sin(delta) * np.cos(delta) +

                (m1 + m2) * G * np.sin(theta1) * np.cos(delta) -

                (m1 + m2) * L2 * z1**2 * np.sin(delta) -

                (m1 + m2) * G * np.sin(theta2)) / den2

    

    return [z1, d2theta1, z2, d2theta2]

# Kezdeti szögek és szögsebességek (radiánban)

theta1_0 = np.pi / 2

z1_0 = 0.0

theta2_0 = np.pi / 2

z2_0 = 0.0

X0 = [theta1_0, z1_0, theta2_0, z2_0]

# Időlépések (0-tól 20 másodpercig, 0.05 s lépésközzel)

t = np.linspace(0, 20, 400)

# Mozgásegyenletek integrálása

X = odeint(dX_dt, X0, t, tfirst=True)

# Deriváltak kinyerése a szögekhez

theta1, theta2 = X[:, 0], X[:, 2]

# Átszámolás Descartes-koordinátákba

x1 = L1 * np.sin(theta1)

y1 = -L1 * np.cos(theta1)

x2 = x1 + L2 * np.sin(theta2)

y2 = y1 - L2 * np.cos(theta2)

# Animáció beállítása

fig, ax = plt.subplots(figsize=(6,6))

ax.set_xlim(-2.5, 2.5)

ax.set_ylim(-2.5, 2.5)

ax.set_aspect('equal')

ax.grid()

line, = ax.plot([], [], 'o-', lw=2, color='blue')

trail, = ax.plot([], [], '-', lw=1, color='red', alpha=0.5)

def update(i):

    # Az aktuális pontok az ábrázoláshoz

    this_x = [0, x1[i], x2[i]]

    this_y = [0, y1[i], y2[i]]

    line.set_data(this_x, this_y)

    

    # Nyomvonal az utolsó néhány pontból

    trail.set_data(x2[:i], y2[:i])

    return line, trail

ani = FuncAnimation(fig, update, frames=len(t), interval=50, blit=True)

plt.title("Kettős inga szimuláció")

plt.show()

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

A csillapodó rezgőmozgás modellezése

 A program kiszámítja a fizikai modellt, majd kirajzolja a rezgés grafikonját és egy animációt is készít, amellyel látványosan szimulálható a folyamat.

Fizikai modell: A program a rugóállandó (k), a tömeg (m) és a csillapítás (b) alapján kiszámítja a rezgés lecsengését.

Kijelző (Felső grafikon): Megmutatja a kitérés amplitúdójának csökkenését az idő múlásával.

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

import numpy as np

import matplotlib.pyplot as plt

from matplotlib.animation import FuncAnimation

# --- Fizikai paraméterek ---

m = 1.0          # Tömeg (kg)

k = 20.0         # Rugóállandó (N/m)

b = 0.5          # Csillapítási tényező (kg/s)

x0 = 2.0         # Kezdő kitérés (m)

v0 = 0.0         # Kezdősebesség (m/s)

omega0 = np.sqrt(k / m)      # Sajátfrekvencia

beta = b / (2 * m)           # Csillapítási tényező

# --- Időintervallum ---

t_max = 15.0

dt = 0.05

t = np.arange(0, t_max, dt)

# --- Analitikus megoldás (Kitérés az idő függvényében) ---

if beta < omega0:

    # Alulcsillapított eset (szép rezgés, ami fokozatosan csökken)

    omega_d = np.sqrt(omega0**2 - beta**2)

    x = x0 * np.exp(-beta * t) * (np.cos(omega_d * t) + (beta / omega_d) * np.sin(omega_d * t))

else:

    # Túlcsillapított vagy kritikus eset (nincs lengés, csak visszatérés)

    x = x0 * np.exp(-beta * t) # Egyszerűsített lecsengés

# --- Statikus grafikon előkészítése ---

fig, (ax_plot, ax_anim) = plt.subplots(2, 1, figsize=(10, 8))

fig.suptitle("Csillapodó rezgőmozgás szimulációja", fontsize=14)

ax_plot.plot(t, x, label='Kitérés $x(t)$', color='blue')

ax_plot.set_title("Kitérés időbeli lefutása")

ax_plot.set_xlabel("Idő (s)")

ax_plot.set_ylabel("Kitérés (m)")

ax_plot.grid(True, linestyle='--')

ax_plot.legend()

# --- Animáció előkészítése ---

ax_anim.set_xlim(-x0 - 0.5, x0 + 0.5)

ax_anim.set_ylim(-1, 1)

ax_anim.set_title("Rezgő test animációja")

ax_anim.set_yticks([])

ax_anim.grid(axis='x', linestyle='--')

# A rugót és a tömeget jelző elemek

line, = ax_anim.plot([], [], color='gray', lw=2)  # Rugó

patch, = ax_anim.plot([], [], 's', color='red', markersize=30) # Tömeg

def init():

    line.set_data([], [])

    patch.set_data([], [])

    return line, patch

def update(frame):

    # A rugó cikkcakkjának pontjai

    spring_x = np.linspace(0, x[frame], 20)

    spring_y = np.linspace(0, 0, 20)

    

    line.set_data(spring_x, spring_y)

    patch.set_data(x[frame], 0)

    return line, patch

ani = FuncAnimation(fig, update, frames=len(t), init_func=init, interval=dt*1000, blit=True, repeat=True)

plt.tight_layout()

plt.show()

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

** Process exited - Return Code: 0 **

https://www.online-python.com/pyodide

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 **

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