A föld pályája a napkörül

 A Föld Nap körüli pályájának modellezése python nyelven. Az algoritmus szimulálja és leírja a Föld Nap körüli keringését. Ez magában foglalja a Föld ellipszis pályán elfoglalt helyzetének kiszámítását az idő függvényében, Kepler bolygómozgási törvényeinek felhasználásával. Ez a tömör program a pályamechanika matematikai alapelveit alkalmazza a Föld elliptikus pályájának vizualizálására a Nap körül, világosan ábrázolva annak útját egy kétdimenziós térben.

Forrás;

import matplotlib.pyplot as plt

import numpy as np

# Generate data

x = np.linspace(0, 10, 200)

y1 = np.sin(x) * np.exp(-0.1 * x)

y2 = np.cos(x) * np.exp(-0.1 * x)

# Create figure

fig, ax = plt.subplots(figsize=(8, 5))

ax.plot(x, y1, color='#2563eb', linewidth=2, label='Damped Sine')

ax.plot(x, y2, color='#f59e0b', linewidth=2, label='Damped Cosine')

ax.fill_between(x, y1, y2, alpha=0.1, color='#8b5cf6')

ax.set_title('Damped Oscillations', fontsize=16, fontweight='bold', pad=12)

ax.set_xlabel('Time (s)', fontsize=12)

ax.set_ylabel('Amplitude', fontsize=12)

ax.legend(fontsize=11, loc='upper right')

ax.grid(True, alpha=0.3)

ax.set_facecolor('#fafafa')

fig.tight_layout()

plt.show()

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

Neurális hálózat

Ez a program egy rendkívül összetett és fejlett mesterséges neurális hálózat, amely az emberi agy működését próbálja utánozni, képes adatok elemzésére, önálló tanulásra és összetett feladatok elvégzésére. Az alábbiakban bemutatom, hogyan írhatunk egy alapvető, saját neurális hálót Pythonban, a TensorFlow és Keras könyvtárak segítségével. Ez a háló képes tanulni például adathalmazokból, és emulálhat bizonyos emberi agyi funkciókat.A kód, ami kiindulási alap lehet, a valódi emberi agyat utánozó, önálló tanulásra képes, összetett háló megalkotására számos kutatási és fejlesztési lépést igényel. A hálózatot nagy mennyiségű előre címkézett adatot kap és a hibákból tanulva folyamatosan pontosítja a belső súlyait. A betanított modell már képes önállóan, új és ismeretlen adatok alapján döntéseket hozni vagy tartalmat generálni!

-----------

import numpy as np

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense

from tensorflow.keras.optimizers import Adam

# Adathalmaz például: XOR feladat

X = np.array([[0,0], [0,1], [1,0], [1,1]])

Y = np.array([[0], [1], [1], [0]])

# Modell felépítése

model = Sequential()

model.add(Dense(8, input_dim=2, activation='relu'))  # ReLU aktivációval

model.add(Dense(1, activation='sigmoid'))  # Kimenet sigmoid aktivációval

# Modell fordítása

model.compile(loss='binary_crossentropy', optimizer=Adam(learning_rate=0.01), metrics=['accuracy'])

# Tanítás

model.fit(X, Y, epochs=1000, verbose=0)

# Eredmény tesztelése

loss, accuracy = model.evaluate(X, Y)

print(f"Pontosság: {accuracy*100:.2f}%")

# Előrejelzés

print("Előrejelzések:")

print(model.predict(X))

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

Egyszerű példakód (Python, Keras), A modellek inkább mintázatokat találhatnak, a sikeres eredményhez sok adat és megfelelő finomhangolás szükséges. Bemeneti réteg (Input): Ez a réteg fogadja a nyers adatokat .Rejtett rétegek (Hidden layers): Az adatok itt haladnak keresztül, miközben a hálózat matematikai műveletekkel (súlyozással és aktivációs függvényekkel) elemzi a mintázatokat. A mélytanulás (deep learning) kifejezés a sok rejtett réteget tartalmazó hálózatokra utal.Kimeneti réteg (Output): Ez a réteg adja meg a végső választ.

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

import numpy as np

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import LSTM, Dense

# Feltételezett adatok: múltbeli kihúzott számok listája

# (Ezt helyettesítsd valódi adatokkal)

data = [

    [5, 12, 23, 34, 45],

    [12, 23, 34, 45, 56],

    [3, 15, 27, 39, 45],

    # ... több adat

]

# Felkészítés

sequence_length = 5

X = []

Y = []

for seq in data:

    for i in range(len(seq) - sequence_length):

        X.append(seq[i:i+sequence_length])

        Y.append(seq[i+sequence_length])  # a következő szám

X = np.array(X)

Y = np.array(Y)

# Átalakítás LSTM bemenethez: [minták, időlépés, jellemzők]

X = X.reshape((X.shape[0], X.shape[1], 1))

# Modell építése

model = Sequential()

model.add(LSTM(50, activation='relu', input_shape=(sequence_length, 1)))

