2026. május 25., hétfő

Ö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()

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

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()

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

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()

Másik sql és python

import sqlite3

DB_NAME = "skandinav_lotto.db"


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]


def coldest_7(draws):
    last_index = {}

    for idx, numbers in enumerate(draws):
        for n in numbers:
            last_index[n] = idx

    sorted_cold = sorted(last_index.items(), key=lambda x: x[1])

    return sorted_cold[:7]


def main():
    draws = load_draws()

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

    result = coldest_7(draws)

    print("️ LEGHIDEGEBB 7 SZÁM:\n")

    for num, idx in result:
        print(f"{num} -> utoljára a {idx}. sorsolásban volt")


if __name__ == "__main__":
    main()

 

Utolsó 10 kivételével skandináv

import sqlite3
import random

DB_NAME = "skandinav_lotto.db"


def create_db():
conn = sqlite3.connect(DB_NAME)
cur = conn.cursor()

cur.execute("""
CREATE TABLE IF NOT EXISTS draws (
id INTEGER PRIMARY KEY AUTOINCREMENT,
date TEXT,
type TEXT,
numbers TEXT
)
""")

conn.commit()
conn.close()


def insert_sample_data():
data = [
("2026-05-06", "kezi", "1,2,9,11,18,29,30"),
("2026-04-29", "kezi", "8,15,23,25,26,30,34"),
("2026-04-22", "kezi", "2,4,8,11,26,27,28"),
("2026-04-15", "kezi", "7,12,16,25,30,32,33"),
("2026-04-08", "kezi", "2,4,12,21,25,30,33"),
("2026-04-01", "kezi", "9,14,15,17,19,21,23"),
("2026-03-25", "kezi", "7,10,17,20,22,23,29"),
("2026-03-18", "kezi", "1,7,10,18,20,22,35"),
("2026-03-11", "kezi", "1,3,7,17,19,21,28"),
("2026-03-04", "kezi", "5,24,25,27,31,32,33"),
]

conn = sqlite3.connect(DB_NAME)
cur = conn.cursor()

cur.executemany("""
INSERT INTO draws (date, type, numbers)
VALUES (?, ?, ?)
""", data)

conn.commit()
conn.close()


def get_last_10_numbers():
conn = sqlite3.connect(DB_NAME)
cur = conn.cursor()

cur.execute("""
SELECT numbers
FROM draws
ORDER BY date DESC
LIMIT 10
""")

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

excluded = set()

for row in rows:
nums = row[0].split(",")
for n in nums:
excluded.add(int(n))

return excluded


def generate_7_numbers(excluded):
available = [i for i in range(1, 36) if i not in excluded]

# ha túl kevés szám maradna (biztonság)
if len(available) < 7:
raise ValueError("Túl kevés szám maradt a sorsoláshoz!")

return random.sample(available, 7)


def main():
create_db()
insert_sample_data()

excluded = get_last_10_numbers()

print("Kizárt számok (utolsó 10 sorsolásból):")
print(sorted(excluded))
print("\n-----------------------------\n")

result = generate_7_numbers(excluded)

print("Új 7 kihúzott szám:")
print(sorted(result))


if __name__ == "__main__":
main()

A legrégebben kihúzott 7 szám

# SKANDINAV LOTTO - Legregebben kihuzott 7 szam
# Internetrol letoltve (manualis beillesztes)

def get_legregebben_kihuzottak():
    """
    Visszaadja a legrgebben kihuzott szamokat es datumokat.
    Adatok forrasa: https://www.lotto567.hu/skandinav_lotto/legregebben_kihuzottak [web:57]
    Utolso frissites: 2025.10.22. [web:57]
    """
    
    # Manualisan letoltve az internetrol [web:57]
    data = [
        (33, "2025.09.03."),
        (32, "2025.09.10."),
        (26, "2025.09.24."),
        (20, "2025.09.24."),
        (30, "2025.09.24."),
        (13, "2025.10.01."),
        (29, "2025.10.01."),
        (12, "2025.10.08."),
        (17, "2025.10.08."),
        (21, "2025.10.08."),
        (27, "2025.10.08."),
        (8,  "2025.10.15."),
        (10, "2025.10.15."),
        (11, "2025.10.15."),
        (15, "2025.10.15."),
        (18, "2025.10.15."),
        (22, "2025.10.15."),
        (28, "2025.10.15."),
        (14, "2025.10.15."),
        (19, "2025.10.15."),
        (24, "2025.10.15."),
        (31, "2025.10.15."),
    ]
    
    return data


def main():
    print("=" * 70)
    print("SKANDINAV LOTTO - Legregebben kihuzott 7 szam")
    print("Forras: https://www.lotto567.hu/skandinav_lotto/legregebben_kihuzottak")
    print("Utolso frissites: 2025.10.22.")
    print("=" * 70)
    print()
    
    data = get_legregebben_kihuzottak()
    
    print(f"Osszes letolt adat: {len(data)} szam")
    print()
    
    # Legregebbi 7
    top_7 = data[:7]
    
    print("=" * 70)
    print("LEGRGEBBEN KIHUZOTT 7 SZAM:")
    print("=" * 70)
    print()
    
    numbers = []
    for i, (num, date_str) in enumerate(top_7, 1):
        numbers.append(num)
        print(f"{i}. {num:2} - utoljara kihuzva: {date_str}")
    
    print()
    print("=" * 70)
    print(f"Kivalasztott 7 szam: {sorted(numbers)}")
    print("=" * 70)
    print()
    
    print("Megj: Ezek a legvalzoszinuvebb szamok a kovetkezo sorsolashoz [web:57]")
    print(f"Legvaloszinubben kiejtett szamok: 33, 32, 26, 20, 30, 13, 29 [web:57]")


if __name__ == "__main__":
    main()
--------------

# SKANDINAV LOTTO - Legregebben kihuzott 7 szam
# Internetrol letoltve (manualis beillesztes)

def get_legregebben_kihuzottak():
    """
    Visszaadja a legrgebben kihuzott szamokat es datumokat.
    Adatok forrasa: https://www.lotto567.hu/skandinav_lotto/legregebben_kihuzottak [web:57]
    Utolso frissites: 2025.10.22. [web:57]
    """
    
    # Manualisan letoltve az internetrol [web:57]
    data = [
        (33, "2025.09.03."),
        (32, "2025.09.10."),
        (26, "2025.09.24."),
        (20, "2025.09.24."),
        (30, "2025.09.24."),
        (13, "2025.10.01."),
        (29, "2025.10.01."),
        (12, "2025.10.08."),
        (17, "2025.10.08."),
        (21, "2025.10.08."),
        (27, "2025.10.08."),
        (8,  "2025.10.15."),
        (10, "2025.10.15."),
        (11, "2025.10.15."),
        (15, "2025.10.15."),
        (18, "2025.10.15."),
        (22, "2025.10.15."),
        (28, "2025.10.15."),
        (14, "2025.10.15."),
        (19, "2025.10.15."),
        (24, "2025.10.15."),
        (31, "2025.10.15."),
    ]
    
    return data


def main():
    print("=" * 70)
    print("SKANDINAV LOTTO - Legregebben kihuzott 7 szam")
    print("Forras: https://www.lotto567.hu/skandinav_lotto/legregebben_kihuzottak")
    print("Utolso frissites: 2025.10.22.")
    print("=" * 70)
    print()
    
    data = get_legregebben_kihuzottak()
    
    print(f"Osszes letolt adat: {len(data)} szam")
    print()
    
    # Legregebbi 7
    top_7 = data[:7]
    
    print("=" * 70)
    print("LEGRGEBBEN KIHUZOTT 7 SZAM:")
    print("=" * 70)
    print()
    
    numbers = []
    for i, (num, date_str) in enumerate(top_7, 1):
        numbers.append(num)
        print(f"{i}. {num:2} - utoljara kihuzva: {date_str}")
    
    print()
    print("=" * 70)
    print(f"Kivalasztott 7 szam: {sorted(numbers)}")
    print("=" * 70)
    print()
    
    print("Megj: Ezek a legvalzoszinuvebb szamok a kovetkezo sorsolashoz [web:57]")
    print(f"Legvaloszinubben kiejtett szamok: 33, 32, 26, 20, 30, 13, 29 [web:57]")


if __name__ == "__main__":
    main()