model.add(Dense(1))

model.compile(optimizer='adam', loss='mse')

# Tanítás

model.fit(X, Y, epochs=200, verbose=1)

# Előrejelzés (példa)

test_input = np.array([45, 12, 23, 34, 5])  # utolsó kihúzott számok

test_input = test_input.reshape((1, sequence_length, 1))

predicted_next_number = model.predict(test_input)

print("Becsült következő szám:", predicted_next_number[0][0])

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

A Python program képességei nagyban függenek a feladattól és a rendelkezésre álló algoritmusoktól, adatforrásoktól. A legmagasabb szintű, bonyolult tudományos feladatok, amelyeket Python képes elvégezni, általában a következők:

1. Kvantummechanika és kvantumszámítógépes szimulációk

Kvantumállapotok szimulálása sok részecske esetén.

Kvantumalgoritmusok (pl. Shor algoritmus, Grover algoritmus) szimulálása klasszikus számítógépen.

2. Generatív modellek és mesterséges intelligencia a tudományos kutatásban

Nagyméretű nyelvi modellek (pl. GPT-szerű modellek) létrehozása és finomhangolása.

Molekuláris szerkezetek generálása, gyógyszertervezés (pl. generatív ellenfelek, GAN-ek vagy variációs autoenkóderek).

3. Számítási csillagászat és asztrofizika

Nagy adatmennyiségek elemzése, például a csillagászati szimulációk (pl. galaxisok mozgásának vagy kozmikus folyamatoknak a modellezése).

Szupernóva-robbanások vagy fekete lyukak szimulációja.

4. Genomika és bioinformatika

Nagyméretű genom adatok elemzése, mutációk keresése, genetikai hálózatok modellezése.

Molekulák és fehérjeszerkezetek szimulációja.

5. Tudományos szimulációk és numerikus módszerek

Finom numerikus módszerek alkalmazása összetett fizikai, kémiai vagy biológiai rendszerek modellezésére (pl. CFD – folyadékkígyó dinamikája, molekuláris dinamikák, általános relativitáselmélet szimulációja). A legmagasabb szintű tudományos feladatok, melyekhez Python-t használunk, általában nagy számítási igényű szimulációk, komplex adatelemzések és mesterséges intelligencia modellek, melyekhez szorosan kapcsolódnak a matematika, fizika, kémia és biológia legújabb eredményei.

Ezekhez gyakran párhuzamosítás, GPU/TPU gyorsítás és speciális algoritmusok szükségesek, de Python – különösen a megfelelő könyvtárak (pl. TensorFlow, PyTorch, SciPy, NumPy, Dask, mpi4py) segítségével – képes ilyen feladatokat végrehajtani.

Kvantumfizika szimulációk (pl. kvantumállapotok modellezése)

Molekuláris dinamika vagy gyógyszertervezés

Asztrofizikai szimulációk (pl. galaxisok mozgása)

Genomikai adatelemzés

Nagyméretű numerikus szimulációk (pl. CFD vagy fizikai rendszerek)

Mesterséges intelligencia a tudományos kutatásban (pl. generatív modellek, gépi tanulás komplex adatokon) Mutatok egy példát asztrofizikai szimulációk (pl. galaxisok mozgása)

import numpy as np

import matplotlib.pyplot as plt

# Konstansok

G = 1.0  # Gravitációs állandó

dt = 0.01  # Lépték idő

num_steps = 1000  # Iterációk száma

# Részecskék száma

N = 50

# Kezdeti pozíciók és tömegek

positions = np.random.randn(N, 3) * 10

velocities = np.zeros((N, 3))

masses = np.random.rand(N) * 10 + 1

# Szimulációs ciklus

for step in range(num_steps):

    accelerations = np.zeros_like(positions)

    for i in range(N):

        for j in range(i + 1, N):

            r = positions[j] - positions[i]

            dist = np.linalg.norm(r) + 1e-5  # Elkerülni a nullát

            force = G * masses[i] * masses[j] / dist**3 * r

            accelerations[i] += force / masses[i]

            accelerations[j] -= force / masses[j]

    # Sebességek frissítése

    velocities += accelerations * dt

    # Pozíciók frissítése

    positions += velocities * dt

# Ábrázolás

fig = plt.figure()

ax = fig.add_subplot(111, projection='3d')

ax.scatter(positions[:,0], positions[:,1], positions[:,2])

ax.set_title("Egyszerű galaxis szimuláció")

plt.show()

Az asztrofizikai szimulációk, például galaxisok mozgásának modellezése, rendkívül összetett feladatok. Ezek a szimulációk általában sok részecske (pl. csillagok, porfelhők, fekete lyukak) kölcsönhatásának számítását jelentik, ahol gravitatív erők hatnak egymásra.

Hogyan működik egy ilyen szimuláció Pythonban?

Általános lépések:

Részecskék inicializálása: pozíciók, tömegek, sebességek.

Gravitációs kölcsönhatás számítása: minden részecske hatással van minden másra (N-túl sok esetben hatékony módszerek szükségesek, pl. Barnes-Hut algoritmus, hogy csökkentsék a számítási komplexitást).

Időléptékek szerinti iteráció: pozíciók és sebességek frissítése a gravitációs erők alapján.

Vizualizáció: a rendszer állapotának megjelenítése.

Egyszerű példaprogram

Az alábbiakban bemutatok egy egyszerű példát, amely 3D-ben szimulál néhány részecske mozgását gravitációs kölcsönhatás mellett. Ez nem fogja modellezni a valódi galaxisokat, de jól szemlélteti az alapokat.

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

Barnes-Hut algoritmus alapvető implementációja ez a kód egy fa struktúrát épít, majd ezt felhasználva számítja ki a gravitációs erőket.

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

import numpy as np

class OctreeNode:

    def __init__(self, center, size):

        self.center = center  # Középpont koordináták

        self.size = size  # Téglalap mérete

        self.children = [None] * 8  # Nyolc gyerek (octree)

        self.mass = 0.0

        self.mass_center = np.zeros(3)

        self.particle = None  # Csak levélben van részecske

def insert_particle(node, particle, pos, mass):

    if node.particle is None and all(c is None for c in node.children):

        # Üres levél

        node.particle = (pos, mass)

        node.mass = mass

        node.mass_center = pos

    else:

        # Részecske beszúrása

        if node.particle is not None:

            # Szétbontás

            existing_pos, existing_mass = node.particle

            node.particle = None

            subdivide(node)

            insert_particle(node, existing_pos, existing_pos, existing_mass)

        # Gyerek kiválasztása

        offset = (pos > node.center).astype(int)

        index = offset[0] * 4 + offset[1] * 2 + offset[2]

        if node.children[index] is None:

            new_center = node.center + (offset * 2 - 1) * node.size / 4

            node.children[index] = OctreeNode(new_center, node.size / 2)

        insert_particle(node.children[index], pos, pos, mass)

        # Tömegközéppont frissítése

        node.mass += mass

        node.mass_center = (node.mass_center * (node.mass - mass) + pos * mass) / node.mass

def subdivide(node):

    pass

def compute_force(particle_pos, node, theta=0.5, G=1.0, eps=0.01):

    force = np.zeros(3)

    if node is None or (node.particle is not None and np.array_equal(node.particle[0], particle_pos)):

        return force

    r = node.mass_center - particle_pos

    dist = np.linalg.norm(r) + eps

    if (node.size / dist) < theta or node.particle is not None:

        force += G * node.mass * r / dist**3

    else:

        for child in node.children:

            if child is not None:

                force += compute_force(particle_pos, child, theta, G, eps)

    return force

# Fő szimuláció

N = 100

positions = np.random.randn(N, 3) * 50

velocities = np.zeros((N, 3))

masses = np.random.rand(N) * 5 + 1

for step in range(100):

    # Fa építése

    root = OctreeNode(np.zeros(3), 200)

    for i in range(N):

        insert_particle(root, positions[i], positions[i], masses[i])

    # Erő kiszámítása

    accelerations = np.zeros_like(positions)

    for i in range(N):

        force = compute_force(positions[i], root)

        accelerations[i] = force / masses[i]

    # Frissítés

    velocities += accelerations * 0.1

    positions += velocities * 0.1

# Eredmény vizualizáció

import matplotlib.pyplot as plt

fig = plt.figure()

ax = fig.add_subplot(111, projection='3d')

ax.scatter(positions[:, 0], positions[:, 1], positions[:, 2])

plt.show()

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

Nagy rendszerek esetén a fa építése és keresése is időigényes lehet, de a Barnes-Hut csökkenti az összegzési költséget. Valódi alkalmazásokban érdemes meglévő, optimalizált könyvtárakat használni, például a Gadget vagy a Rebound szimulációs szoftvereket alkalmaz. Az alábbiakban bemutatom, hogyan lehet optimalizálni a Barnes-Hut szimulációt Pythonban, hogy gyorsabb és hatékonyabb legyen. Az optimalizálás több irányból is megközelíthető: Numpy vektorizációk alkalmazása Adatszerkezetek hatékonyabb kezelése

Rekurzió csökkentése vagy iteratív megközelítés Egyszerűsítés az algoritmuson Az alábbi példában egy optimalizáltabb változatot mutatok be, ahol: A faépítés és keresés gyorsabbá válik A számítások vektorizált módon történnek.

Kvantumszimuláció Qiskittel pip install qiskit egy egyszerű kvantumszámítógépes szimuláció

 from qiskit import QuantumCircuit, Aer, execute

from qiskit.visualization import plot_bloch_multivector

import matplotlib.pyplot as plt

# Kvantumkör létrehozása: 1 qubit

qc = QuantumCircuit(1)

# Hadamard kapu alkalmazása: szuperpozíció létrehozása

qc.h(0)

# Állapotokat mérünk

qc.measure_all()

# Szimulátor kiválasztása

simulator = Aer.get_backend('statevector_simulator')