-------------

2026. május 24., vasárnap

Egy összetett skandináv lottó elemző és generáló program python nyelven

Telepítés:

pip install requests matplotlib

A program fájlokat készít:

  • skandinav_lotto.csv
  • statisztika.png

Funkciók:

  • automatikus óránkénti frissítés,
  • AI-alapú súlyozás,
  • több stratégia,
  • grafikonkészítés,
  • több szelvény generálása,
  • utolsó húzás kizárása.

import requests
import csv
import random
import time
from io import StringIO
from collections import Counter
from datetime import datetime

import matplotlib.pyplot as plt

# ============================================
# SKANDINaV LOTTo AI ELEMZo RENDSZER
# ============================================
#
# Funkciok:
#
# 1. Automatikus CSV letöltes
# 2. CSV mentes
# 3. Gyakorisagi elemzes
# 4. Legregebben húzott szamok
# 5. AI-alapú pontozas
# 6. Több strategia
# 7. Több szelveny generalas
# 8. Grafikon keszites
#
# ============================================

URL = "https://www.szerencsejatek.hu/export/skandinav_lotto.csv"

# ============================================
# CSV LETÖLTeS
# ============================================

def download_data():

    print("Adatok letöltese...")

    response = requests.get(URL, timeout=10)
    response.raise_for_status()

    with open("skandinav_lotto.csv", "w", encoding="utf-8") as f:
        f.write(response.text)

    return response.text


# ============================================
# CSV FELDOLGOZaS
# ============================================

def parse_csv(text):

    csv_data = StringIO(text)

    reader = csv.reader(csv_data, delimiter=';')

    header = next(reader, None)

    draws = []

    for row in reader:

        try:

            if len(row) < 25:
                continue

            year = int(row[0])
            week = int(row[1])

            numbers = list(map(int, row[11:25]))

            draws.append({
                "year": year,
                "week": week,
                "numbers": numbers
            })

        except:
            continue

    return draws


# ============================================
# GYAKORISaG SZaMiTaS
# ============================================

def calculate_frequency(draws):

    freq = Counter()

    for draw in draws:

        for number in draw["numbers"]:
            freq[number] += 1

    return freq


# ============================================
# LEGReGEBBEN HÚZOTT SZaMOK
# ============================================

def calculate_age(draws):

    last_seen = {}

    for index in range(len(draws)-1, -1, -1):

        draw = draws[index]

        for number in draw["numbers"]:

            if number not in last_seen:
                last_seen[number] = len(draws) - index

    return last_seen


# ============================================
# AI PONTOZaS
# ============================================

def ai_score(draws):

    freq = calculate_frequency(draws)

    age = calculate_age(draws)

    latest = set(draws[-1]["numbers"])

    scores = {}

    for n in range(1, 36):

        if n in latest:
            continue

        frequency_score = freq[n]

        age_score = age.get(n, 999)

        # AI súlyozas
        score = (
            age_score * 2
            - frequency_score * 0.3
            + random.uniform(0, 5)
        )

        scores[n] = score

    return scores


# ============================================
# STRATeGIaK
# ============================================

def strategy_oldest(draws):

    age = calculate_age(draws)

    latest = set(draws[-1]["numbers"])

    ranking = []

    for n in range(1, 36):

        if n in latest:
            continue

        ranking.append((n, age.get(n, 999)))

    ranking.sort(key=lambda x: x[1], reverse=True)

    return sorted([x[0] for x in ranking[:7]])


def strategy_most_common(draws):

    freq = calculate_frequency(draws)

    latest = set(draws[-1]["numbers"])

    ranking = []

    for n in range(1, 36):

        if n in latest:
            continue

        ranking.append((n, freq[n]))

    ranking.sort(key=lambda x: x[1], reverse=True)

    return sorted([x[0] for x in ranking[:7]])


def strategy_ai(draws):

    scores = ai_score(draws)

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

    return sorted([x[0] for x in ranking[:7]])


def strategy_random():

    return sorted(random.sample(range(1, 36), 7))


# ============================================
# GRAFIKON
# ============================================