# A kör futtatása

result = execute(qc, simulator).result()

# Állapot vektora

statevector = result.get_statevector()

# Megjelenítés a Bloch gömbön

plot_bloch_multivector(statevector)

plt.show()

      Mit csinál ez a kód?

Létrehoz egy kvantumkört egy qubit-tal Alkalmaz egy Hadamard kaput, ami szuperpozícióba hozza az állapotot Szimulálja az állapotot Megjeleníti a Bloch gömbön az eredményt.

Statisztikai elemzés; a leggyakoribb ismétlődés

 Lottósorsolás statisztikai elemzése; Ez a program a korábbi lottósorsolások adatait elemzi. A program kiszámítja az egymást követő sorsolások közötti közös számok számát, kiszámítja az egyezések átlagos számát, kiértékeli az egyes számok gyakoriságát, és összefoglalja az eredményeket.

## Generált kód (rövid verzió)

```python

Visszajelzés küldése

Oldalsó panelek

Előzmények

Mentve

draws_raw = """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

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

2, 5, 6, 8, 9, 14, 33

3, 12, 13, 14, 15, 21, 26

5, 8, 9, 13, 16, 22, 27

2, 3, 5, 19, 26, 27, 28

5, 15, 22, 23, 28, 32, 33

7, 8, 10, 14, 15, 27, 31

11, 17, 18, 25, 26, 29, 35

2, 10, 13, 16, 17, 27, 34

4, 5, 10, 15, 22, 30, 35

5, 12, 13, 18, 24, 25, 35

1, 5, 9, 14, 26, 28, 30

1, 9, 10, 16, 20, 29, 33

6, 9, 17, 22, 25, 28, 34

5, 6, 15, 16, 18, 27, 33

4, 7, 14, 21, 23, 24, 33""".splitlines()

huzasok = [sorted(map(int, line.split(','))) for line in draws_raw]

print("=" * 60)

print("STATISTICAL ANALYSIS - PREVIOUS DRAWS")

print("=" * 60)

egyezesek_szama = [len(set(huzasok[i-1]) & set(huzasok[i])) for i in range(1, len(huzasok))]

for i in range(1, len(huzasok)):

    print(f"Week {i} & Week {i+1}: {sorted(set(huzasok[i-1]) & set(huzasok[i]))} ({egyezesek_szama[i-1]} matches)")

atlag_egyezes = sum(egyezesek_szama) / len(egyezesek_szama)

print(f"\nAverage Matches: {atlag_egyezes:.2f}")

for i in range(5, len(huzasok)):

    ot_het_elotte = set().union(*huzasok[i-5:i])

    print(f"Week {i+1}: {len(ot_het_elotte & set(huzasok[i]))} matches from the last 5 weeks")

gyakorisag = {}

for huzas in huzasok:

    for szam in huzas:

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

rendezett_gyak = sorted(gyakorisag.items(), key=lambda x: x[1], reverse=True)

print("Top 10 Most Frequent Numbers:")

for szam, gyak in rendezett_gyak[:10]:

    print(f"  {szam}: {gyak} times")

print("\nTop 10 Least Frequent Numbers:")

for szam, gyak in rendezett_gyak[-10:]:

    print(f"  {szam}: {gyak} times")

print("\n" + "=" * 60)

print("SUMMARY STATISTICS")

print("=" * 60)

print(f"Total Draws: {len(huzasok)}")

print(f"Average Matches from Previous Week: {atlag_egyezes:.2f}")

print(f"Maximum Matches: {max(egyezesek_szama)}")

print(f"Minimum Matches: {min(egyezesek_szama)}")

print(f"Most Frequent Number: {rendezett_gyak[0][0]} ({rendezett_gyak[0][1]} times)")

Python gyakorlat

Feladat; A skandináv lottó kézi sorsolásának nyerőszámait láthatod itt időrendben, írj egy programot pythonban, ami kiválasztja azt a 7 számot amit a legrégebben húztak;

Megoldás;

 

draws = [

    [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],

]

last_seen = {}

for i, row in enumerate(draws):

    for n in row:

        if n not in last_seen:

            last_seen[n] = i

sorted_numbers = sorted(last_seen.items(), key=lambda x: (x[1], x[0]))

result = [n for n, _ in sorted_numbers[:7]]

print(result)

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

# -*- coding: utf-8 -*-

# A Skandináv lottó kézi sorsolásának nyerőszámait láthatod itt időrendben.

# A program kiválasztja azt a 7 számot, amelyeket a legrégebben húztak.

draws_raw = """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

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

2, 5, 6, 8, 9, 14, 33

3, 12, 13, 14, 15, 21, 26

5, 8, 9, 13, 16, 22, 27

2, 3, 5, 19, 26, 27, 28

5, 15, 22, 23, 28, 32, 33

7, 8, 10, 14, 15, 27, 31

11, 17, 18, 25, 26, 29, 35

2, 10, 13, 16, 17, 27, 34

4, 5, 10, 15, 22, 30, 35

5, 12, 13, 18, 24, 25, 35

1, 5, 9, 14, 26, 28, 30

1, 9, 10, 16, 20, 29, 33

6, 9, 17, 22, 25, 28, 34

5, 6, 15, 16, 18, 27, 33

4, 7, 14, 21, 23, 24, 33""".splitlines()

# A sorsolások feldolgozása

all_draws = []

for line in draws_raw:

    cleaned_line = line.replace(' ', '').strip()

    numbers = list(map(int, cleaned_line.split(',')))

    all_draws.append(numbers)

# Minden számra tároljuk az első sorsolás indexét (azt, hogy melyik körben húzták legrégebben)

first_occurrence = {}

for draw_idx, draw in enumerate(all_draws):

    for num in draw:

        if num not in first_occurrence:

            first_occurrence[num] = draw_idx

# A legrégebben húzott 7 szám (legkorábban megjelenők)

earliest = sorted(first_occurrence.keys(), key=lambda x: first_occurrence[x])[:7]

# Eredmény kiírása

print("A legrégebben húzott 7 szám:", sorted(earliest))

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

http://www.thebzzs.com/skandinavlotto

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

# -*- coding: utf-8 -*-

# A Skandináv lottó kézi sorsolásának nyerőszámait láthatod itt időrendben.

# A program kiválasztja azt a 7 számot, amelyeket a legrégebben húztak.

draws_raw = """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

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

2, 5, 6, 8, 9, 14, 33

3, 12, 13, 14, 15, 21, 26

5, 8, 9, 13, 16, 22, 27

2, 3, 5, 19, 26, 27, 28

5, 15, 22, 23, 28, 32, 33

7, 8, 10, 14, 15, 27, 31

11, 17, 18, 25, 26, 29, 35

2, 10, 13, 16, 17, 27, 34

4, 5, 10, 15, 22, 30, 35

5, 12, 13, 18, 24, 25, 35

1, 5, 9, 14, 26, 28, 30

1, 9, 10, 16, 20, 29, 33

6, 9, 17, 22, 25, 28, 34

5, 6, 15, 16, 18, 27, 33

4, 7, 14, 21, 23, 24, 33""".splitlines()

# A sorsolások feldolgozása

all_draws = []

for line in draws_raw:

    cleaned_line = line.replace(' ', '').strip()

    numbers = list(map(int, cleaned_line.split(',')))

    all_draws.append(numbers)

# Minden számra tároljuk az első sorsolás indexét (azt, hogy melyik körben húzták legrégebben)

first_occurrence = {}

for draw_idx, draw in enumerate(all_draws):

    for num in draw:

        if num not in first_occurrence:

            first_occurrence[num] = draw_idx

# A legrégebben húzott 7 szám (legkorábban megjelenők)

earliest = sorted(first_occurrence.keys(), key=lambda x: first_occurrence[x])[:7]

# Eredmény kiírása

print("A legrégebben húzott 7 szám:", sorted(earliest))

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

magyar karakterrel

# -*- coding: utf-8 -*- magyar

file beolnasása

with open('adatok.txt', 'r', encoding='utf-8') as fajl: tartalom = fajl.read() print(tartalom)

Az adatok alapján mely számoknak van a legnagyobb valószinüsége, hogy a következő sorsoláson kihuzzákA Skandnáv lottó esetén minden számnak matematikailag szabálya a valószínűsége , hogy a következő sorsoláson kihúzzák (a szerint minden szám független, minden húzásnál minden számot “újra keverik”). Viszont a talált adatok alapján modellezhetsz egy heurisztikát : pl. azt mondhatjuk, hogy a leggyakrabban előforduló számoknak „pszichológiai” vagy statisztikai szempontból nagyobb az esélye, hogy újra előkerülnek, de ez nem jelent valódi valószínűség-növekedést.scribd+1

Mit mutatnak az adatok?

A korábban ajánlott sorsolások alapján számolgatja a leggyakrabban előforduló számokat (a legtöbbször kihúzottak) a következők közül:

•24, 25, 27, 30, 33 nagyon sokszor szerepelnek (10–13-szor körül).

•2, 5, 7, 9, 17, 21, 22, 23, 26, 31, 32 is gyakran, de valamivel ritkábban.

Ha azt a kérdést értelmezték, hogy mely számoknak a „legnagyobb esélye” van újra kihúzásra a statisztikai minta alapján , a válasz a választás alapján:

•24, 25, 27, 30, 33 – a legtöbb szélsőségesen gyakori szám ebben a sorsolási listában. 

•Ezen belül a 25, 27, 30, 33 rendkívül stabilan gyakoriak.

Figyelmeztetés fontos statisztikai értelemben

•A lottó valóban emlékezetmentes : a múltbeli húzások nem befolyásolják a jövőbeni számokat.index

•A „legnagyobb valószínűség” csak abban az értelemben értelmezhető, ha hiszünk abban, hogy a lottó nem teljesen véletlen, vagy ha pszichológiai / játékstratégiai szempontból szeretnénk „nagyobb eséllyel játszani”.

https://python.tanit.hu/?grade=0&id=10

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

A legrégebben kihúzott 18 számból véletlenszerüen generál 7 számot a program;

import random; print(*random.sample([1,2,8,9,11,12,13,15,17,18,22,24,25,27,29,30,32,33], 7))


Leggyakoribb számok 19, 14, 25, 11, 30, 6, 5 
Legritkább számok 17, 33, 2, 12, 20, 9, 15 
A te számsorod (1, 2, 8, 9, 11, 12, 13, 15, 17, 18, 22, 24, 25, 27, 29, 30, 32, 33):
 Stratégiai elemzés
Felső gyakori 11, 25, 30  
Közepes 1, 6(hiányzik), 14(hiányzik), 18, 24, 29  
Ritka 2, 9, 12, 15, 17, 33 
Javaslat: Ha játszol, tarts meg 1-2 számot az előző heti nyerőből, és 5-6 újat!

Összehasonlitás

import sqlite3
import random

DB_NAME = "skandinav_lotto.db"


# ----------------------------
# ADATBETÖLTÉS
# ----------------------------
def load_draws():
conn = sqlite3.connect(DB_NAME)
cur = conn.cursor()

cur.execute("SELECT numbers FROM draws ORDER BY id ASC")

rows = cur.fetchall()
conn.close()

return [list(map(int, r[0].split(","))) for r in rows]


# ----------------------------
# STATISZTIKA
# ----------------------------
def stats(draws):
last_seen = {}
freq = {}

for i, d in enumerate(draws):
for n in d:
last_seen[n] = i
freq[n] = freq.get(n, 0) + 1

return last_seen, freq


# ----------------------------
# MODELL 1: RANDOM
# ----------------------------
def model_random():
return random.sample(range(1, 36), 7)


# ----------------------------
# MODELL 2: COLD (hideg)
# ----------------------------
def model_cold(last_seen):
sorted_nums = sorted(last_seen.items(), key=lambda x: x[1])
return [n for n, _ in sorted_nums[:7]]


# ----------------------------
# MODELL 3: HOT (gyakori)
# ----------------------------
def model_hot(freq):
sorted_nums = sorted(freq.items(), key=lambda x: x[1], reverse=True)
return [n for n, _ in sorted_nums[:7]]


# ----------------------------
# MODELL 4: AI súlyozott
# ----------------------------
def model_ai(last_seen, freq, t):
weights = {}

for n in range(1, 36):
cold = t - last_seen.get(n, -1)
f = freq.get(n, 0)

score = cold - f * 0.5
if score < 0:
score = 0.1

weights[n] = score

nums = list(weights.keys())
w = list(weights.values())

return random.choices(nums, weights=w, k=7)


# ----------------------------
# BACKTEST
# ----------------------------
def backtest(draws, model_name):
last_seen, freq = stats(draws)

hits_total = 0
bankroll = 0
ticket_price = 300

for i in range(10, len(draws)):
history = draws[:i]
actual = set(draws[i])

last_seen, freq = stats(history)

if model_name == "random":
ticket = set(model_random())
elif model_name == "cold":
ticket = set(model_cold(last_seen))
elif model_name == "hot":
ticket = set(model_hot(freq))
elif model_name == "ai":
ticket = set(model_ai(last_seen, freq, len(history)))
else:
continue

hits = len(ticket & actual)
hits_total += hits

bankroll -= ticket_price
bankroll += hits * 1000 # egyszerű jutalom modell

return hits_total, bankroll


# ----------------------------
# KIVÁLASZTÓ
# ----------------------------
def main():
draws = load_draws()

if len(draws) < 15:
print("Kevés adat")
return

models = ["random", "cold", "hot", "ai"]

results = {}

print("🤖 AI MODEL KIVÁLASZTÁS\n")

for m in models:
hits, money = backtest(draws, m)
results[m] = money

print(f"{m.upper()} -> bankroll: {money} Ft | találatok: {hits}")

best = max(results, key=results.get)

print("\n🏆 LEGJOBB MODELL:", best.upper())


if __name__ == "__main__":
main()

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

import sqlite3
import numpy as np

DB_NAME = "skandinav_lotto.db"

NUMBERS = 35
WINDOW = 5


# ----------------------------
# ADAT
# ----------------------------
def load_draws():
conn = sqlite3.connect(DB_NAME)
cur = conn.cursor()

cur.execute("SELECT numbers FROM draws ORDER BY id ASC")
rows = cur.fetchall()
conn.close()

data = []
for r in rows:
vec = np.zeros(NUMBERS)
for n in map(int, r[0].split(",")):
vec[n - 1] = 1
data.append(vec)

return np.array(data)


# ----------------------------
# EGYSZERŰ "NEURÁLIS" SÚLYOK
# ----------------------------
def train_like_nn(data):
weights = np.zeros(NUMBERS)

for i in range(len(data) - 1):
weights += data[i] * (i / len(data))

return weights


# ----------------------------
# PREDIKCIÓ
# ----------------------------
def predict(weights):
probs = weights + np.random.random(NUMBERS) * 0.1

top7 = np.argsort(probs)[-7:] + 1

return sorted(top7)


# ----------------------------
# MAIN
# ----------------------------
def main():
data = load_draws()

if len(data) < 10:
print("Kevés adat")
return

weights = train_like_nn(data)

result = predict(weights)

print("🧠 TF-NÉLKÜLI NEURÁLIS AI LOTTÓ:\n")
print(result)


if __name__ == "__main__":
main()

Bankroll szimuláció

import sqlite3
import random

DB_NAME = "skandinav_lotto.db"

TICKET_COST = 300

PRIZES = {
0: 0,
1: 0,
2: 0,
3: 1000,
4: 10000,
5: 100000,
6: 1000000,
7: 5000000 # szimulált jackpot
}


# ----------------------------
# ADATBETÖLTÉS
# ----------------------------
def load_draws():
conn = sqlite3.connect(DB_NAME)
cur = conn.cursor()

cur.execute("""
SELECT numbers
FROM draws
ORDER BY id ASC
""")

rows = cur.fetchall()
conn.close()

return [list(map(int, r[0].split(","))) for r in rows]


# ----------------------------
# STAT + SÚLYOK
# ----------------------------
def stats(draws):
last_seen = {}
freq = {}

for i, d in enumerate(draws):
for n in d:
last_seen[n] = i
freq[n] = freq.get(n, 0) + 1

return last_seen, freq


def weights(last_seen, freq, t):
w = {}

for n in range(1, 36):
cold = t - last_seen.get(n, -1)
f = freq.get(n, 0)

score = cold - f * 0.5
if score < 0:
score = 0.1

w[n] = score

return w


def generate_ticket(weights):
nums = list(weights.keys())
w = list(weights.values())

ticket = set()

while len(ticket) < 7:
ticket.add(random.choices(nums, weights=w, k=1)[0])

return ticket


# ----------------------------
# BANKROLL SZIMULÁCIÓ
# ----------------------------
def simulate(draws, start_money=100000):
bankroll = start_money

print(f"💰 KEZDŐ BANKROLL: {bankroll} Ft\n")

for i in range(10, len(draws)):
history = draws[:i]
actual = set(draws[i])

last_seen, freq = stats(history)
w = weights(last_seen, freq, len(history))

ticket = generate_ticket(w)

hits = len(ticket & actual)

reward = PRIZES.get(hits, 0)

bankroll -= TICKET_COST
bankroll += reward

print(f"{i}. sorsolás | találat: {hits} | nyeremény: {reward} Ft | bankroll: {bankroll} Ft")

print("\n------------------------")
print(f"🏁 VÉGSŐ BANKROLL: {bankroll} Ft")


# ----------------------------
# MAIN
# ----------------------------
def main():
draws = load_draws()

if len(draws) < 15:
print("Túl kevés adat!")
return

simulate(draws)


if __name__ == "__main__":
main()

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

https://www.betcraft.ai/bankroll-simulator

Backtest statisztikából

import sqlite3
import random

DB_NAME = "skandinav_lotto.db"


# ----------------------------
# ADATBETÖLTÉS
# ----------------------------
def load_draws():
conn = sqlite3.connect(DB_NAME)
cur = conn.cursor()

cur.execute("""
SELECT numbers
FROM draws
ORDER BY id ASC
""")

rows = cur.fetchall()
conn.close()

return [list(map(int, r[0].split(","))) for r in rows]


# ----------------------------
# STATISZTIKA
# ----------------------------
def calc_stats(history):
last_seen = {}
freq = {}

for i, draw in enumerate(history):
for n in draw:
last_seen[n] = i
freq[n] = freq.get(n, 0) + 1

return last_seen, freq


# ----------------------------
# SÚLYOZÁS
# ----------------------------
def weights(last_seen, freq, t):
w = {}

for n in range(1, 36):
cold = t - last_seen.get(n, -1)
f = freq.get(n, 0)

weight = cold - f * 0.5

if weight < 0:
weight = 0.1

w[n] = weight

return w


# ----------------------------
# SZELVÉNY GENERÁLÁS
# ----------------------------
def generate(weights):
nums = list(weights.keys())
w = list(weights.values())

result = set()

while len(result) < 7:
result.add(random.choices(nums, weights=w, k=1)[0])

return sorted(result)


# ----------------------------
# BACKTEST
# ----------------------------
def backtest(draws):
total_hits = 0
count = 0

print("📊 BACKTEST INDUL...\n")

# csak múltból jósolunk
for i in range(10, len(draws)):
history = draws[:i]
actual = draws[i]

last_seen, freq = calc_stats(history)
w = weights(last_seen, freq, len(history))

prediction = set(generate(w))
actual_set = set(actual)

hits = len(prediction & actual_set)

total_hits += hits
count += 1

print(f"{i}. sorsolás -> találat: {hits}")

avg = total_hits / count if count else 0

print("\n----------------------")
print("📈 ÁTLAG TALÁLAT:", round(avg, 2))


# ----------------------------
# MAIN
# ----------------------------
def main():
draws = load_draws()

if len(draws) < 15:
print("Túl kevés adat backtesthez!")
return

backtest(draws)


if __name__ == "__main__":
main()

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

https://www.betcraft.ai/bankroll-simulator

Statisztikai súlyozás + diverzifikáció.

import sqlite3
import random

DB_NAME = "skandinav_lotto.db"


# ----------------------------
# ADATBETÖLTÉS
# ----------------------------
def load_draws():
conn = sqlite3.connect(DB_NAME)
cur = conn.cursor()

cur.execute("""
SELECT numbers
FROM draws
ORDER BY id ASC
""")

rows = cur.fetchall()
conn.close()

return [list(map(int, r[0].split(","))) for r in rows]


# ----------------------------
# STATISZTIKA
# ----------------------------
def stats(draws):
last_seen = {}
freq = {}

for i, numbers in enumerate(draws):
for n in numbers:
last_seen[n] = i
freq[n] = freq.get(n, 0) + 1

return last_seen, freq


# ----------------------------
# SÚLYOK
# ----------------------------
def weights(last_seen, freq, total):
w = {}

for n in range(1, 36):
last = last_seen.get(n, -1)
f = freq.get(n, 0)

cold = total - last
weight = cold - (f * 0.5)

if weight < 0:
weight = 0.1

w[n] = weight

return w


# ----------------------------
# SZELVÉNY GENERÁLÁS
# ----------------------------
def pick(weights, temperature=1.0):
nums = list(weights.keys())
w = [x ** temperature for x in weights.values()]

result = set()

while len(result) < 7:
result.add(random.choices(nums, weights=w, k=1)[0])

return sorted(result)


# ----------------------------
# KOCKÁZATI SZINTEK
# ----------------------------
def generate_tickets(weights):
low_risk = pick(weights, temperature=0.5) # stabil
mid_risk = pick(weights, temperature=1.0) # balanced
high_risk = pick(weights, temperature=2.0) # extrém

return low_risk, mid_risk, high_risk


# ----------------------------
# MAIN
# ----------------------------
def main():
draws = load_draws()

if not draws:
print("Nincs adat!")
return

last_seen, freq = stats(draws)
w = weights(last_seen, freq, len(draws))

low, mid, high = generate_tickets(w)

print("🎯 KOCKÁZAT ALAPÚ LOTTÓ AI RENDSZER\n")

print("🟢 ALACSONY KOCKÁZAT:")
print(low)

print("\n🟡 KÖZEPES KOCKÁZAT:")
print(mid)

print("\n🔴 MAGAS KOCKÁZAT:")
print(high)


if __name__ == "__main__":
main()

Súlyozott diverzifikáció előrejelzés, statisztikai szimulációval

import sqlite3
import random

DB_NAME = "skandinav_lotto.db"


# ----------------------------
# ADATBETÖLTÉS
# ----------------------------
def load_draws():
conn = sqlite3.connect(DB_NAME)
cur = conn.cursor()

cur.execute("""
SELECT numbers
FROM draws
ORDER BY id ASC
""")

rows = cur.fetchall()
conn.close()

return [list(map(int, r[0].split(","))) for r in rows]


# ----------------------------
# STATISZTIKA SZÁMOLÁS
# ----------------------------
def calculate_stats(draws):
last_seen = {}
freq = {}

for idx, numbers in enumerate(draws):
for n in numbers:
last_seen[n] = idx
freq[n] = freq.get(n, 0) + 1

return last_seen, freq


# ----------------------------
# AI-SÚLYOZÁS
# ----------------------------
def ai_weights(last_seen, freq, total_draws):
weights = {}

for n in range(1, 36):
# ha soha nem volt
last = last_seen.get(n, -1)
f = freq.get(n, 0)

# hidegség (minél régebbi, annál nagyobb)
cold_score = (total_draws - last)

# gyakoriság büntetés
freq_penalty = f * 0.5

weight = cold_score - freq_penalty

if weight < 0:
weight = 0.1

weights[n] = weight

return weights


# ----------------------------
# AI SZÁM GENERÁLÁS
# ----------------------------
def ai_pick_numbers(weights):
numbers = list(weights.keys())
w = list(weights.values())

result = set()

while len(result) < 7:
pick = random.choices(numbers, weights=w, k=1)[0]
result.add(pick)

return sorted(result)


# ----------------------------
# MAIN
# ----------------------------
def main():
draws = load_draws()

if not draws:
print("Nincs adat az adatbázisban!")
return

last_seen, freq = calculate_stats(draws)

weights = ai_weights(last_seen, freq, len(draws))

prediction = ai_pick_numbers(weights)

print("🤖 AI LOTTÓ ELŐREJELZÉS (súlyozott modell):\n")

print("🎯 Javasolt 7 szám:")
print(prediction)


if __name__ == "__main__":
main()