def draw_chart(draws):

    freq = calculate_frequency(draws)

    x = list(range(1, 36))
    y = [freq[n] for n in x]

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

    plt.bar(x, y)

    plt.xlabel("Szam")
    plt.ylabel("Elofordulas")
    plt.title("Skandinav lotto szamgyakorisag")

    plt.xticks(x)

    plt.tight_layout()

    plt.savefig("statisztika.png")

    print("\nGrafikon mentve: statisztika.png")


# ============================================
# SZELVeNYEK
# ============================================

def generate_tickets(draws):

    print("\n==============================")
    print("GENERaLT SZELVeNYEK")
    print("==============================")

    print("\n1. Legregebbi strategia:")
    print(strategy_oldest(draws))

    print("\n2. Leggyakoribb strategia:")
    print(strategy_most_common(draws))

    print("\n3. AI strategia:")
    print(strategy_ai(draws))

    print("\n4. Veletlen strategia:")
    print(strategy_random())


# ============================================
# AUTOMATIKUS FRISSiTeS
# ============================================

def auto_update():

    while True:

        try:

            print("\n===================================")
            print("Frissites ideje:", datetime.now())
            print("===================================")

            text = download_data()

            draws = parse_csv(text)

            if not draws:
                print("Nincs feldolgozhato adat.")
                continue

            latest = draws[-1]

            print("\nUtolso húzas:")
            print(sorted(latest["numbers"]))

            generate_tickets(draws)

            draw_chart(draws)

        except Exception as e:

            print("Hiba:", e)

        # 1 ora varakozas
        print("\nKövetkezo frissites 1 ora múlva...")
        time.sleep(3600)


# ============================================
# INDiTaS
# ============================================

if __name__ == "__main__":

    auto_update()

Skandináv lottó elemző

import requests
from collections import defaultdict
from datetime import datetime

# =========================
# Skandináv lottó elemző
# =========================
#
# Feladat:
# 1. Letölti az eddigi Skandináv lottó húzásokat
# 2. Kizárja az utolsó sorsolás 14 számát
# 3. Megnézi a többi szám közül melyiket húzták ki a legrégebben
# 4. Kiválaszt 7 számot
#
# Megjegyzés:
# A program az Szerencsejáték Zrt. publikus API-ját használja.
#

URL = "https://bet.szerencsejatek.hu/cmsfiles/skandinav.csv"

# CSV letöltése
response = requests.get(URL)

if response.status_code != 200:
    print("Nem sikerült letölteni az adatokat.")
    exit()

# Sorok feldolgozása
lines = response.text.strip().split("\n")

# Fejléc eltávolítása
header = lines[0]
data_lines = lines[1:]

draws = []

for line in data_lines:
    parts = line.split(";")

    try:
        year = parts[0]
        week = parts[1]

        # A 14 kihúzott szám
        numbers = list(map(int, parts[11:25]))

        draws.append({
            "year": int(year),
            "week": int(week),
            "numbers": numbers
        })

    except:
        continue

# Legfrissebb húzás
latest_draw = draws[-1]
latest_numbers = set(latest_draw["numbers"])

print("Utolsó húzás számai:")
print(sorted(latest_numbers))
print()

# Utolsó előfordulás keresése minden számra
last_seen = {}

# Visszafelé haladunk az időben
for index in range(len(draws)-1, -1, -1):
    draw = draws[index]

    for number in draw["numbers"]:
        if number not in last_seen:
            last_seen[number] = len(draws) - index

# Skandináv lottó számok: 1-35
all_numbers = set(range(1, 36))

# Kizárjuk az utolsó húzás számait
remaining_numbers = all_numbers - latest_numbers

# Rangsorolás:
# minél nagyobb a "len(draws)-index",
# annál régebben volt húzva
ranking = []

for number in remaining_numbers:
    age = last_seen.get(number, 999999)
    ranking.append((number, age))

# Régebben húzott számok előre
ranking.sort(key=lambda x: x[1], reverse=True)

# 7 szám kiválasztása
selected = ranking[:7]

selected_numbers = sorted([x[0] for x in selected])

print("Ajánlott 7 szám:")
print(selected_numbers)

print("\nRészletek:")
for number, age in selected:
    print(f"{number} -> {age} húzás óta nem szerepelt")

A program működéséhez szükséges csomag:

Bash pip install requests