data_generator.py

import random
import string
import json
import uuid
import math
from fractions import Fraction
from collections import Counter
import calendar
from datetime import datetime, timedelta

# ─────────────────────────────────────────────
# YARDIMCI FONKSİYONLAR
# ─────────────────────────────────────────────

def get_random_id():
    return ''.join(random.choices(string.ascii_lowercase + string.digits, k=10))

def asal_mi(n):
    if n < 2:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

def asal_carpanlar(n):
    """n sayısının asal çarpanlarını liste olarak döndürür."""
    carpanlar = []
    d = 2
    while d * d <= n:
        while n % d == 0:
            carpanlar.append(d)
            n //= d
        d += 1
    if n > 1:
        carpanlar.append(n)
    return carpanlar

def ebob(a, b):
    return math.gcd(a, b)

def ekok(a, b):
    return a * b // math.gcd(a, b)

def sayi_yaz(n):
    """Negatif sayıları parantezli gösterir."""
    if n < 0:
        return f"({n})"
    return str(n)


# ──────────────────────────────────────────────
# ZORLUK SEVİYESİ YARDIMCISI
# easy   : 1-2 basamaklı   (ağırlık %25)
# medium : 2-4 basamaklı   (ağırlık %50)
# hard   : 4-7 basamaklı   (ağırlık %25)
# ──────────────────────────────────────────────
def seviye():
    return random.choices(["easy", "medium", "hard"], weights=[25, 50, 25], k=1)[0]

def aralik(s, easy=(2,9), medium=(10,999), hard=(1000,999999)):
    return {"easy": easy, "medium": medium, "hard": hard}[s]


# ══════════════════════════════════════════════
# 1. TOPLAMA
# ══════════════════════════════════════════════
def gen_addition():
    s = seviye()
    lo, hi = aralik(s, easy=(2,9), medium=(10,9999), hard=(10000,999999))
    a = random.randint(lo, hi)
    b = random.randint(lo, hi)
    result = a + b

    if s == "easy":
        cozum = (
            f"{a} + {b} işlemini parmak sayarak ya da sayı doğrusunda ilerleyerek bulabiliriz:\n\n"
            f"{a}'dan {b} adım ileri: {a} → {result}\n\n"
            f"$\\boxed{{{result}}}$"
        )
    elif s == "medium":
        # basamak basamak açıklama
        basamaklar = max(len(str(a)), len(str(b)))
        cozum = (
            f"Sayıları basamaklarına ayırarak toplayalım:\n\n"
            f"  {a:>{basamaklar+2}}\n"
            f"+ {b:>{basamaklar+2}}\n"
            f"{'─'*(basamaklar+4)}\n"
            f"  {result:>{basamaklar+2}}\n\n"
            f"Elde varsa bir üst basamağa taşınır.\n\n"
            f"$\\boxed{{{result}}}$"
        )
    else:
        cozum = (
            f"Büyük sayıları toplarken her basamağı sağdan sola işleriz:\n\n"
            f"  {a}\n"
            f"+ {b}\n"
            f"{'─'*max(len(str(a)),len(str(b))+2)}\n"
            f"  {result}\n\n"
            f"$\\boxed{{{result}}}$"
        )
    soru = f"{a} + {b} işleminin sonucu kaçtır?"
    return soru, cozum, "Toplama", s


# ══════════════════════════════════════════════
# 2. ÇIKARMA
# ══════════════════════════════════════════════
def gen_subtraction():
    s = seviye()
    lo, hi = aralik(s, easy=(2,9), medium=(10,9999), hard=(10000,999999))
    a = random.randint(lo, hi)
    b = random.randint(lo // 2 if lo > 1 else 1, a)
    if b > a: a, b = b, a
    result = a - b

    soru = f"{a} - {b} işleminin sonucu kaçtır?"
    if s == "easy":
        cozum = (
            f"{a}'dan {b} adım geri sayalım:\n\n"
            f"{a} - {b} = {result}\n\n"
            f"$\\boxed{{{result}}}$"
        )
    else:
        w = max(len(str(a)), len(str(b))) + 2
        cozum = (
            f"Çıkarma işlemini sağdan sola basamak basamak yaparız:\n\n"
            f"  {a:>{w}}\n"
            f"- {b:>{w}}\n"
            f"{'─'*(w+2)}\n"
            f"  {result:>{w}}\n\n"
            f"$\\boxed{{{result}}}$"
        )
    return soru, cozum, "Çıkarma", s


# ══════════════════════════════════════════════
# 3. ÇARPMA
# ══════════════════════════════════════════════
def gen_multiplication():
    s = seviye()
    if s == "easy":
        a = random.randint(2, 9)
        b = random.randint(2, 9)
    elif s == "medium":
        a = random.randint(11, 99)
        b = random.randint(11, 99)
    else:
        a = random.randint(100, 9999)
        b = random.randint(100, 9999)

    result = a * b
    soru = f"{a} $\\times$ {b} işleminin sonucu kaçtır?"

    if s == "easy":
        cozum = (
            f"Çarpma tablosundan: {a} $\\times$ {b} = {result}\n\n"
            f"Ya da {a} sayısını {b} kez toplayalım:\n"
            f"  {' + '.join([str(a)]*b)} = {result}\n\n"
            f"$\\boxed{{{result}}}$"
        )
    else:
        b_on = (b // 10) * 10
        b_bir = b % 10
        if b_bir == 0:
            b_bir = 1; b_on = b - 1; b = b_on + b_bir  # edge case fix
            result = a * b
        step_bir = a * b_bir
        step_on  = a * b_on
        cozum = (
            f"{b} = {b_on} + {b_bir} olarak ayırarak çarpalım:\n\n"
            f"**1. Adım:** {a} $\\times$ {b_bir} = {step_bir}\n\n"
            f"**2. Adım:** {a} $\\times$ {b_on} = {step_on}\n\n"
            f"**3. Adım:** {step_bir} + {step_on} = {result}\n\n"
            f"$\\boxed{{{result}}}$"
        )
    return soru, cozum, "Çarpma", s


# ══════════════════════════════════════════════
# 4. BÖLME
# ══════════════════════════════════════════════
def gen_division():
    s = seviye()
    if s == "easy":
        b = random.randint(2, 9)
        q = random.randint(2, 9)
    elif s == "medium":
        b = random.randint(2, 99)
        q = random.randint(10, 999)
    else:
        b = random.randint(2, 999)
        q = random.randint(1000, 99999)
    a = b * q

    soru = f"{a} $\\div$ {b} işleminin sonucu kaçtır?"
    cozum = (
        f"**Formül:** Bölünen = Bölen × Bölüm\n\n"
        f"  {b} × ? = {a}\n\n"
        f"  ? = {a} ÷ {b} = {q}\n\n"
        f"**Doğrulama:** {b} × {q} = {a}  ✓\n\n"
        f"$\\boxed{{{q}}}$"
    )
    return soru, cozum, "Bölme", s


# ══════════════════════════════════════════════
# 5. KALÂNLI BÖLME
# ══════════════════════════════════════════════
def gen_division_remainder():
    s = seviye()
    if s == "easy":
        b = random.randint(2, 9); q = random.randint(1, 9)
    elif s == "medium":
        b = random.randint(2, 99); q = random.randint(10, 999)
    else:
        b = random.randint(2, 999); q = random.randint(1000, 99999)
    r = random.randint(1, b - 1)
    a = b * q + r

    soru = f"{a} sayısı {b}'ye bölündüğünde kalan kaçtır?"
    cozum = (
        f"**Formül:** Bölünen = Bölen × Bölüm + Kalan\n\n"
        f"1. {b}'nin {a}'a en yakın katını bul:\n"
        f"   {b} × {q} = {b*q}   ({b*q} ≤ {a})\n\n"
        f"2. Kalanı hesapla:\n"
        f"   {a} - {b*q} = {r}\n\n"
        f"Doğrulama: {b} × {q} + {r} = {b*q} + {r} = {a}  ✓\n\n"
        f"$\\boxed{{{r}}}$"
    )
    return soru, cozum, "Kalanlı Bölme", s


# ══════════════════════════════════════════════
# 6. KESİR TOPLAMA
# ══════════════════════════════════════════════
def gen_fraction_addition():
    s = "medium"
    b = random.randint(2, 9)
    d = random.randint(2, 9)
    while d == b:
        d = random.randint(2, 9)
    a = random.randint(1, b - 1)
    c = random.randint(1, d - 1)
    pay = a * d + c * b
    payda = b * d
    g = math.gcd(pay, payda)
    sp, sd = pay // g, payda // g

    soru = f"$\\frac{{{a}}}{{{b}}} + \\frac{{{c}}}{{{d}}}$ işleminin sonucu kaçtır?"
    cozum = (
        f"Kesirlerde toplama yapabilmek için paydaların eşit olması gerekir.\n\n"
        f"Mevcut paydalar: {b} ve {d}\n\n"
        f"**1. Adım – Paydaları eşitle (çapraz genişletme):**\n"
        f"  $\\frac{{{a} \\times {d}}}{{{b} \\times {d}}} + \\frac{{{c} \\times {b}}}{{{d} \\times {b}}}$\n\n"
        f"  $= \\frac{{{a*d}}}{{{b*d}}} + \\frac{{{c*b}}}{{{d*b}}}$\n\n"
        f"**2. Adım – Paydalar eşit olduğundan payları topla:**\n"
        f"  $\\frac{{{a*d} + {c*b}}}{{{b*d}}} = \\frac{{{pay}}}{{{payda}}}$\n\n"
    )
    if g > 1:
        cozum += (
            f"**3. Adım – Sadeleştir (EBOB = {g}):**\n"
            f"  $\\frac{{{pay} \\div {g}}}{{{payda} \\div {g}}} = \\frac{{{sp}}}{{{sd}}}$\n\n"
            f"$\\boxed{{\\frac{{{sp}}}{{{sd}}}}}$"
        )
    else:
        cozum += f"Kesir zaten sade biçimde.\n\n$\\boxed{{\\frac{{{pay}}}{{{payda}}}}}$"
    return soru, cozum, "Kesir Toplama", s


# ══════════════════════════════════════════════
# 7. KESİR ÇIKARMA
# ══════════════════════════════════════════════
def gen_fraction_subtraction():
    s = "medium"
    b = random.randint(2, 9)
    d = random.randint(2, 9)
    while d == b:
        d = random.randint(2, 9)
    a = random.randint(1, b - 1)
    c = random.randint(1, d - 1)
    pay = a * d - c * b
    payda = b * d
    # Sonuç pozitif olsun
    if pay <= 0:
        a, c = c, a
        b, d = d, b
        pay = a * d - c * b
        payda = b * d
    g = math.gcd(abs(pay), payda)
    sp, sd = pay // g, payda // g

    soru = f"$\\frac{{{a}}}{{{b}}} - \\frac{{{c}}}{{{d}}}$ işleminin sonucu kaçtır?"
    cozum = (
        f"Kesirlerde çıkarma işleminde de önce paydaları eşitlememiz gerekir.\n\n"
        f"Mevcut paydalar: {b} ve {d}\n\n"
        f"**1. Adım – Paydaları eşitle:**\n"
        f"  $\\frac{{{a} \\times {d}}}{{{b} \\times {d}}} - \\frac{{{c} \\times {b}}}{{{d} \\times {b}}}$\n\n"
        f"  $= \\frac{{{a*d}}}{{{b*d}}} - \\frac{{{c*b}}}{{{d*b}}}$\n\n"
        f"**2. Adım – Payları çıkar:**\n"
        f"  $\\frac{{{a*d} - {c*b}}}{{{b*d}}} = \\frac{{{pay}}}{{{payda}}}$\n\n"
    )
    if g > 1:
        cozum += (
            f"**3. Adım – Sadeleştir (EBOB = {g}):**\n"
            f"  $\\frac{{{sp}}}{{{sd}}}$\n\n"
            f"$\\boxed{{\\frac{{{sp}}}{{{sd}}}}}$"
        )
    else:
        cozum += f"$\\boxed{{\\frac{{{pay}}}{{{payda}}}}}$"
    return soru, cozum, "Kesir Çıkarma", s


# ══════════════════════════════════════════════
# 8. KESİR ÇARPMASI
# ══════════════════════════════════════════════
def gen_fraction_multiplication():
    s = "medium"
    a = random.randint(1, 7)
    b = random.randint(2, 9)
    c = random.randint(1, 7)
    d = random.randint(2, 9)
    pay = a * c
    payda = b * d
    g = math.gcd(pay, payda)
    sp, sd = pay // g, payda // g

    soru = f"$\\frac{{{a}}}{{{b}}} \\times \\frac{{{c}}}{{{d}}}$ işleminin sonucu kaçtır?"
    cozum = (
        f"Kesirlerde çarpma işlemi oldukça basittir: "
        f"**pay payda ile, payda payda ile çarpılır.**\n\n"
        f"$\\frac{{{a}}}{{{b}}} \\times \\frac{{{c}}}{{{d}}} = \\frac{{{a} \\times {c}}}{{{b} \\times {d}}}$\n\n"
        f"**1. Adım – Payları çarp:**\n"
        f"  {a} × {c} = {pay}\n\n"
        f"**2. Adım – Paydaları çarp:**\n"
        f"  {b} × {d} = {payda}\n\n"
        f"**3. Adım – Kesri oluştur:**\n"
        f"  $\\frac{{{pay}}}{{{payda}}}$\n\n"
    )
    if g > 1:
        cozum += (
            f"**4. Adım – Sadeleştir (EBOB = {g}):**\n"
            f"  $\\frac{{{pay} \\div {g}}}{{{payda} \\div {g}}} = \\frac{{{sp}}}{{{sd}}}$\n\n"
            f"$\\boxed{{\\frac{{{sp}}}{{{sd}}}}}$"
        )
    else:
        cozum += f"Kesir sade biçimde.\n\n$\\boxed{{\\frac{{{pay}}}{{{payda}}}}}$"
    return soru, cozum, "Kesir Çarpması", s


# ══════════════════════════════════════════════
# 9. KESİR BÖLME
# ══════════════════════════════════════════════
def gen_fraction_division():
    s = "medium"
    a = random.randint(1, 7)
    b = random.randint(2, 9)
    c = random.randint(1, 7)
    d = random.randint(2, 9)
    # a/b ÷ c/d = a*d / b*c
    pay = a * d
    payda = b * c
    g = math.gcd(pay, payda)
    sp, sd = pay // g, payda // g

    soru = f"$\\frac{{{a}}}{{{b}}} \\div \\frac{{{c}}}{{{d}}}$ işleminin sonucu kaçtır?"
    cozum = (
        f"Kesirlerde bölme işlemi, **bölen kesri ters çevirip çarpma**ya dönüştürmek demektir.\n\n"
        f"Kural: $\\frac{{a}}{{b}} \\div \\frac{{c}}{{d}} = \\frac{{a}}{{b}} \\times \\frac{{d}}{{c}}$\n\n"
        f"**1. Adım – Bölen kesri tersine çevir:**\n"
        f"  $\\frac{{{c}}}{{{d}}}$ → $\\frac{{{d}}}{{{c}}}$\n\n"
        f"**2. Adım – Çarpma işlemine dönüştür:**\n"
        f"  $\\frac{{{a}}}{{{b}}} \\times \\frac{{{d}}}{{{c}}} = \\frac{{{a} \\times {d}}}{{{b} \\times {c}}} = \\frac{{{pay}}}{{{payda}}}$\n\n"
    )
    if g > 1:
        cozum += (
            f"**3. Adım – Sadeleştir (EBOB = {g}):**\n"
            f"  $\\frac{{{pay} \\div {g}}}{{{payda} \\div {g}}} = \\frac{{{sp}}}{{{sd}}}$\n\n"
            f"$\\boxed{{\\frac{{{sp}}}{{{sd}}}}}$"
        )
    else:
        cozum += f"$\\boxed{{\\frac{{{pay}}}{{{payda}}}}}$"
    return soru, cozum, "Kesir Bölme", s


# ══════════════════════════════════════════════
# 10. ÜSLÜ SAYILAR
# ══════════════════════════════════════════════
def gen_exponents():
    s = seviye()
    if s == "easy":
        taban = random.randint(2, 5); us = random.randint(2, 3)
    elif s == "medium":
        taban = random.randint(4, 15); us = random.randint(2, 4)
    else:
        taban = random.randint(10, 30); us = random.randint(3, 5)
    result = taban ** us
    result = taban ** us
    adimlar = []
    carpim = 1
    for i in range(1, us + 1):
        carpim *= taban
        adimlar.append(f"  {i}. çarpım: {' × '.join([str(taban)]*i)} = {carpim}")

    soru = f"${taban}^{{{us}}}$ işleminin sonucu kaçtır?"
    cozum = (
        f"Üslü sayılarda **taban**, kendisiyle **üs** kadar çarpılır.\n\n"
        f"${taban}^{{{us}}}$ demek, {taban} sayısının {us} kez kendisiyle çarpılması demektir:\n\n"
        f"${taban}^{{{us}}} = " + " \\times ".join([str(taban)] * us) + f" = {result}$\n\n"
        f"Adım adım hesaplayalım:\n"
        + "\n".join(adimlar) + "\n\n"
        f"$\\boxed{{{result}}}$"
    )
    return soru, cozum, "Üslü Sayılar", s


# ══════════════════════════════════════════════
# 11. KAREKÖK
# ══════════════════════════════════════════════
def gen_square_root():
    s = seviye()
    if s == "easy":   r = random.randint(2, 9)
    elif s == "medium": r = random.randint(10, 50)
    else:             r = random.randint(50, 200)
    n = r * r
    n = r * r
    soru = f"$\\sqrt{{{n}}}$ işleminin sonucu kaçtır?"
    cozum = (
        f"Karekök ($\\sqrt{{}}$), hangi sayının kendisiyle çarpılırsa verilen sayıyı "
        f"vereceğini sorar.\n\n"
        f"$\\sqrt{{{n}}} = ?$ → ? $\\times$ ? = {n}\n\n"
        f"Adım adım tam kare kontrolü:\n"
    )
    for k in range(1, r + 1):
        if k == r:
            cozum += f"  {k} $\\times$ {k} = {k*k}  ✓ Bulundu!\n"
        else:
            cozum += f"  {k} $\\times$ {k} = {k*k}\n"
    cozum += (
        f"\n$\\sqrt{{{n}}} = {r}$\n\n"
        f"**Doğrulama:** ${r}^2 = {r} \\times {r} = {n}$  ✓\n\n"
        f"$\\boxed{{{r}}}$"
    )
    return soru, cozum, "Karekök", s


# ══════════════════════════════════════════════
# 12. BİRİNCİ DERECE DENKLEM (ax + b = c)
# ══════════════════════════════════════════════
def gen_linear_equation():
    s = seviye()
    if s == "easy":
        x = random.randint(1, 9); a = random.randint(1, 5); b = random.randint(1, 10)
    elif s == "medium":
        x = random.randint(10, 999); a = random.randint(2, 20); b = random.randint(10, 500)
    else:
        x = random.randint(1000, 99999); a = random.randint(2, 50); b = random.randint(100, 50000)
    c = a * x + b
    soru = f"${a}x + {b} = {c}$ denkleminde $x$ kaçtır?"
    cozum = (
        f"**1. Adım – Sabit terimi karşıya taşı:**\n"
        f"  ${a}x = {c} - {b} = {c - b}$\n\n"
        f"**2. Adım – {a}'e böl:**\n"
        f"  $x = \\dfrac{{{c - b}}}{{{a}}} = {x}$\n\n"
        f"**Doğrulama:** ${a} \\times {x} + {b} = {a*x} + {b} = {c}$  ✓\n\n"
        f"$\\boxed{{{x}}}$"
    )
    return soru, cozum, "Birinci Derece Denklem (ax + b = c)", s


# ══════════════════════════════════════════════
# 13. BİRİNCİ DERECE DENKLEM (ax - b = c)
# ══════════════════════════════════════════════
def gen_linear_equation_neg():
    s = seviye()
    if s == "easy":
        x = random.randint(2, 9); a = random.randint(2, 5); b = random.randint(1, 9)
    elif s == "medium":
        x = random.randint(10, 999); a = random.randint(2, 20); b = random.randint(5, 200)
    else:
        x = random.randint(1000, 99999); a = random.randint(2, 50); b = random.randint(100, 10000)
    c = a * x - b
    if c <= 0:
        x += 10; c = a * x - b
    soru = f"${a}x - {b} = {c}$ denkleminde $x$ kaçtır?"
    cozum = (
        f"**1. Adım – {b}'yi karşıya taşı:**\n"
        f"  ${a}x = {c} + {b} = {c + b}$\n\n"
        f"**2. Adım – {a}'e böl:**\n"
        f"  $x = \\dfrac{{{c + b}}}{{{a}}} = {x}$\n\n"
        f"**Doğrulama:** ${a} \\times {x} - {b} = {a*x} - {b} = {c}$  ✓\n\n"
        f"$\\boxed{{{x}}}$"
    )
    return soru, cozum, "Birinci Derece Denklem (ax - b = c)", s


# ══════════════════════════════════════════════
# 14. İKİNCİ DERECE DENKLEM (x² = n, tam kare)
# ══════════════════════════════════════════════
def gen_quadratic_simple():
    s = "medium"
    r = random.randint(2, 12)
    n = r * r
    soru = f"$x^2 = {n}$ denkleminin çözüm kümesi nedir?"
    cozum = (
        f"$x^2 = {n}$ denklemini çözmek için her iki tarafın karekökünü alırız.\n\n"
        f"$x^2 = {n}$\n\n"
        f"$x = \\pm\\sqrt{{{n}}}$\n\n"
        f"$\\sqrt{{{n}}} = {r}$ olduğundan:\n\n"
        f"$x = +{r}$ veya $x = -{r}$\n\n"
        f"**Doğrulama:**\n"
        f"  $({r})^2 = {n}$  ✓\n"
        f"  $(-{r})^2 = {n}$  ✓\n\n"
        f"Çözüm kümesi: $K = \\{{{{{-r}, {r}}}\\}}$\n\n"
        f"$\\boxed{{x = \\pm{r}}}$"
    )
    return soru, cozum, "İkinci Derece Denklem (x² = n)", s


# ══════════════════════════════════════════════
# 15. İKİ BİLİNMEYENLİ DENKLEM SİSTEMİ
# ══════════════════════════════════════════════
def gen_system_of_equations():
    s = "hard"
    # Çözümü önceden belirle
    x = random.randint(1, 10)
    y = random.randint(1, 10)
    a1 = random.randint(1, 5)
    b1 = random.randint(1, 5)
    c1 = a1 * x + b1 * y

    a2 = random.randint(1, 5)
    while a2 == a1:
        a2 = random.randint(1, 5)
    b2 = random.randint(1, 5)
    while b2 == b1:
        b2 = random.randint(1, 5)
    c2 = a2 * x + b2 * y

    soru = (
        f"Aşağıdaki denklem sistemini çözünüz:\n\n"
        f"$\\begin{{cases}} {a1}x + {b1}y = {c1} \\\\ {a2}x + {b2}y = {c2} \\end{{cases}}$"
    )

    # Yerine koyma yöntemi: 1. denklemden x bul
    # a1*x = c1 - b1*y → x = (c1 - b1*y) / a1
    # 2. denkleme koy: a2*(c1 - b1*y)/a1 + b2*y = c2
    # (a2*c1 - a2*b1*y)/a1 + b2*y = c2
    # a2*c1 - a2*b1*y + a1*b2*y = a1*c2
    # (a1*b2 - a2*b1)*y = a1*c2 - a2*c1
    det = a1 * b2 - a2 * b1
    rhs_y = a1 * c2 - a2 * c1

    cozum = (
        f"**Çıkarma (eliminasyon) yöntemi** ile çözeceğiz.\n\n"
        f"Verilen denklemler:\n"
        f"  (1): ${a1}x + {b1}y = {c1}$\n"
        f"  (2): ${a2}x + {b2}y = {c2}$\n\n"
        f"**1. Adım – x'i yok etmek için (1)'i {a2} ile, (2)'yi {a1} ile çarpalım:**\n"
        f"  {a2} × (1): ${a1*a2}x + {b1*a2}y = {c1*a2}$\n"
        f"  {a1} × (2): ${a2*a1}x + {b2*a1}y = {c2*a1}$\n\n"
        f"**2. Adım – Çarpılmış denklemleri çıkar (x yokolur):**\n"
        f"  ${b1*a2 - b2*a1}y = {c1*a2 - c2*a1}$\n\n"
    )
    if det != 0:
        cozum += (
            f"  $y = \\dfrac{{{c1*a2 - c2*a1}}}{{{b1*a2 - b2*a1}}} = {y}$\n\n"
            f"**3. Adım – y = {y} değerini (1). denkleme koy:**\n"
            f"  ${a1}x + {b1} \\times {y} = {c1}$\n"
            f"  ${a1}x + {b1*y} = {c1}$\n"
            f"  ${a1}x = {c1 - b1*y}$\n"
            f"  $x = {x}$\n\n"
            f"**Doğrulama:**\n"
            f"  (1): ${a1} \\times {x} + {b1} \\times {y} = {a1*x} + {b1*y} = {c1}$  ✓\n"
            f"  (2): ${a2} \\times {x} + {b2} \\times {y} = {a2*x} + {b2*y} = {c2}$  ✓\n\n"
            f"$\\boxed{{x = {x}, \\quad y = {y}}}$"
        )
    else:
        cozum += "Denklem sisteminin özgün çözümü yoktur."
    return soru, cozum, "İki Bilinmeyenli Denklem Sistemi", s


# ══════════════════════════════════════════════
# 16. EŞİTSİZLİK (ax + b < c veya >)
# ══════════════════════════════════════════════
def gen_inequality():
    s = "medium"
    a = random.randint(2, 8)
    b = random.randint(3, 20)
    x_sinir = random.randint(3, 15)
    c = a * x_sinir + b
    isaret = random.choice(["<", ">", "\\leq", "\\geq"])
    yön = "sola" if isaret in ["<", "\\leq"] else "sağa"
    sembol = {"<": "<", ">": ">", "\\leq": "≤", "\\geq": "≥"}[isaret]

    soru = f"${a}x + {b} {isaret} {c}$ eşitsizliğini sağlayan $x$ değerleri nelerdir?"
    cozum = (
        f"Eşitsizlik çözümünde denklem gibi davranırız; ancak her iki tarafı **negatif** "
        f"bir sayıyla çarpar veya bölersek eşitsizlik işareti ters döner. Bu problemde böyle bir durum yok.\n\n"
        f"**1. Adım – {b} sabitini karşıya taşı:**\n"
        f"  ${a}x {isaret} {c} - {b}$\n"
        f"  ${a}x {isaret} {c - b}$\n\n"
        f"**2. Adım – {a}'ya böl (pozitif, işaret değişmez):**\n"
        f"  $x {isaret} \\dfrac{{{c - b}}}{{{a}}}$\n"
        f"  $x {isaret} {(c - b)//a if (c-b)%a==0 else Fraction(c-b,a)}$\n\n"
        f"$\\boxed{{x {isaret} {(c-b)//a if (c-b)%a==0 else Fraction(c-b,a)}}}$"
    )
    return soru, cozum, "Eşitsizlik", s


# ══════════════════════════════════════════════
# 17. MUTLAK DEĞER
# ══════════════════════════════════════════════
def gen_absolute_value():
    s = seviye()
    if s == "easy":
        choices = list(range(-9, 0)) + list(range(1, 10))
    elif s == "medium":
        choices = list(range(-999, -9)) + list(range(10, 1000))
    else:
        choices = list(range(-99999, -999)) + list(range(1000, 100000))
    a = random.choice(choices)
    b = random.choice(choices)
    result = abs(a) + abs(b)

    soru = f"$|{a}| + |{b}|$ işleminin sonucu kaçtır?"
    cozum = (
        f"Mutlak değer ($| \\cdot |$), bir sayının sayı doğrusu üzerinde sıfırdan "
        f"olan **uzaklığını** verir. Sonuç her zaman negatif olmayan bir sayıdır.\n\n"
        f"Kural:\n"
        f"  $|x| = x$ eğer $x \\geq 0$\n"
        f"  $|x| = -x$ eğer $x < 0$\n\n"
        f"**1. Adım – $|{a}|$ hesapla:**\n"
        f"  {a} {'$\\geq 0$ olduğundan' if a >= 0 else '$< 0$ olduğundan'} "
        f"$|{a}| = {abs(a)}$\n\n"
        f"**2. Adım – $|{b}|$ hesapla:**\n"
        f"  {b} {'$\\geq 0$ olduğundan' if b >= 0 else '$< 0$ olduğundan'} "
        f"$|{b}| = {abs(b)}$\n\n"
        f"**3. Adım – Topla:**\n"
        f"  ${abs(a)} + {abs(b)} = {result}$\n\n"
        f"$\\boxed{{{result}}}$"
    )
    return soru, cozum, "Mutlak Değer", s


# ══════════════════════════════════════════════
# 18. YÜZDE HESAPLAMA
# ══════════════════════════════════════════════
def gen_percentage():
    p = random.choice([10, 15, 20, 25, 30, 40, 50, 60, 75, 80])
    s = seviye()
    if s == "easy":   base = random.randint(1, 10) * 10
    elif s == "medium": base = random.randint(10, 200) * 10
    else:             base = random.randint(200, 5000) * 10
    result = int(base * p / 100)

    soru = f"{base} sayısının %{p}'si kaçtır?"
    cozum = (
        f"Bir sayının yüzdesini bulmak için: Sayı $\\times \\frac{{\\text{{Yüzde}}}}{{100}}$\n\n"
        f"**1. Adım – İşlemi yaz:**\n"
        f"  ${base} \\times \\frac{{{p}}}{{100}}$\n\n"
        f"**2. Adım – Payı hesapla:**\n"
        f"  ${base} \\times {p} = {base * p}$\n\n"
        f"**3. Adım – 100'e böl:**\n"
        f"  ${base * p} \\div 100 = {result}$\n\n"
        f"Yani {base} sayısının %{p}'si **{result}**'dır.\n\n"
        f"$\\boxed{{{result}}}$"
    )
    return soru, cozum, "Yüzde Hesaplama", s


# ══════════════════════════════════════════════
# 19. YÜZDE ARTIŞ / AZALIŞ
# ══════════════════════════════════════════════
def gen_percentage_change():
    s = "medium"
    base = random.randint(2, 50) * 10
    p = random.choice([10, 15, 20, 25, 30, 50])
    artis = random.choice([True, False])
    degisim = int(base * p / 100)
    result = base + degisim if artis else base - degisim
    kelime = "artırılıyor" if artis else "azaltılıyor"
    islem = "+" if artis else "-"

    soru = f"{base} sayısı %{p} {kelime}. Yeni değer kaçtır?"
    cozum = (
        f"{'Artışta' if artis else 'Azalışta'} önce {p}% miktarını buluruz, "
        f"sonra orijinal sayıya {'ekleriz' if artis else 'çıkarırız'}.\n\n"
        f"**1. Adım – {p}% miktarını bul:**\n"
        f"  ${base} \\times \\frac{{{p}}}{{100}} = {degisim}$\n\n"
        f"**2. Adım – Yeni değeri hesapla:**\n"
        f"  ${base} {islem} {degisim} = {result}$\n\n"
        f"Alternatif yöntem (çarpan yöntemi):\n"
        f"  ${base} \\times {1 + p/100 if artis else 1 - p/100} = {result}$\n\n"
        f"$\\boxed{{{result}}}$"
    )
    return soru, cozum, "Yüzde Artış / Azalış", s


# ══════════════════════════════════════════════
# 20. KÂR / ZARAR
# ══════════════════════════════════════════════
def gen_profit_loss():
    s = "medium"
    alis = random.randint(10, 200) * 5
    oran = random.choice([10, 20, 25, 30, 40, 50])
    kar_mi = random.choice([True, False])
    fark = int(alis * oran / 100)
    satis = alis + fark if kar_mi else alis - fark
    durum = "kâr" if kar_mi else "zarar"

    soru = (
        f"Bir ürün {alis} TL'ye alınıp {satis} TL'ye satılıyor. "
        f"Elde edilen {durum} yüzdesi kaçtır?"
    )
    cozum = (
        f"Kâr veya zarar yüzdesi hesabında alış fiyatı baz alınır.\n\n"
        f"**Formül:** $\\text{{Kâr/Zarar \\%}} = \\frac{{\\text{{Kâr/Zarar}}}}{{\\text{{Alış Fiyatı}}}} \\times 100$\n\n"
        f"**1. Adım – {'Kâr' if kar_mi else 'Zarar'} miktarını bul:**\n"
        f"  {satis} - {alis} = {fark} TL\n\n"
        f"**2. Adım – Yüzdeyi hesapla:**\n"
        f"  $\\frac{{{fark}}}{{{alis}}} \\times 100 = {oran}\\%$\n\n"
        f"Yani bu işlemde %{oran} **{durum}** edildi.\n\n"
        f"$\\boxed{{\\%{oran} {durum}}}$"
    )
    return soru, cozum, "Kâr / Zarar", s


# ══════════════════════════════════════════════
# 21. HIZ / ZAMAN / YOL
# ══════════════════════════════════════════════
def gen_speed_time_distance():
    s = "medium"
    tip = random.choice(["yol", "hız", "süre"])
    hiz = random.randint(40, 120)
    sure = random.randint(1, 6)
    yol = hiz * sure

    if tip == "yol":
        soru = f"Saatte {hiz} km hızla giden bir araç {sure} saatte kaç km yol alır?"
        cozum = (
            f"**Temel formül:** Yol = Hız $\\times$ Süre\n\n"
            f"Verilen bilgiler:\n"
            f"  • Hız = {hiz} km/sa\n"
            f"  • Süre = {sure} sa\n\n"
            f"**Hesaplama:**\n"
            f"  Yol = {hiz} km/sa $\\times$ {sure} sa = {yol} km\n\n"
            f"$\\boxed{{{yol} \\text{{ km}}}}$"
        )
    elif tip == "hız":
        soru = f"Bir araç {yol} km'yi {sure} saatte katediyor. Bu aracın hızı kaç km/sa'dir?"
        cozum = (
            f"**Temel formül:** Hız = Yol $\\div$ Süre\n\n"
            f"Verilen bilgiler:\n"
            f"  • Yol = {yol} km\n"
            f"  • Süre = {sure} sa\n\n"
            f"**Hesaplama:**\n"
            f"  Hız = {yol} $\\div$ {sure} = {hiz} km/sa\n\n"
            f"$\\boxed{{{hiz} \\text{{ km/sa}}}}$"
        )
    else:
        soru = f"Saatte {hiz} km giden bir araç {yol} km'yi kaç saatte alır?"
        cozum = (
            f"**Temel formül:** Süre = Yol $\\div$ Hız\n\n"
            f"Verilen bilgiler:\n"
            f"  • Yol = {yol} km\n"
            f"  • Hız = {hiz} km/sa\n\n"
            f"**Hesaplama:**\n"
            f"  Süre = {yol} $\\div$ {hiz} = {sure} sa\n\n"
            f"$\\boxed{{{sure} \\text{{ sa}}}}$"
        )
    return soru, cozum, "Hız / Zaman / Yol", s


# ══════════════════════════════════════════════
# 22. İŞ PROBLEMLERİ
# ══════════════════════════════════════════════
def gen_work_problem():
    s = "hard"
    a = random.randint(3, 12)  # A kaç günde bitirir
    b = random.randint(3, 12)
    while b == a:
        b = random.randint(3, 12)
    # Birlikte bitirme süresi = a*b / (a+b) gün
    from fractions import Fraction
    sure = Fraction(a * b, a + b)

    soru = (
        f"A bir işi {a} günde, B aynı işi {b} günde yapabiliyor. "
        f"Birlikte çalışırlarsa işi kaç günde bitirirler?"
    )
    cozum = (
        f"Bu tür problemlerde **günlük iş hızlarını** kullanırız.\n\n"
        f"**1. Adım – Günlük iş hızlarını bul:**\n"
        f"  A'nın günlük hızı = $\\frac{{1}}{{{a}}}$ (işin $\\frac{{1}}{{{a}}}$'si/gün)\n"
        f"  B'nin günlük hızı = $\\frac{{1}}{{{b}}}$ (işin $\\frac{{1}}{{{b}}}$'si/gün)\n\n"
        f"**2. Adım – Birlikte günlük hızlarını topla:**\n"
        f"  $\\frac{{1}}{{{a}}} + \\frac{{1}}{{{b}}} = \\frac{{{b} + {a}}}{{{a*b}}} = \\frac{{{a+b}}}{{{a*b}}}$\n\n"
        f"**3. Adım – Birlikte çalışma süresini bul (1 iş ÷ hız):**\n"
        f"  Süre = $\\frac{{1}}{{\\frac{{{a+b}}}{{{a*b}}}}} = \\frac{{{a*b}}}{{{a+b}}}$"
        + (f" = ${sure}$ gün\n\n" if sure.denominator > 1 else f" = {int(sure)} gün\n\n") +
        f"$\\boxed{{\\frac{{{a*b}}}{{{a+b}}} \\text{{ gün}}}}$"
    )
    return soru, cozum, "İş Problemleri", s


# ══════════════════════════════════════════════
# 23. ARİTMETİK DİZİ
# ══════════════════════════════════════════════
def gen_arithmetic_sequence():
    s = "medium"
    a1 = random.randint(5, 30)
    d = random.randint(3, 15)
    n = random.randint(5, 10)
    an = a1 + (n - 1) * d
    tip = random.choice(["terim", "toplam"])

    if tip == "terim":
        soru = f"İlk terimi {a1}, ortak farkı {d} olan aritmetik dizinin {n}. terimi kaçtır?"
        cozum = (
            f"Aritmetik dizide her terim bir öncekinden sabit bir sayı (ortak fark) kadar farklıdır.\n\n"
            f"**Genel terim formülü:** $a_n = a_1 + (n-1) \\cdot d$\n\n"
            f"Verilen bilgiler:\n"
            f"  • $a_1 = {a1}$ (ilk terim)\n"
            f"  • $d = {d}$ (ortak fark)\n"
            f"  • $n = {n}$ (kaçıncı terim?)\n\n"
            f"**Hesaplama:**\n"
            f"  $a_{{{n}}} = {a1} + ({n} - 1) \\times {d}$\n"
            f"  $a_{{{n}}} = {a1} + {n-1} \\times {d}$\n"
            f"  $a_{{{n}}} = {a1} + {(n-1)*d}$\n"
            f"  $a_{{{n}}} = {an}$\n\n"
            f"Dizinin ilk {n} terimi: {', '.join(str(a1 + i*d) for i in range(n))}\n\n"
            f"$\\boxed{{{an}}}$"
        )
    else:
        Sn = n * (2 * a1 + (n - 1) * d) // 2
        soru = f"İlk terimi {a1}, ortak farkı {d} olan aritmetik dizinin ilk {n} teriminin toplamı kaçtır?"
        cozum = (
            f"**Toplam formülü:** $S_n = \\frac{{n}}{{2}} \\cdot (2a_1 + (n-1) \\cdot d)$\n\n"
            f"Verilen bilgiler:\n"
            f"  • $a_1 = {a1}$,  $d = {d}$,  $n = {n}$\n\n"
            f"**Hesaplama:**\n"
            f"  $S_{{{n}}} = \\frac{{{n}}}{{2}} \\cdot (2 \\times {a1} + ({n}-1) \\times {d})$\n"
            f"  $= \\frac{{{n}}}{{2}} \\cdot ({2*a1} + {(n-1)*d})$\n"
            f"  $= \\frac{{{n}}}{{2}} \\cdot {2*a1 + (n-1)*d}$\n"
            f"  $= {Sn}$\n\n"
            f"Dizinin ilk {n} terimi: {', '.join(str(a1 + i*d) for i in range(n))}\n"
            f"Toplam: {' + '.join(str(a1 + i*d) for i in range(n))} = {Sn}\n\n"
            f"$\\boxed{{{Sn}}}$"
        )
    return soru, cozum, "Aritmetik Dizi", s


# ══════════════════════════════════════════════
# 24. GEOMETRİK DİZİ
# ══════════════════════════════════════════════
def gen_geometric_sequence():
    s = "medium"
    a1 = random.randint(2, 8)
    r = random.randint(2, 4)
    n = random.randint(4, 6)   # min 4. terim → en az a1*r^3 >= 2*8=16
    an = a1 * (r ** (n - 1))
    dizi = [a1 * r**i for i in range(n)]

    soru = f"İlk terimi {a1}, ortak çarpanı {r} olan geometrik dizinin {n}. terimi kaçtır?"
    cozum = (
        f"Geometrik dizide her terim, bir öncekinin sabit bir sayı (ortak çarpan) ile çarpılmasıyla elde edilir.\n\n"
        f"**Genel terim formülü:** $a_n = a_1 \\cdot r^{{n-1}}$\n\n"
        f"Verilen bilgiler:\n"
        f"  • $a_1 = {a1}$\n"
        f"  • $r = {r}$ (ortak çarpan)\n"
        f"  • $n = {n}$\n\n"
        f"**Hesaplama:**\n"
        f"  $a_{{{n}}} = {a1} \\cdot {r}^{{{n}-1}}$\n"
        f"  $= {a1} \\cdot {r}^{{{n-1}}}$\n"
        f"  $= {a1} \\cdot {r**(n-1)}$\n"
        f"  $= {an}$\n\n"
        f"Dizinin ilk {n} terimi: {', '.join(map(str, dizi))}\n\n"
        f"$\\boxed{{{an}}}$"
    )
    return soru, cozum, "Geometrik Dizi", s


# ══════════════════════════════════════════════
# 25. EBOB / EKOK
# ══════════════════════════════════════════════
def gen_gcd_lcm():
    s = "medium"
    # Ortak çarpanı garantile: a = k*p, b = k*q (k>=2, p≠q asal)
    k = random.randint(2, 8)
    p = random.randint(2, 12)
    q = random.randint(2, 12)
    while q == p:
        q = random.randint(2, 12)
    a = k * p
    b = k * q
    tip = random.choice(["ebob", "ekok"])
    result = ebob(a, b) if tip == "ebob" else ekok(a, b)

    ca = asal_carpanlar(a)
    cb = asal_carpanlar(b)

    soru = f"{a} ve {b} sayılarının {'EBOB' if tip == 'ebob' else 'EKOK'}'u kaçtır?"
    cozum = (
        f"{'EBOB (En Büyük Ortak Bölen)' if tip == 'ebob' else 'EKOK (En Küçük Ortak Kat)'} "
        f"bulmak için **asal çarpanlara ayırma** yöntemini kullanırız.\n\n"
        f"**1. Adım – Asal çarpanlara ayır:**\n"
        f"  {a} = {' × '.join(map(str, ca))}\n"
        f"  {b} = {' × '.join(map(str, cb))}\n\n"
    )
    if tip == "ebob":
        cozum += (
            f"**2. Adım – Her iki sayıda da ortak olan asal çarpanları al (küçük kuvvetiyle):**\n"
            f"  EBOB = {result}\n\n"
            f"**Kontrol:** {a} ÷ {result} = {a//result}, {b} ÷ {result} = {b//result}  ✓\n\n"
            f"$\\boxed{{{result}}}$"
        )
    else:
        cozum += (
            f"**2. Adım – Her asal çarpanı en yüksek kuvvetiyle al:**\n"
            f"  EKOK = {result}\n\n"
            f"**Kontrol:** {result} ÷ {a} = {result//a}, {result} ÷ {b} = {result//b}  ✓\n\n"
            f"Ayrıca: EBOB × EKOK = {a} × {b} = {a*b}, "
            f"EBOB({a},{b}) × EKOK({a},{b}) = {ebob(a,b)} × {ekok(a,b)} = {ebob(a,b)*ekok(a,b)}  ✓\n\n"
            f"$\\boxed{{{result}}}$"
        )
    return soru, cozum, "EBOB / EKOK", s


# ══════════════════════════════════════════════
# 26. ASAL SAYI / ASAL ÇARPANLARA AYIRMA
# ══════════════════════════════════════════════
def gen_prime_factorization():
    s = "medium"
    n = random.randint(20, 150)
    carpanlar = asal_carpanlar(n)

    soru = f"{n} sayısını asal çarpanlarına ayırınız."
    cozum = f"**Bölme ağacı yöntemiyle** {n} sayısını asal çarpanlarına ayıralım:\n\n"
    temp = n
    adim = 1
    for p in carpanlar:
        cozum += f"  {adim}. {temp} ÷ {p} = {temp // p}\n"
        temp //= p
        adim += 1
    cozum += (
        f"\n{n} = {' × '.join(map(str, carpanlar))}\n\n"
        f"Doğrulama: {' × '.join(map(str, carpanlar))} = {n}  ✓\n\n"
        f"Tüm asal çarpanlar: {set(carpanlar)}\n\n"
        f"$\\boxed{{{n} = {' \\times '.join(map(str, carpanlar))}}}$"
    )
    return soru, cozum, "Asal Çarpanlara Ayırma", s


# ══════════════════════════════════════════════
# 27. ORTALAMA (Aritmetik)
# ══════════════════════════════════════════════
def gen_arithmetic_mean():
    s = "medium"
    n = random.randint(4, 7)
    sayilar = [random.randint(10, 99) for _ in range(n)]
    toplam = sum(sayilar)
    ort = toplam / n

    soru = f"{', '.join(map(str, sayilar))} sayılarının aritmetik ortalaması kaçtır?"
    cozum = (
        f"**Aritmetik ortalama formülü:** $\\bar{{x}} = \\dfrac{{\\text{{Toplam}}}}{{\\text{{Sayı adedi}}}}$\n\n"
        f"**1. Adım – Tüm sayıları topla:**\n"
        f"  {' + '.join(map(str, sayilar))} = {toplam}\n\n"
        f"**2. Adım – Sayı adedine böl:**\n"
        f"  $\\bar{{x}} = \\dfrac{{{toplam}}}{{{n}}} = "
        + (f"{int(ort)}" if ort == int(ort) else f"{ort:.2f}") + "$\n\n"
        f"$\\boxed{{" + (f"{int(ort)}" if ort == int(ort) else f"{ort:.2f}") + "}}$"
    )
    return soru, cozum, "Aritmetik Ortalama", s


# ══════════════════════════════════════════════
# 28. MEDYAN (Ortanca)
# ══════════════════════════════════════════════
def gen_median():
    s = "medium"
    n = random.choice([5, 7])  # Tek sayı – tek bir ortanca var
    sayilar = sorted([random.randint(10, 50) for _ in range(n)])
    medyan = sayilar[n // 2]

    soru = f"{', '.join(map(str, sayilar))} sayılarının medyanı (ortancası) kaçtır?"
    cozum = (
        f"Medyan, sayılar küçükten büyüğe sıralandığında tam ortada kalan değerdir.\n\n"
        f"**1. Adım – Sayıları sırala:**\n"
        f"  {', '.join(map(str, sayilar))}\n\n"
        f"**2. Adım – Ortadaki değeri bul:**\n"
        f"  {n} adet sayı var, ortanca {n//2 + 1}. sıradaki değerdir.\n"
        f"  {', '.join(f'**{s}**' if i == n//2 else str(s) for i, s in enumerate(sayilar))}\n\n"
        f"Medyan = {medyan}\n\n"
        f"$\\boxed{{{medyan}}}$"
    )
    return soru, cozum, "Medyan (Ortanca)", s


# ══════════════════════════════════════════════
# 29. MOD (En sık tekrar eden)
# ══════════════════════════════════════════════
def gen_mode():
    s = "medium"
    tekrarlanan = random.randint(10, 30)
    diger = random.sample(range(10, 50), 4)
    while tekrarlanan in diger:
        tekrarlanan = random.randint(10, 30)
    sayilar = diger + [tekrarlanan, tekrarlanan]
    random.shuffle(sayilar)

    soru = f"{', '.join(map(str, sayilar))} veri kümesinin modu (en sık tekrar eden değeri) kaçtır?"
    from collections import Counter
    sayim = Counter(sayilar)
    cozum = (
        f"Mod, veri kümesinde **en çok tekrar eden** değerdir.\n\n"
        f"**1. Adım – Her değerin kaç kez geçtiğini say:**\n"
    )
    for k, v in sorted(sayim.items()):
        cozum += f"  {k}: {v} kez {'← en fazla!' if k == tekrarlanan else ''}\n"
    cozum += (
        f"\n**2. Adım – En yüksek frekansa sahip değeri bul:**\n"
        f"  {tekrarlanan} değeri {sayim[tekrarlanan]} kez tekrar ediyor.\n\n"
        f"$\\boxed{{{tekrarlanan}}}$"
    )
    return soru, cozum, "Mod (En sık tekrar eden)", s


# ══════════════════════════════════════════════
# 30. OLASILIK (Temel)
# ══════════════════════════════════════════════
def gen_probability():
    s = "medium"
    toplam = random.choice([6, 10, 12, 20, 52])
    isimler = {
        6: ("zar", "yüzey", "yüz"),
        10: ("top", "top", "top"),
        12: ("kart", "kart", "kart"),
        20: ("kart", "kart", "kart"),
        52: ("kart", "kart", "kart"),
    }
    nesne, _, _ = isimler[toplam]
    elverişli = random.randint(1, toplam // 3)
    g = math.gcd(elverişli, toplam)
    pay, payda = elverişli // g, toplam // g

    soru = (
        f"İçinde {toplam} eşit {nesne} bulunan bir torbadan rastgele bir {nesne} çekiliyor. "
        f"Elverişli sonuç sayısı {elverişli} ise bu olayın olasılığı kaçtır?"
    )
    cozum = (
        f"**Klasik Olasılık Formülü:**\n"
        f"  $P(A) = \\dfrac{{\\text{{Elverişli sonuç sayısı}}}}{{"
        f"\\text{{Toplam eşit olası sonuç sayısı}}}}$\n\n"
        f"Verilen bilgiler:\n"
        f"  • Toplam {nesne} sayısı: {toplam}\n"
        f"  • Elverişli {nesne} sayısı: {elverişli}\n\n"
        f"**Hesaplama:**\n"
        f"  $P(A) = \\dfrac{{{elverişli}}}{{{toplam}}}$\n\n"
    )
    if g > 1:
        cozum += (
            f"  Sadeleştir (EBOB = {g}):\n"
            f"  $P(A) = \\dfrac{{{pay}}}{{{payda}}}$\n\n"
        )
    cozum += f"$\\boxed{{P(A) = \\dfrac{{{pay}}}{{{payda}}}}}$"
    return soru, cozum, "Olasılık", s


# ══════════════════════════════════════════════
# 31. KÜMELER (Birleşim & Kesişim)
# ══════════════════════════════════════════════
def gen_sets():
    s = "medium"
    n_A = random.randint(10, 40)
    n_B = random.randint(10, 40)
    n_inter = random.randint(2, min(n_A, n_B) - 2)
    n_union = n_A + n_B - n_inter

    soru = (
        f"$s(A) = {n_A}$, $s(B) = {n_B}$ ve $s(A \\cap B) = {n_inter}$ olduğuna göre "
        f"$s(A \\cup B)$ kaçtır?"
    )
    cozum = (
        f"Birleşim formülü: $s(A \\cup B) = s(A) + s(B) - s(A \\cap B)$\n\n"
        f"Ortak elemanlar toplamda iki kere sayılır; bunu önlemek için bir kez çıkarılır.\n\n"
        f"**Hesaplama:**\n"
        f"  $s(A \\cup B) = {n_A} + {n_B} - {n_inter}$\n"
        f"  $= {n_A + n_B} - {n_inter}$\n"
        f"  $= {n_union}$\n\n"
        f"$\\boxed{{{n_union}}}$"
    )
    return soru, cozum, "Kümeler", s


# ══════════════════════════════════════════════
# 32. ALAN HESABı – Dikdörtgen
# ══════════════════════════════════════════════
def gen_area_rectangle():
    s = "medium"
    a = random.randint(3, 20)
    b = random.randint(3, 20)
    alan = a * b
    cevre = 2 * (a + b)
    tip = random.choice(["alan", "cevre"])

    if tip == "alan":
        soru = f"Kenar uzunlukları {a} cm ve {b} cm olan dikdörtgenin alanı kaç cm²'dir?"
        cozum = (
            f"**Dikdörtgen Alanı Formülü:** Alan = uzun kenar × kısa kenar\n\n"
            f"Alan = {a} × {b} = {alan} cm²\n\n"
            f"$\\boxed{{{alan} \\text{{ cm}}^2}}$"
        )
    else:
        soru = f"Kenar uzunlukları {a} cm ve {b} cm olan dikdörtgenin çevresi kaç cm'dir?"
        cozum = (
            f"**Dikdörtgen Çevre Formülü:** Çevre = 2 × (a + b)\n\n"
            f"Çevre = 2 × ({a} + {b}) = 2 × {a+b} = {cevre} cm\n\n"
            f"$\\boxed{{{cevre} \\text{{ cm}}}}$"
        )
    return soru, cozum, "Alan/Çevre (Dikdörtgen)", s


# ══════════════════════════════════════════════
# 33. ALAN HESABı – Üçgen
# ══════════════════════════════════════════════
def gen_area_triangle():
    s = "medium"
    taban = random.randint(4, 20)
    yukseklik = random.randint(3, 15)
    alan = taban * yukseklik / 2

    soru = f"Tabanı {taban} cm ve yüksekliği {yukseklik} cm olan üçgenin alanı kaç cm²'dir?"
    cozum = (
        f"**Üçgen Alanı Formülü:** Alan = $\\frac{{\\text{{taban}} \\times \\text{{yükseklik}}}}{{2}}$\n\n"
        f"Alan = $\\frac{{{taban} \\times {yukseklik}}}{{2}} = \\frac{{{taban*yukseklik}}}{{2}} = {alan:.1f}$ cm²\n\n"
        f"$\\boxed{{{alan:.1f} \\text{{ cm}}^2}}$"
    )
    return soru, cozum, "Alan (Üçgen)", s


# ══════════════════════════════════════════════
# 34. ALAN HESABı – Daire
# ══════════════════════════════════════════════
def gen_area_circle():
    s = "medium"
    r = random.randint(2, 12)
    alan = math.pi * r * r
    tip = random.choice(["alan", "cevre"])

    if tip == "alan":
        soru = f"Yarıçapı {r} cm olan bir dairenin alanı kaç cm²'dir? ($\\pi = 3.14$ alınız)"
        pi = 3.14
        cozum = (
            f"**Daire Alanı Formülü:** Alan = $\\pi r^2$\n\n"
            f"$r = {r}$ cm\n\n"
            f"Alan = $3.14 \\times {r}^2 = 3.14 \\times {r*r} = {3.14 * r * r:.2f}$ cm²\n\n"
            f"$\\boxed{{{3.14*r*r:.2f} \\text{{ cm}}^2}}$"
        )
    else:
        cevre = 2 * 3.14 * r
        soru = f"Yarıçapı {r} cm olan bir dairenin çevresi kaç cm'dir? ($\\pi = 3.14$ alınız)"
        cozum = (
            f"**Daire Çevresi Formülü:** Çevre = $2\\pi r$\n\n"
            f"Çevre = $2 \\times 3.14 \\times {r} = {cevre:.2f}$ cm\n\n"
            f"$\\boxed{{{cevre:.2f} \\text{{ cm}}}}$"
        )
    return soru, cozum, "Alan/Çevre (Daire)", s


# ══════════════════════════════════════════════
# 35. HACİM – Küp & Dikdörtgenler Prizması
# ══════════════════════════════════════════════
def gen_volume():
    s = "medium"
    tip = random.choice(["küp", "dikdörtgenler_prizması"])
    if tip == "küp":
        a = random.randint(2, 10)
        hacim = a ** 3
        soru = f"Kenar uzunluğu {a} cm olan bir küpün hacmi kaç cm³'tür?"
        cozum = (
            f"**Küp Hacmi Formülü:** $V = a^3$\n\n"
            f"$V = {a}^3 = {a} \\times {a} \\times {a} = {hacim}$ cm³\n\n"
            f"$\\boxed{{{hacim} \\text{{ cm}}^3}}$"
        )
    else:
        a = random.randint(2, 10)
        b = random.randint(2, 10)
        c = random.randint(2, 10)
        hacim = a * b * c
        soru = f"Kenar uzunlukları {a} cm, {b} cm ve {c} cm olan dikdörtgenler prizmasının hacmi kaç cm³'tür?"
        cozum = (
            f"**Dikdörtgenler Prizması Hacmi:** $V = a \\times b \\times c$\n\n"
            f"$V = {a} \\times {b} \\times {c} = {hacim}$ cm³\n\n"
            f"$\\boxed{{{hacim} \\text{{ cm}}^3}}$"
        )
    return soru, cozum, "Hacim", s


# ══════════════════════════════════════════════
# 36. PİSAGOR TEOREMİ
# ══════════════════════════════════════════════
def gen_pythagorean():
    # Pitagor üçlüleri
    triples = [(3,4,5),(5,12,13),(8,15,17),(7,24,25),(6,8,10),(9,12,15),(9,40,41)]
    a, b, c = random.choice(triples)
    k = random.randint(1, 3)
    a, b, c = a*k, b*k, c*k
    tip = random.choice(["hipotenüs", "dik_kenar"])

    if tip == "hipotenüs":
        soru = f"Dik kenarları {a} cm ve {b} cm olan dik üçgenin hipotenüsü kaç cm'dir?"
        cozum = (
            f"**Pisagor Teoremi:** $c^2 = a^2 + b^2$\n\n"
            f"Burada $a = {a}$, $b = {b}$, $c = ?$\n\n"
            f"**1. Adım – Kareleri al:**\n"
            f"  $a^2 = {a}^2 = {a*a}$\n"
            f"  $b^2 = {b}^2 = {b*b}$\n\n"
            f"**2. Adım – Topla:**\n"
            f"  $c^2 = {a*a} + {b*b} = {a*a + b*b}$\n\n"
            f"**3. Adım – Karekök al:**\n"
            f"  $c = \\sqrt{{{a*a + b*b}}} = {c}$ cm\n\n"
            f"$\\boxed{{{c} \\text{{ cm}}}}$"
        )
    else:
        soru = f"Hipotenüsü {c} cm, bir dik kenarı {a} cm olan dik üçgenin diğer dik kenarı kaç cm'dir?"
        cozum = (
            f"**Pisagor Teoremi:** $c^2 = a^2 + b^2$ → $b^2 = c^2 - a^2$\n\n"
            f"**1. Adım – Kareleri hesapla:**\n"
            f"  $c^2 = {c}^2 = {c*c}$\n"
            f"  $a^2 = {a}^2 = {a*a}$\n\n"
            f"**2. Adım – Çıkar:**\n"
            f"  $b^2 = {c*c} - {a*a} = {b*b}$\n\n"
            f"**3. Adım – Karekök al:**\n"
            f"  $b = \\sqrt{{{b*b}}} = {b}$ cm\n\n"
            f"$\\boxed{{{b} \\text{{ cm}}}}$"
        )
    return soru, cozum, "Pisagor Teoremi", "medium"


# ══════════════════════════════════════════════
# 37. AÇILAR (Tamamlayan / Bütünleyen)
# ══════════════════════════════════════════════
def gen_angles():
    tip = random.choice(["tamamlayan", "butunleyen", "üçgen"])
    if tip == "tamamlayan":
        a = random.randint(15, 75)
        b = 90 - a
        soru = f"{a}° açısının tümler açısı kaç derecedir?"
        cozum = (
            f"**Tümler (tamamlayan) açılar:** Toplamı 90° olan açı çiftleridir.\n\n"
            f"Tümler açı = 90° - {a}° = {b}°\n\n"
            f"$\\boxed{{{b}°}}$"
        )
    elif tip == "butunleyen":
        a = random.randint(20, 160)
        b = 180 - a
        soru = f"{a}° açısının bütünler açısı kaç derecedir?"
        cozum = (
            f"**Bütünler açılar:** Toplamı 180° olan açı çiftleridir.\n\n"
            f"Bütünler açı = 180° - {a}° = {b}°\n\n"
            f"$\\boxed{{{b}°}}$"
        )
    else:
        a = random.randint(30, 70)
        b_max = 180 - a - 10  # en az 10° üçüncü açı kalsın
        b = random.randint(20, min(b_max, 90))
        c = 180 - a - b
        soru = f"Bir üçgenin iki iç açısı {a}° ve {b}° ise üçüncü iç açı kaç derecedir?"
        cozum = (
            f"**Üçgenin iç açıları toplamı = 180°** kuralını kullanırız.\n\n"
            f"Üçüncü açı = 180° - {a}° - {b}° = {c}°\n\n"
            f"Doğrulama: {a}° + {b}° + {c}° = {a+b+c}°  ✓\n\n"
            f"$\\boxed{{{c}°}}$"
        )
    return soru, cozum, "Açılar", "medium"


# ══════════════════════════════════════════════
# 38. ONDALıKLI SAYI İŞLEMLERİ
# ══════════════════════════════════════════════
def gen_decimal_operations():
    tip = random.choice(["toplama", "çıkarma", "çarpma"])
    if tip == "toplama":
        a = round(random.uniform(10.5, 60.5), 1)
        b = round(random.uniform(10.5, 60.5), 1)
        r = round(a + b, 1)
        soru = f"{a} + {b} işleminin sonucu kaçtır?"
        cozum = (
            f"Ondalık sayıların toplamında **virgüller hizalı** olacak şekilde alt alta yazılır.\n\n"
            f"  {a:>8}\n"
            f"+ {b:>8}\n"
            f"{'─'*12}\n"
            f"  {r:>8}\n\n"
            f"$\\boxed{{{r}}}$"
        )
    elif tip == "çıkarma":
        a = round(random.uniform(30.5, 80.5), 1)
        b = round(random.uniform(10.5, a - 10), 1)
        r = round(a - b, 1)
        soru = f"{a} - {b} işleminin sonucu kaçtır?"
        cozum = (
            f"Ondalık çıkarmada da virgüller hizalı yazılır.\n\n"
            f"  {a:>8}\n"
            f"- {b:>8}\n"
            f"{'─'*12}\n"
            f"  {r:>8}\n\n"
            f"$\\boxed{{{r}}}$"
        )
    else:
        a = round(random.uniform(3.5, 9.9), 1)
        b = random.randint(5, 15)   # çarpan en az 5
        r = round(a * b, 2)
        soru = f"{a} $\\times$ {b} işleminin sonucu kaçtır?"
        cozum = (
            f"Ondalık çarpmada önce sayıları tam sayı gibi çarpıp sonra virgülü ayarlarız.\n\n"
            f"  {a} = {int(a*10)} (10 ile çarpılarak tam sayıya dönüştürüldü)\n\n"
            f"  {int(a*10)} $\\times$ {b} = {int(a*10)*b}\n\n"
            f"  Sonucu 10'a böl (virgülü bir basamak sola kaydır):\n"
            f"  {int(a*10)*b} $\\div$ 10 = {r}\n\n"
            f"$\\boxed{{{r}}}$"
        )
    return soru, cozum, "Ondalıklı Sayı İşlemleri", "medium"


# ══════════════════════════════════════════════
# 39. KESİR ↔ ONDALIK ↔ YÜZDE DÖNÜŞÜM
# ══════════════════════════════════════════════
def gen_fraction_decimal_percent():
    paydalar = [6, 7, 8, 9, 12, 15, 16, 20, 24, 25, 40]
    payda = random.choice(paydalar)
    pay = random.randint(2, payda - 2)   # 1/x ve (x-1)/x gibi trivial uçlardan kaçın
    g = math.gcd(pay, payda)
    sp, sd = pay//g, payda//g
    ondalik = pay / payda
    yuzde = ondalik * 100

    tip = random.choice(["kesirden_ondalik", "ondaliktan_yuzde", "yüzdeden_kesir"])
    if tip == "kesirden_ondalik":
        soru = f"$\\frac{{{pay}}}{{{payda}}}$ kesrini ondalık sayıya dönüştürünüz."
        cozum = (
            f"Kesri ondalığa çevirmek için **payı paydaya böleriz.**\n\n"
            f"  {pay} ÷ {payda} = {ondalik}\n\n"
            f"Alternatif: Paydayı 100'e tamamlayabiliriz:\n"
            f"  $\\frac{{{pay}}}{{{payda}}} = \\frac{{{int(yuzde)}}}{{{100}}} = {ondalik}$\n\n"
            f"$\\boxed{{{ondalik}}}$"
        )
    elif tip == "ondaliktan_yuzde":
        soru = f"{ondalik} ondalık sayısını yüzde olarak ifade ediniz."
        cozum = (
            f"Ondalık sayıyı yüzdeye çevirmek için **100 ile çarparız** ve % işareti koyarız.\n\n"
            f"  ${ondalik} \\times 100 = {yuzde:.1f}$\n\n"
            f"Yani {ondalik} = **%{yuzde:.1f}**\n\n"
            f"$\\boxed{{\\%{yuzde:.1f}}}$"
        )
    else:
        soru = f"%{yuzde:.0f}'i kesir olarak yazınız."
        cozum = (
            f"Yüzdeyi kesre çevirmek için pay = yüzde değeri, payda = 100 olur.\n\n"
            f"  $\\%{yuzde:.0f} = \\frac{{{int(yuzde)}}}{{100}}$\n\n"
            f"Sadeleştir (EBOB = {math.gcd(int(yuzde),100)}):\n"
            f"  $\\frac{{{sp}}}{{{sd}}}$\n\n"
            f"$\\boxed{{\\frac{{{sp}}}{{{sd}}}}}$"
        )
    return soru, cozum, "Kesir ↔ Ondalık ↔ Yüzde Dönüşüm", "medium"


# ══════════════════════════════════════════════
# 40. BİLİMSEL GÖSTERIM
# ══════════════════════════════════════════════
def gen_scientific_notation():
    exp = random.randint(2, 8)
    mantis = round(random.uniform(1.1, 9.9), 1)
    sayi = mantis * (10 ** exp)
    tip = random.choice(["büyük_to_bilimsel", "bilimsel_to_büyük"])

    if tip == "büyük_to_bilimsel":
        # Tam sayı kullan daha temiz olsun
        tam_sayi = int(mantis * 10) * (10 ** (exp - 1))
        m2 = tam_sayi / (10 ** exp)
        soru = f"{tam_sayi} sayısını bilimsel gösterimle yazınız."
        cozum = (
            f"Bilimsel gösterimde sayı $a \\times 10^n$ biçiminde yazılır; "
            f"burada $1 \\leq a < 10$.\n\n"
            f"**Adım adım:**\n"
            f"1. Virgülü ilk anlamlı rakamdan sonra koy: {m2}\n"
            f"2. Virgül kaç basamak kaydırıldı? {exp} basamak sola → $10^{{{exp}}}$\n\n"
            f"{tam_sayi} = ${m2} \\times 10^{{{exp}}}$\n\n"
            f"$\\boxed{{{m2} \\times 10^{{{exp}}}}}$"
        )
    else:
        soru = f"${mantis} \\times 10^{{{exp}}}$ sayısını standart biçimde yazınız."
        sifirlar = "0" * (exp - 1)
        mantis_str = str(mantis).replace(".", "")
        cozum = (
            f"Bilimsel gösterimi standart biçime çevirmek için ondalık noktayı "
            f"üs kadar **sağa kaydırırız.**\n\n"
            f"Üs = {exp}, yani virgülü {exp} basamak sağa taşı:\n\n"
            f"${mantis} \\times 10^{{{exp}}} = {int(mantis * 10**exp)}$\n\n"
            f"$\\boxed{{{int(mantis * 10**exp)}}}$"
        )
    return soru, cozum, "Bilimsel Gösterim", "medium"


# ══════════════════════════════════════════════
# 41. ORAN – ORANI (Doğru & Ters Orantı)
# ══════════════════════════════════════════════
def gen_proportion():
    tip = random.choice(["doğru", "ters"])
    a = random.randint(2, 10)
    b = random.randint(2, 10)
    c = random.randint(2, 10)
    if tip == "doğru":
        d = b * c // a if (b * c) % a == 0 else None
        if d is None or d < 10:
            # Temiz ve sonucu büyük bir üçlü üret
            a = random.randint(2, 5)
            b = random.randint(10, 30)
            c = a * random.randint(3, 8)
            d = b * c // a
        soru = f"$\\frac{{{a}}}{{{b}}} = \\frac{{{c}}}{{x}}$ orantısında $x$ kaçtır? (Doğru orantı)"
        cozum = (
            f"**Doğru orantıda:** $\\frac{{a}}{{b}} = \\frac{{c}}{{x}}$ → $a \\cdot x = b \\cdot c$\n\n"
            f"  ${a} \\times x = {b} \\times {c}$\n"
            f"  ${a}x = {b*c}$\n"
            f"  $x = {b*c} \\div {a} = {d}$\n\n"
            f"$\\boxed{{{d}}}$"
        )
    else:
        # a1*b1 = a2*b2 → ters orantı
        a1 = random.randint(2, 8)
        b1 = random.randint(2, 8)
        a2 = random.randint(2, 8)
        x = a1 * b1 // a2 if (a1 * b1) % a2 == 0 else a1 * b1
        payda2 = a2 if (a1 * b1) % a2 == 0 else 1
        x_val = a1 * b1 // a2 if (a1 * b1) % a2 == 0 else None
        if x_val is None:
            a2 = a1  # garantili tam bölünme
            x_val = b1
        soru = f"{a1} işçi bir işi {b1} günde bitiriyor. {a2} işçi aynı işi kaç günde bitirir? (Ters orantı)"
        cozum = (
            f"İşçi sayısı arttıkça iş süresi azalır → **Ters orantı**\n\n"
            f"Ters orantıda: $a_1 \\times b_1 = a_2 \\times b_2$\n\n"
            f"  ${a1} \\times {b1} = {a2} \\times x$\n"
            f"  ${a1*b1} = {a2}x$\n"
            f"  $x = {a1*b1} \\div {a2} = {x_val}$\n\n"
            f"{a2} işçi işi **{x_val} günde** bitirir.\n\n"
            f"$\\boxed{{{x_val} \\text{{ gün}}}}$"
        )
    return soru, cozum, "Oran - Orantı", "medium"


# ══════════════════════════════════════════════
# 42. CEBİRSEL İFADE AÇILIMI (FOIL / (a+b)²)
# ══════════════════════════════════════════════
def gen_algebraic_expansion():
    a = random.randint(2, 8)
    b = random.randint(1, 6)
    tip = random.choice(["kare_toplam", "kare_fark", "fark_carpimi"])

    if tip == "kare_toplam":
        soru = f"$(x + {a})^2$ ifadesini açınız."
        cozum = (
            f"**Tam Kare Formülü:** $(a+b)^2 = a^2 + 2ab + b^2$\n\n"
            f"Burada $a = x$, $b = {a}$\n\n"
            f"$(x + {a})^2 = x^2 + 2 \\cdot x \\cdot {a} + {a}^2$\n\n"
            f"$= x^2 + {2*a}x + {a**2}$\n\n"
            f"$\\boxed{{x^2 + {2*a}x + {a**2}}}$"
        )
    elif tip == "kare_fark":
        soru = f"$(x - {a})^2$ ifadesini açınız."
        cozum = (
            f"**Tam Kare Fark Formülü:** $(a-b)^2 = a^2 - 2ab + b^2$\n\n"
            f"Burada $a = x$, $b = {a}$\n\n"
            f"$(x - {a})^2 = x^2 - 2 \\cdot x \\cdot {a} + {a}^2$\n\n"
            f"$= x^2 - {2*a}x + {a**2}$\n\n"
            f"$\\boxed{{x^2 - {2*a}x + {a**2}}}$"
        )
    else:
        soru = f"$(x + {a})(x - {a})$ ifadesini açınız."
        cozum = (
            f"**Fark Çarpımı Formülü:** $(a+b)(a-b) = a^2 - b^2$\n\n"
            f"Burada $a = x$, $b = {a}$\n\n"
            f"$(x + {a})(x - {a}) = x^2 - {a}^2 = x^2 - {a**2}$\n\n"
            f"$\\boxed{{x^2 - {a**2}}}$"
        )
    return soru, cozum, "Cebirsel İfade Açılımı", "medium"


# ══════════════════════════════════════════════
# 43. LOGARITMA (Temel)
# ══════════════════════════════════════════════
def gen_logarithm():
    taban = random.choice([2, 3, 5, 10])
    us = random.randint(4, 6)   # log sonucu >= 4, üs değeri >= 16
    sonuc = taban ** us
    tip = random.choice(["değer", "denklem"])

    if tip == "değer":
        soru = f"$\\log_{{{taban}}} {sonuc}$ değerini hesaplayınız."
        cozum = (
            f"**Logaritma tanımı:** $\\log_b a = c$ ↔ $b^c = a$\n\n"
            f"$\\log_{{{taban}}} {sonuc} = ?$ demek, \"{taban}'ün kaçıncı kuvveti {sonuc}'dir?\" demektir.\n\n"
            f"{taban}'ün kuvvetleri:\n"
        )
        for k in range(1, us + 1):
            cozum += f"  ${taban}^{{{k}}} = {taban**k}$" + (" ✓ Bulundu!" if taban**k == sonuc else "") + "\n"
        cozum += (
            f"\n$\\log_{{{taban}}} {sonuc} = {us}$\n\n"
            f"$\\boxed{{{us}}}$"
        )
    else:
        soru = f"$\\log_{{{taban}}} x = {us}$ denkleminde $x$ kaçtır?"
        cozum = (
            f"**Logaritma tanımı:** $\\log_b x = c$ → $x = b^c$\n\n"
            f"$\\log_{{{taban}}} x = {us}$\n\n"
            f"$x = {taban}^{{{us}}} = "
            + " \\times ".join([str(taban)] * us) +
            f" = {sonuc}$\n\n"
            f"$\\boxed{{{sonuc}}}$"
        )
    return soru, cozum, "Logaritma", "medium"


# ══════════════════════════════════════════════
# 44. TRİGONOMETRİ (sin/cos/tan – özel açılar)
# ══════════════════════════════════════════════
def gen_trigonometry():
    ozel_acılar = {
        0:  {"sin": "0", "cos": "1", "tan": "0"},
        30: {"sin": "\\frac{1}{2}", "cos": "\\frac{\\sqrt{3}}{2}", "tan": "\\frac{1}{\\sqrt{3}}"},
        45: {"sin": "\\frac{\\sqrt{2}}{2}", "cos": "\\frac{\\sqrt{2}}{2}", "tan": "1"},
        60: {"sin": "\\frac{\\sqrt{3}}{2}", "cos": "\\frac{1}{2}", "tan": "\\sqrt{3}"},
        90: {"sin": "1", "cos": "0", "tan": "\\text{tanımsız}"},
    }
    aci = random.choice(list(ozel_acılar.keys()))
    fonk = random.choice(["sin", "cos", "tan"])
    deger = ozel_acılar[aci][fonk]

    soru = f"$\\{fonk} {aci}°$ değeri kaçtır?"
    cozum = (
        f"**Özel açılar tablosunu** kullanarak bu değeri buluruz.\n\n"
        f"| Açı | sin | cos | tan |\n"
        f"|-----|-----|-----|-----|\n"
        f"| 0° | 0 | 1 | 0 |\n"
        f"| 30° | 1/2 | √3/2 | 1/√3 |\n"
        f"| 45° | √2/2 | √2/2 | 1 |\n"
        f"| 60° | √3/2 | 1/2 | √3 |\n"
        f"| 90° | 1 | 0 | tanımsız |\n\n"
        f"Tablodan: $\\{fonk} {aci}° = {deger}$\n\n"
        f"$\\boxed{{${deger}$}}$"
    )
    return soru, cozum, "Trigonometri", "medium"


# ══════════════════════════════════════════════
# 45. VERİ ANALİZİ – Aralık (Range)
# ══════════════════════════════════════════════
def gen_range():
    n = random.randint(5, 8)
    sayilar = sorted([random.randint(5, 80) for _ in range(n)])
    # Aralığın en az 20 olmasını garantile
    while max(sayilar) - min(sayilar) < 20:
        sayilar = sorted([random.randint(5, 80) for _ in range(n)])
    aralik = max(sayilar) - min(sayilar)

    soru = f"{', '.join(map(str, sayilar))} veri kümesinin aralığı (range) kaçtır?"
    cozum = (
        f"**Aralık (Range):** En büyük değer ile en küçük değer arasındaki farktır.\n\n"
        f"**1. Adım – En büyük değeri bul:**\n"
        f"  Maks = {max(sayilar)}\n\n"
        f"**2. Adım – En küçük değeri bul:**\n"
        f"  Min = {min(sayilar)}\n\n"
        f"**3. Adım – Çıkar:**\n"
        f"  Aralık = {max(sayilar)} - {min(sayilar)} = {aralik}\n\n"
        f"$\\boxed{{{aralik}}}$"
    )
    return soru, cozum, "Veri Analizi - Aralık", "medium"


# ══════════════════════════════════════════════
# 46. PERMÜTASYON (nPr)
# ══════════════════════════════════════════════
def gen_permutation():
    n = random.randint(4, 8)
    r = random.randint(2, min(3, n - 1))
    result = math.perm(n, r)

    soru = f"$P({n}, {r})$ = $_{{{n}}}P_{{{r}}}$ kaçtır?"
    cozum = (
        f"**Permütasyon:** $n$ elemanlı bir kümeden $r$ eleman seçip **sıralı** dizilim sayısıdır.\n\n"
        f"**Formül:** $P(n,r) = \\dfrac{{n!}}{{(n-r)!}}$\n\n"
        f"$P({n},{r}) = \\dfrac{{{n}!}}{{({n}-{r})!}} = \\dfrac{{{n}!}}{{{n-r}!}}$\n\n"
        f"$= {n}" + " \\times ".join(str(n - i) for i in range(r)).replace(str(n), "", 1).strip(" \\times").lstrip() + "$\n\n"
    )
    # Daha temiz yol
    cozum = (
        f"**Permütasyon:** $n$ elemanlı kümeden $r$ eleman seçip **sıralı** dizmek.\n\n"
        f"**Formül:** $P(n,r) = n \\times (n-1) \\times \\ldots \\times (n-r+1)$\n\n"
        f"$P({n},{r}) = " + " \\times ".join(str(n - i) for i in range(r)) + f" = {result}$\n\n"
        f"$\\boxed{{{result}}}$"
    )
    return soru, cozum, "Permütasyon", "medium"


# ══════════════════════════════════════════════
# 47. KOMBİNASYON (nCr)
# ══════════════════════════════════════════════
def gen_combination():
    n = random.randint(6, 12)
    r = random.randint(2, min(4, n - 2))
    result = math.comb(n, r)

    soru = f"$C({n}, {r})$ = $\\binom{{{n}}}{{{r}}}$ kaçtır?"
    cozum = (
        f"**Kombinasyon:** $n$ elemanlı kümeden $r$ eleman seçmenin **sırasız** yol sayısı.\n\n"
        f"**Formül:** $C(n,r) = \\dfrac{{n!}}{{r! \\cdot (n-r)!}}$\n\n"
        f"$C({n},{r}) = \\dfrac{{{n}!}}{{{r}! \\cdot {n-r}!}}$\n\n"
        f"$= \\dfrac{{{' × '.join(str(n-i) for i in range(r))}}}{{{' × '.join(str(i+1) for i in range(r))}}}$\n\n"
        f"$= \\dfrac{{{math.perm(n,r)}}}{{{math.factorial(r)}}}$\n\n"
        f"$= {result}$\n\n"
        f"$\\boxed{{{result}}}$"
    )
    return soru, cozum, "Kombinasyon", "medium"


# ══════════════════════════════════════════════
# 48. FAKTOR / ÇARPAN (Polinom Çarpanlar)
# ══════════════════════════════════════════════
def gen_factoring():
    r1 = random.randint(1, 8)
    r2 = random.randint(1, 8)
    b = -(r1 + r2)
    c = r1 * r2
    # x² + bx + c = 0 → (x - r1)(x - r2) = 0
    # Ama bx > 0 için r1,r2 negatif yapalım → x² - (r1+r2)x + r1*r2
    soru = f"$x^2 - {r1+r2}x + {r1*r2}$ ifadesini çarpanlarına ayırınız."
    cozum = (
        f"İkinci dereceden ifadeyi çarpanlarına ayırmak için **toplamı {r1+r2}, çarpımı {r1*r2}** olan "
        f"iki sayı arayalım.\n\n"
        f"Deneyecek sayı çiftleri (çarpımı {r1*r2} olanlar):\n"
    )
    for i in range(1, r1*r2 + 1):
        if r1*r2 % i == 0:
            j = r1*r2 // i
            cozum += f"  {i} ve {j}: toplamları = {i+j}" + (" ✓ Bulundu!\n" if i+j == r1+r2 else "\n")
    cozum += (
        f"\nBulduğumuz sayılar: {r1} ve {r2} (toplam = {r1+r2}, çarpım = {r1*r2})\n\n"
        f"$x^2 - {r1+r2}x + {r1*r2} = (x - {r1})(x - {r2})$\n\n"
        f"**Doğrulama (FOIL):**\n"
        f"  $(x - {r1})(x - {r2}) = x^2 - {r2}x - {r1}x + {r1*r2} = x^2 - {r1+r2}x + {r1*r2}$  ✓\n\n"
        f"$\\boxed{{(x-{r1})(x-{r2})}}$"
    )
    return soru, cozum, "Çarpanlara Ayırma", "medium"


# ══════════════════════════════════════════════
# 49. BASİT FAİZ
# ══════════════════════════════════════════════
def gen_simple_interest():
    ana_para = random.choice([1000, 2000, 5000, 10000])
    oran = random.choice([5, 8, 10, 12, 15])  # yıllık %
    sure = random.randint(1, 5)  # yıl
    faiz = ana_para * oran * sure / 100
    toplam = ana_para + faiz

    soru = (
        f"{ana_para} TL ana para, yıllık %{oran} basit faizle {sure} yıl yatırılıyor. "
        f"Toplam faiz kaç TL'dir?"
    )
    cozum = (
        f"**Basit Faiz Formülü:** $F = P \\times r \\times t$\n\n"
        f"  • P = Ana para = {ana_para} TL\n"
        f"  • r = Yıllık faiz oranı = %{oran} = {oran/100}\n"
        f"  • t = Süre = {sure} yıl\n\n"
        f"**Hesaplama:**\n"
        f"  $F = {ana_para} \\times {oran/100} \\times {sure}$\n"
        f"  $F = {ana_para} \\times {oran*sure/100}$\n"
        f"  $F = {faiz:.0f}$ TL\n\n"
        f"Toplam tutar: {ana_para} + {faiz:.0f} = {toplam:.0f} TL\n\n"
        f"$\\boxed{{{faiz:.0f} \\text{{ TL faiz}}}}$"
    )
    return soru, cozum, "Basit Faiz", "medium"


# ══════════════════════════════════════════════
# 50. BİLEŞİK FAİZ
# ══════════════════════════════════════════════
def gen_compound_interest():
    ana_para = random.choice([1000, 5000, 10000])
    oran = random.choice([5, 10, 20])  # yıllık %
    sure = random.randint(2, 4)  # yıl
    # A = P(1 + r)^t
    r = oran / 100
    A = ana_para * (1 + r) ** sure
    faiz = A - ana_para

    soru = (
        f"{ana_para} TL, yıllık %{oran} bileşik faizle {sure} yıl yatırılıyor. "
        f"Vade sonundaki toplam miktar kaç TL'dir?"
    )
    cozum = (
        f"**Bileşik Faiz Formülü:** $A = P \\times (1 + r)^t$\n\n"
        f"  • P = {ana_para} TL\n"
        f"  • r = {oran/100}\n"
        f"  • t = {sure} yıl\n\n"
        f"**Hesaplama:**\n"
        f"  $A = {ana_para} \\times (1 + {oran/100})^{{{sure}}}$\n"
        f"  $= {ana_para} \\times ({1+oran/100})^{{{sure}}}$\n"
        f"  $= {ana_para} \\times {(1+oran/100)**sure:.4f}$\n"
        f"  $= {A:.2f}$ TL\n\n"
        f"Kazanılan faiz = {A:.2f} - {ana_para} = {faiz:.2f} TL\n\n"
        f"$\\boxed{{{A:.2f} \\text{{ TL}}}}$"
    )
    return soru, cozum, "Bileşik Faiz", "medium"


# ══════════════════════════════════════════════
# 51. MANTIK / LOJİK
# ══════════════════════════════════════════════
def gen_logic():
    s = "medium"
    tip = random.choice(["silogizm", "dogruluk_tablosu", "venn", "olumsuzlama"])

    if tip == "silogizm":
        # Deterministik silogizm: Tüm A→B, Tüm B→C ⇒ Tüm A→C
        kategoriler = [
            ("kediler", "memeliler", "canlılar"),
            ("kareler", "dikdörtgenler", "dörtgenler"),
            ("elmaslar", "taşlar", "doğal maddeler"),
            ("öğrenciler", "gençler", "insanlar"),
            ("gül", "çiçek", "bitki"),
            ("aslanlar", "etçiller", "hayvanlar"),
            ("arabalar", "motorlu araçlar", "taşıtlar"),
            ("üçgenler", "çokgenler", "geometrik şekiller"),
            ("romanlar", "kitaplar", "yazılı eserler"),
            ("violinler", "telli çalgılar", "müzik aletleri"),
        ]
        A, B, C = random.choice(kategoriler)
        # Bazen ters yönde soru sor (geçersiz çıkarım)
        gecerli = random.choice([True, True, True, False])
        if gecerli:
            soru = (
                f"Verilen önermeler:\n"
                f"  1. Tüm {A} {B}'dir.\n"
                f"  2. Tüm {B} {C}'dir.\n\n"
                f"Bu önermelerden \"Tüm {A} {C}'dir\" sonucu çıkar mı?"
            )
            cozum = (
                f"Bu bir **Barbara tipi silogizm** problemidir (AAA-1).\\n\\n"
                f"**Verilen:**\\n"
                f"  Öncül 1: Tüm {A} → {B}\\n"
                f"  Öncül 2: Tüm {B} → {C}\\n\\n"
                f"**Çıkarım kuralı (Geçişlilik / Transitivity):**\\n"
                f"  Eğer Tüm X ⊆ Y ve Tüm Y ⊆ Z ise → Tüm X ⊆ Z\\n\\n"
                f"**Uygulama:**\\n"
                f"  {A} ⊆ {B} (Öncül 1)\\n"
                f"  {B} ⊆ {C} (Öncül 2)\\n"
                f"  ∴ {A} ⊆ {C} (Sonuç)\\n\\n"
                f"Evet, \"Tüm {A} {C}'dir\" sonucu **geçerli** bir çıkarımdır.\\n\\n"
                f"$\\\\boxed{{\\\\text{{Evet, geçerlidir}}}}$"
            )
        else:
            soru = (
                f"Verilen önermeler:\n"
                f"  1. Tüm {A} {B}'dir.\n"
                f"  2. Tüm {B} {C}'dir.\n\n"
                f"Bu önermelerden \"Tüm {C} {A}'dir\" sonucu çıkar mı?"
            )
            cozum = (
                f"**Verilen:**\\n"
                f"  Öncül 1: Tüm {A} → {B}  (yani {A} ⊆ {B})\\n"
                f"  Öncül 2: Tüm {B} → {C}  (yani {B} ⊆ {C})\\n\\n"
                f"**Soru:** Tüm {C} → {A} doğru mu?\\n\\n"
                f"**Analiz:**\\n"
                f"  {A} ⊆ {B} ⊆ {C} ilişkisi vardır.\\n"
                f"  Ancak {C} kümesi {B}'yi, {B} kümesi {A}'yı **içerir**.\\n"
                f"  {C}'nin {A} dışında da elemanları olabilir.\\n\\n"
                f"**Karşı örnek:**\\n"
                f"  Tüm {A} {C}'dir ama {C}'nin hepsi {A} olmak zorunda değildir.\\n\\n"
                f"Bu **tersine çıkarım hatası** (converse error) olur.\\n\\n"
                f"$\\\\boxed{{\\\\text{{Hayır, geçersizdir}}}}$"
            )

    elif tip == "dogruluk_tablosu":
        islem = random.choice(["AND", "OR", "XOR", "IMPLIES"])
        sembol = {"AND": "∧", "OR": "∨", "XOR": "⊕", "IMPLIES": "→"}[islem]
        aciklama = {
            "AND": "VE (Konjunksiyon)",
            "OR": "VEYA (Disjunksiyon)",
            "XOR": "ÖZEL VEYA (Exclusive OR)",
            "IMPLIES": "İÇERME (Koşullu)"
        }[islem]
        # Belirli bir satır için sonucu sor
        p_val = random.choice([True, False])
        q_val = random.choice([True, False])
        if islem == "AND":
            sonuc = p_val and q_val
        elif islem == "OR":
            sonuc = p_val or q_val
        elif islem == "XOR":
            sonuc = p_val != q_val
        else:  # IMPLIES: p→q = ¬p ∨ q
            sonuc = (not p_val) or q_val

        p_str = "D" if p_val else "Y"
        q_str = "D" if q_val else "Y"
        s_str = "D" if sonuc else "Y"

        def tablo_satir(pv, qv, op):
            if op == "AND": r = pv and qv
            elif op == "OR": r = pv or qv
            elif op == "XOR": r = pv != qv
            else: r = (not pv) or qv
            return f"  | {'D' if pv else 'Y':^3} | {'D' if qv else 'Y':^3} | {'D' if r else 'Y':^5} |"

        soru = (
            f"p = {p_str} ({'Doğru' if p_val else 'Yanlış'}) ve "
            f"q = {q_str} ({'Doğru' if q_val else 'Yanlış'}) iken "
            f"p {sembol} q ({aciklama}) işleminin sonucu nedir?"
        )
        cozum = (
            f"**{aciklama}** ({sembol}) doğruluk tablosu:\\n\\n"
            f"  |  p  |  q  | p{sembol}q |\\n"
            f"  |-----|-----|-------|\\n"
            f"{tablo_satir(True, True, islem)}\\n"
            f"{tablo_satir(True, False, islem)}\\n"
            f"{tablo_satir(False, True, islem)}\\n"
            f"{tablo_satir(False, False, islem)}\\n\\n"
        )
        if islem == "AND":
            cozum += f"**Kural:** p ∧ q yalnızca her iki önerme de Doğru olduğunda Doğrudur.\\n\\n"
        elif islem == "OR":
            cozum += f"**Kural:** p ∨ q, en az biri Doğru olduğunda Doğrudur.\\n\\n"
        elif islem == "XOR":
            cozum += f"**Kural:** p ⊕ q, tam olarak biri Doğru olduğunda Doğrudur.\\n\\n"
        else:
            cozum += f"**Kural:** p → q yalnızca p=D ve q=Y olduğunda Yanlıştır; diğer tüm durumlarda Doğrudur.\\n\\n"

        cozum += (
            f"p = {p_str}, q = {q_str} → p {sembol} q = **{s_str} ({'Doğru' if sonuc else 'Yanlış'})**\\n\\n"
            f"$\\\\boxed{{\\\\text{{{s_str} ({'Doğru' if sonuc else 'Yanlış'})}}}}$"
        )

    elif tip == "venn":
        # Üç küme Venn problemi
        sA = random.randint(20, 50)
        sB = random.randint(20, 50)
        sAB = random.randint(3, min(sA, sB) - 5)
        sadece_A = sA - sAB
        sadece_B = sB - sAB
        evrensel = sadece_A + sadece_B + sAB + random.randint(5, 15)
        hicbiri = evrensel - sadece_A - sadece_B - sAB

        soru = (
            f"Bir sınıfta {evrensel} öğrenci vardır. "
            f"{sA} öğrenci matematik, {sB} öğrenci fen dersini seviyor. "
            f"{sAB} öğrenci her iki dersi de seviyor. "
            f"Hiçbir dersi sevmeyen kaç öğrenci vardır?"
        )
        cozum = (
            f"**Venn diyagramı** ile çözelim.\\n\\n"
            f"Verilen bilgiler:\\n"
            f"  • n(E) = {evrensel} (evrensel küme)\\n"
            f"  • n(M) = {sA} (matematik)\\n"
            f"  • n(F) = {sB} (fen)\\n"
            f"  • n(M ∩ F) = {sAB} (her ikisi)\\n\\n"
            f"**1. Adım – Birleşim kümesini bul:**\\n"
            f"  n(M ∪ F) = n(M) + n(F) - n(M ∩ F)\\n"
            f"  = {sA} + {sB} - {sAB} = {sA + sB - sAB}\\n\\n"
            f"**2. Adım – Hiçbirini sevmeyenleri bul:**\\n"
            f"  n(M ∪ F)' = n(E) - n(M ∪ F)\\n"
            f"  = {evrensel} - {sA + sB - sAB} = {hicbiri}\\n\\n"
            f"**Venn bölgeleri:**\\n"
            f"  Sadece Matematik: {sA} - {sAB} = {sadece_A}\\n"
            f"  Sadece Fen: {sB} - {sAB} = {sadece_B}\\n"
            f"  Her ikisi: {sAB}\\n"
            f"  Hiçbiri: {hicbiri}\\n"
            f"  Toplam: {sadece_A} + {sadece_B} + {sAB} + {hicbiri} = {evrensel}  ✓\\n\\n"
            f"$\\\\boxed{{{hicbiri} \\\\text{{ öğrenci}}}}$"
        )

    else:  # olumsuzlama / De Morgan
        tip_dm = random.choice(["demorgan_and", "demorgan_or"])
        p_str = random.choice(["Hava yağmurlu", "Sınav zor", "Yol kalabalık", "Ders uzun"])
        q_str = random.choice(["Hava soğuk", "Öğrenci hazır", "Trafik var", "Öğretmen katı"])

        if tip_dm == "demorgan_and":
            soru = (
                f"De Morgan yasasına göre aşağıdaki ifadenin eşdeğerini bulunuz:\n\n"
                f"  ¬(\"{p_str}\" ∧ \"{q_str}\")"
            )
            cozum = (
                f"**De Morgan'ın 1. Yasası:**\\n"
                f"  ¬(p ∧ q) ≡ (¬p) ∨ (¬q)\\n\\n"
                f"**Uygulama:**\\n"
                f"  p = \"{p_str}\"\\n"
                f"  q = \"{q_str}\"\\n\\n"
                f"  ¬(p ∧ q) = (¬p) ∨ (¬q)\\n\\n"
                f"**Sonuç:**\\n"
                f"  \"{p_str} DEĞİL\" VEYA \"{q_str} DEĞİL\"\\n\\n"
                f"Yani: \"{p_str} değildir veya {q_str} değildir.\"\\n\\n"
                f"$\\\\boxed{{¬p ∨ ¬q}}$"
            )
        else:
            soru = (
                f"De Morgan yasasına göre aşağıdaki ifadenin eşdeğerini bulunuz:\n\n"
                f"  ¬(\"{p_str}\" ∨ \"{q_str}\")"
            )
            cozum = (
                f"**De Morgan'ın 2. Yasası:**\\n"
                f"  ¬(p ∨ q) ≡ (¬p) ∧ (¬q)\\n\\n"
                f"**Uygulama:**\\n"
                f"  p = \"{p_str}\"\\n"
                f"  q = \"{q_str}\"\\n\\n"
                f"  ¬(p ∨ q) = (¬p) ∧ (¬q)\\n\\n"
                f"**Sonuç:**\\n"
                f"  \"{p_str} DEĞİL\" VE \"{q_str} DEĞİL\"\\n\\n"
                f"Yani: \"{p_str} değildir ve {q_str} değildir.\"\\n\\n"
                f"$\\\\boxed{{¬p ∧ ¬q}}$"
            )

    return soru, cozum, "Mantık", s


# ══════════════════════════════════════════════
# 52. BİRİM DÖNÜŞÜMLERİ
# ══════════════════════════════════════════════
def gen_unit_conversion():
    s = "medium"
    tip = random.choice(["uzunluk", "agirlik", "zaman", "sicaklik"])

    if tip == "uzunluk":
        # Zincirli dönüşüm: km ↔ m ↔ cm ↔ mm
        birimler = [("km", "m", 1000), ("m", "cm", 100), ("cm", "mm", 10),
                    ("m", "km", 0.001), ("cm", "m", 0.01), ("mm", "cm", 0.1)]
        kaynak, hedef, carpan = random.choice(birimler)
        if carpan >= 1:
            miktar = round(random.uniform(0.5, 50.0), 1)
        else:
            miktar = random.randint(100, 99000)
        sonuc = round(miktar * carpan, 4)

        soru = f"{miktar} {kaynak} kaç {hedef}'dir?"
        cozum = (
            f"**Dönüşüm kuralı:** 1 {kaynak} = {carpan} {hedef}\n\n"
            f"**Hesaplama:**\n"
            f"  {miktar} {kaynak} × {carpan} = {sonuc} {hedef}\n\n"
        )
        if carpan >= 1:
            cozum += f"Büyük birimden küçük birime geçerken **çarparız**.\n\n"
        else:
            cozum += f"Küçük birimden büyük birime geçerken **böleriz** (veya küçük çarpanla çarparız).\n\n"
        cozum += f"$\\boxed{{{sonuc} \\text{{ {hedef}}}}}$"

    elif tip == "agirlik":
        birimler = [("ton", "kg", 1000), ("kg", "g", 1000), ("g", "mg", 1000),
                    ("kg", "ton", 0.001), ("g", "kg", 0.001), ("mg", "g", 0.001)]
        kaynak, hedef, carpan = random.choice(birimler)
        if carpan >= 1:
            miktar = round(random.uniform(0.5, 25.0), 1)
        else:
            miktar = random.randint(100, 50000)
        sonuc = round(miktar * carpan, 4)

        soru = f"{miktar} {kaynak} kaç {hedef}'dir?"
        cozum = (
            f"**Dönüşüm kuralı:** 1 {kaynak} = {carpan} {hedef}\n\n"
            f"**Hesaplama:**\n"
            f"  {miktar} {kaynak} × {carpan} = {sonuc} {hedef}\n\n"
            f"$\\boxed{{{sonuc} \\text{{ {hedef}}}}}$"
        )

    elif tip == "zaman":
        alt_tip = random.choice(["saat_dakika", "dakika_saniye", "saat_saniye",
                                  "dakika_saat", "saniye_dakika"])
        if alt_tip == "saat_dakika":
            saat = random.randint(1, 12)
            dk_ekstra = random.randint(0, 59)
            toplam_dk = saat * 60 + dk_ekstra
            if dk_ekstra > 0:
                soru = f"{saat} saat {dk_ekstra} dakika toplam kaç dakikadır?"
                cozum = (
                    f"**Dönüşüm:** 1 saat = 60 dakika\n\n"
                    f"**Hesaplama:**\n"
                    f"  {saat} saat = {saat} × 60 = {saat * 60} dakika\n"
                    f"  {saat * 60} + {dk_ekstra} = {toplam_dk} dakika\n\n"
                    f"$\\boxed{{{toplam_dk} \\text{{ dakika}}}}$"
                )
            else:
                soru = f"{saat} saat kaç dakikadır?"
                cozum = (
                    f"**Dönüşüm:** 1 saat = 60 dakika\n\n"
                    f"  {saat} × 60 = {toplam_dk} dakika\n\n"
                    f"$\\boxed{{{toplam_dk} \\text{{ dakika}}}}$"
                )
        elif alt_tip == "dakika_saniye":
            dk = random.randint(1, 30)
            sn_ekstra = random.randint(0, 59)
            toplam_sn = dk * 60 + sn_ekstra
            if sn_ekstra > 0:
                soru = f"{dk} dakika {sn_ekstra} saniye toplam kaç saniyedir?"
                cozum = (
                    f"**Dönüşüm:** 1 dakika = 60 saniye\n\n"
                    f"  {dk} × 60 = {dk * 60} saniye\n"
                    f"  {dk * 60} + {sn_ekstra} = {toplam_sn} saniye\n\n"
                    f"$\\boxed{{{toplam_sn} \\text{{ saniye}}}}$"
                )
            else:
                soru = f"{dk} dakika kaç saniyedir?"
                cozum = (
                    f"**Dönüşüm:** 1 dakika = 60 saniye\n\n"
                    f"  {dk} × 60 = {toplam_sn} saniye\n\n"
                    f"$\\boxed{{{toplam_sn} \\text{{ saniye}}}}$"
                )
        elif alt_tip == "saat_saniye":
            saat = random.randint(1, 5)
            toplam_sn = saat * 3600
            soru = f"{saat} saat kaç saniyedir?"
            cozum = (
                f"**Dönüşüm:** 1 saat = 60 dakika = 3600 saniye\n\n"
                f"**Hesaplama:**\n"
                f"  {saat} saat × 60 = {saat * 60} dakika\n"
                f"  {saat * 60} dakika × 60 = {toplam_sn} saniye\n\n"
                f"Veya doğrudan: {saat} × 3600 = {toplam_sn} saniye\n\n"
                f"$\\boxed{{{toplam_sn} \\text{{ saniye}}}}$"
            )
        elif alt_tip == "dakika_saat":
            toplam_dk = random.randint(61, 600)
            saat = toplam_dk // 60
            kalan_dk = toplam_dk % 60
            soru = f"{toplam_dk} dakika kaç saat kaç dakikadır?"
            cozum = (
                f"**Dönüşüm:** 60 dakika = 1 saat\n\n"
                f"**Hesaplama:**\n"
                f"  {toplam_dk} ÷ 60 = {saat} saat, kalan {kalan_dk} dakika\n\n"
                f"  Doğrulama: {saat} × 60 + {kalan_dk} = {saat * 60 + kalan_dk}  ✓\n\n"
                f"$\\boxed{{{saat} \\text{{ saat }} {kalan_dk} \\text{{ dakika}}}}$"
            )
        else:  # saniye_dakika
            toplam_sn = random.randint(61, 3600)
            dk = toplam_sn // 60
            kalan_sn = toplam_sn % 60
            soru = f"{toplam_sn} saniye kaç dakika kaç saniyedir?"
            cozum = (
                f"**Dönüşüm:** 60 saniye = 1 dakika\n\n"
                f"**Hesaplama:**\n"
                f"  {toplam_sn} ÷ 60 = {dk} dakika, kalan {kalan_sn} saniye\n\n"
                f"  Doğrulama: {dk} × 60 + {kalan_sn} = {dk * 60 + kalan_sn}  ✓\n\n"
                f"$\\boxed{{{dk} \\text{{ dakika }} {kalan_sn} \\text{{ saniye}}}}$"
            )

    else:  # sicaklik
        alt_tip = random.choice(["c_to_f", "f_to_c", "c_to_k", "k_to_c"])
        if alt_tip == "c_to_f":
            c = random.randint(-20, 100)
            f_val = round(c * 9 / 5 + 32, 1)
            soru = f"{c}°C kaç °F'dir?"
            cozum = (
                f"**Formül:** °F = °C × $\\frac{{9}}{{5}}$ + 32\n\n"
                f"**Hesaplama:**\n"
                f"  1. {c} × $\\frac{{9}}{{5}}$ = {c} × 1.8 = {round(c * 1.8, 1)}\n"
                f"  2. {round(c * 1.8, 1)} + 32 = {f_val}\n\n"
                f"$\\boxed{{{f_val}°F}}$"
            )
        elif alt_tip == "f_to_c":
            f_val = random.randint(20, 212)
            c = round((f_val - 32) * 5 / 9, 1)
            soru = f"{f_val}°F kaç °C'dir?"
            cozum = (
                f"**Formül:** °C = (°F - 32) × $\\frac{{5}}{{9}}$\n\n"
                f"**Hesaplama:**\n"
                f"  1. {f_val} - 32 = {f_val - 32}\n"
                f"  2. {f_val - 32} × $\\frac{{5}}{{9}}$ = {c}\n\n"
                f"$\\boxed{{{c}°C}}$"
            )
        elif alt_tip == "c_to_k":
            c = random.randint(-50, 100)
            k = round(c + 273.15, 2)
            soru = f"{c}°C kaç Kelvin'dir?"
            cozum = (
                f"**Formül:** K = °C + 273.15\n\n"
                f"**Hesaplama:**\n"
                f"  {c} + 273.15 = {k}\n\n"
                f"$\\boxed{{{k} \\text{{ K}}}}$"
            )
        else:  # k_to_c
            k = random.randint(200, 400)
            c = round(k - 273.15, 2)
            soru = f"{k} Kelvin kaç °C'dir?"
            cozum = (
                f"**Formül:** °C = K - 273.15\n\n"
                f"**Hesaplama:**\n"
                f"  {k} - 273.15 = {c}\n\n"
                f"$\\boxed{{{c}°C}}$"
            )

    return soru, cozum, "Birim Dönüşümleri", s


# ══════════════════════════════════════════════
# 53. SAYI SİSTEMLERİ DÖNÜŞÜMÜ
# ══════════════════════════════════════════════
def gen_number_systems():
    s = "medium"
    tip = random.choice(["dec_to_bin", "bin_to_dec", "dec_to_hex", "hex_to_dec",
                         "dec_to_oct", "oct_to_dec", "bin_to_hex", "hex_to_bin"])

    if tip == "dec_to_bin":
        n = random.randint(5, 255)
        binary = bin(n)[2:]
        soru = f"{n} sayısının ikilik (binary) tabandaki karşılığı nedir?"
        # Adım adım bölme
        adimlar = []
        temp = n
        while temp > 0:
            adimlar.append(f"  {temp} ÷ 2 = {temp // 2}, kalan = {temp % 2}")
            temp //= 2
        cozum = (
            f"**Yöntem:** Sayıyı sürekli 2'ye böl, kalanları aşağıdan yukarı oku.\n\n"
            f"**Adım adım bölme:**\n"
            + "\n".join(adimlar) + "\n\n"
            f"Kalanları aşağıdan yukarı oku: **{binary}**\n\n"
            f"**Doğrulama:** {' + '.join(f'{int(b)} × 2^{len(binary)-1-i}' for i, b in enumerate(binary) if b == '1')}"
            f" = {' + '.join(str(int(b) * 2**(len(binary)-1-i)) for i, b in enumerate(binary) if b == '1')}"
            f" = {n}  ✓\n\n"
            f"$\\boxed{{({binary})_2}}$"
        )

    elif tip == "bin_to_dec":
        n = random.randint(5, 255)
        binary = bin(n)[2:]
        soru = f"$({binary})_2$ (ikilik) sayısının onluk (decimal) karşılığı nedir?"
        adimlar = []
        for i, b in enumerate(binary):
            us = len(binary) - 1 - i
            if b == '1':
                adimlar.append(f"  {b} × 2^{us} = {int(b) * 2**us}")
            else:
                adimlar.append(f"  {b} × 2^{us} = 0")
        cozum = (
            f"**Yöntem:** Her basamak değerini 2'nin ilgili kuvvetiyle çarpıp topla.\n\n"
            f"$({binary})_2$ sayısının basamakları:\n"
            + "\n".join(adimlar) + "\n\n"
            f"**Toplam:** {' + '.join(str(int(b) * 2**(len(binary)-1-i)) for i, b in enumerate(binary))}"
            f" = {n}\n\n"
            f"$\\boxed{{{n}}}$"
        )

    elif tip == "dec_to_hex":
        n = random.randint(16, 4095)
        hexval = hex(n)[2:].upper()
        soru = f"{n} sayısının on altılık (hexadecimal) tabandaki karşılığı nedir?"
        adimlar = []
        temp = n
        hex_digits = "0123456789ABCDEF"
        while temp > 0:
            kalan = temp % 16
            adimlar.append(f"  {temp} ÷ 16 = {temp // 16}, kalan = {kalan} ({hex_digits[kalan]})")
            temp //= 16
        cozum = (
            f"**Yöntem:** Sayıyı sürekli 16'ya böl, kalanları aşağıdan yukarı oku.\n\n"
            f"**Hex basamak karşılıkları:** 0-9 = 0-9, A=10, B=11, C=12, D=13, E=14, F=15\n\n"
            f"**Adım adım bölme:**\n"
            + "\n".join(adimlar) + "\n\n"
            f"Kalanları aşağıdan yukarı oku: **{hexval}**\n\n"
            f"$\\boxed{{(\\text{{{hexval}}})_{{16}}}}$"
        )

    elif tip == "hex_to_dec":
        n = random.randint(16, 4095)
        hexval = hex(n)[2:].upper()
        soru = f"$(\\text{{{hexval}}})_{{16}}$ (hexadecimal) sayısının onluk karşılığı nedir?"
        hex_digits = "0123456789ABCDEF"
        adimlar = []
        for i, h in enumerate(hexval):
            us = len(hexval) - 1 - i
            deger = hex_digits.index(h)
            adimlar.append(f"  {h} (={deger}) × 16^{us} = {deger * 16**us}")
        cozum = (
            f"**Yöntem:** Her basamak değerini 16'ın ilgili kuvvetiyle çarpıp topla.\n\n"
            + "\n".join(adimlar) + "\n\n"
            f"**Toplam:** {' + '.join(str(hex_digits.index(h) * 16**(len(hexval)-1-i)) for i, h in enumerate(hexval))}"
            f" = {n}\n\n"
            f"$\\boxed{{{n}}}$"
        )

    elif tip == "dec_to_oct":
        n = random.randint(8, 511)
        octval = oct(n)[2:]
        soru = f"{n} sayısının sekizlik (octal) tabandaki karşılığı nedir?"
        adimlar = []
        temp = n
        while temp > 0:
            adimlar.append(f"  {temp} ÷ 8 = {temp // 8}, kalan = {temp % 8}")
            temp //= 8
        cozum = (
            f"**Yöntem:** Sayıyı sürekli 8'e böl, kalanları aşağıdan yukarı oku.\n\n"
            f"**Adım adım bölme:**\n"
            + "\n".join(adimlar) + "\n\n"
            f"Kalanları aşağıdan yukarı oku: **{octval}**\n\n"
            f"$\\boxed{{({octval})_8}}$"
        )

    elif tip == "oct_to_dec":
        n = random.randint(8, 511)
        octval = oct(n)[2:]
        soru = f"$({octval})_8$ (sekizlik) sayısının onluk karşılığı nedir?"
        adimlar = []
        for i, o in enumerate(octval):
            us = len(octval) - 1 - i
            adimlar.append(f"  {o} × 8^{us} = {int(o) * 8**us}")
        cozum = (
            f"**Yöntem:** Her basamak değerini 8'in ilgili kuvvetiyle çarpıp topla.\n\n"
            + "\n".join(adimlar) + "\n\n"
            f"**Toplam:** {' + '.join(str(int(o) * 8**(len(octval)-1-i)) for i, o in enumerate(octval))}"
            f" = {n}\n\n"
            f"$\\boxed{{{n}}}$"
        )

    elif tip == "bin_to_hex":
        n = random.randint(16, 255)
        binary = bin(n)[2:]
        hexval = hex(n)[2:].upper()
        # 4'lü gruplara ayır
        padded = binary.zfill((len(binary) + 3) // 4 * 4)
        gruplar = [padded[i:i+4] for i in range(0, len(padded), 4)]
        hex_digits = "0123456789ABCDEF"
        soru = f"$({binary})_2$ (binary) sayısının hexadecimal karşılığı nedir?"
        cozum = (
            f"**Yöntem:** Binary sayıyı sağdan 4'erli gruplara ayır, her grubu hex'e çevir.\n\n"
            f"**1. Adım – 4'lü gruplara ayır (soldan sıfırla doldur):**\n"
            f"  {binary} → {' '.join(gruplar)}\n\n"
            f"**2. Adım – Her grubu hex'e çevir:**\n"
        )
        for g in gruplar:
            deger = int(g, 2)
            cozum += f"  {g} = {deger} = {hex_digits[deger]}\n"
        cozum += (
            f"\n**Sonuç:** {''.join(hex_digits[int(g, 2)] for g in gruplar)}\n\n"
            f"$\\boxed{{(\\text{{{hexval}}})_{{16}}}}$"
        )

    else:  # hex_to_bin
        n = random.randint(16, 255)
        binary = bin(n)[2:]
        hexval = hex(n)[2:].upper()
        hex_digits = "0123456789ABCDEF"
        soru = f"$(\\text{{{hexval}}})_{{16}}$ (hexadecimal) sayısının binary karşılığı nedir?"
        cozum = (
            f"**Yöntem:** Her hex basamağını 4 bitlik binary'ye çevir.\n\n"
        )
        sonuc_bits = []
        for h in hexval:
            deger = hex_digits.index(h)
            bits = bin(deger)[2:].zfill(4)
            sonuc_bits.append(bits)
            cozum += f"  {h} (={deger}) → {bits}\n"
        full_bin = ''.join(sonuc_bits).lstrip('0') or '0'
        cozum += (
            f"\n**Sonuç:** {''.join(sonuc_bits)} = {full_bin}\n\n"
            f"$\\boxed{{({full_bin})_2}}$"
        )

    return soru, cozum, "Sayı Sistemleri", s


# ══════════════════════════════════════════════
# 54. TEMEL İSTATİSTİK / VERİ OKUMA
# ══════════════════════════════════════════════
def gen_data_reading():
    s = "medium"
    tip = random.choice(["en_yuksek", "en_dusuk", "ortalama", "toplam", "karsilastirma"])

    # Tablo verisi üret
    konular = [
        ("Ay", ["Ocak", "\u015eubat", "Mart", "Nisan", "May\u0131s", "Haziran"],
         "sat\u0131\u015f", "adet", (50, 500)),
        ("\u00dcr\u00fcn", ["Kalem", "Defter", "Silgi", "Cetvel", "Boya"],
         "fiyat", "TL", (5, 100)),
        ("\u015eehir", ["Ankara", "\u0130stanbul", "\u0130zmir", "Bursa", "Antalya", "Konya"],
         "n\u00fcfus (bin)", "bin", (200, 5000)),
        ("G\u00fcn", ["Pazartesi", "Sal\u0131", "\u00c7ar\u015famba", "Per\u015fembe", "Cuma"],
         "s\u0131cakl\u0131k", "\u00b0C", (15, 40)),
        ("\u00d6\u011frenci", ["Ali", "Ay\u015fe", "Mehmet", "Zeynep", "Can", "Elif"],
         "puan", "puan", (40, 100)),
    ]
    kategori_adi, kategoriler, olcum, birim, (lo, hi) = random.choice(konular)
    n = random.randint(4, len(kategoriler))
    secilen = random.sample(kategoriler, n)
    degerler = [random.randint(lo, hi) for _ in range(n)]

    # Tablo string'i oluştur
    tablo = f"| {kategori_adi} | {olcum.capitalize()} ({birim}) |\n"
    tablo += "|" + "-" * (len(kategori_adi) + 2) + "|" + "-" * (len(olcum) + len(birim) + 5) + "|\n"
    for kat, deg in zip(secilen, degerler):
        tablo += f"| {kat} | {deg} |\n"

    if tip == "en_yuksek":
        en_yuksek_idx = degerler.index(max(degerler))
        soru = (
            f"A\u015fa\u011f\u0131daki tabloda en y\u00fcksek {olcum} de\u011ferine sahip {kategori_adi.lower()} hangisidir?\n\n"
            + tablo
        )
        cozum = (
            f"Tablodaki t\u00fcm {olcum} de\u011ferlerini kar\u015f\u0131la\u015ft\u0131ral\u0131m:\n\n"
        )
        sirali = sorted(zip(degerler, secilen), reverse=True)
        for i, (d, k) in enumerate(sirali):
            isaret = " \u2190 en y\u00fcksek" if i == 0 else ""
            cozum += f"  {k}: {d} {birim}{isaret}\n"
        cozum += (
            f"\nEn y\u00fcksek {olcum}: **{secilen[en_yuksek_idx]}** ({max(degerler)} {birim})\n\n"
            f"$\\boxed{{\\text{{{secilen[en_yuksek_idx]}}} = {max(degerler)} \\text{{ {birim}}}}}$"
        )

    elif tip == "en_dusuk":
        en_dusuk_idx = degerler.index(min(degerler))
        soru = (
            f"A\u015fa\u011f\u0131daki tabloda en d\u00fc\u015f\u00fck {olcum} de\u011ferine sahip {kategori_adi.lower()} hangisidir?\n\n"
            + tablo
        )
        cozum = (
            f"Tablodaki t\u00fcm {olcum} de\u011ferlerini kar\u015f\u0131la\u015ft\u0131ral\u0131m:\n\n"
        )
        sirali = sorted(zip(degerler, secilen))
        for i, (d, k) in enumerate(sirali):
            isaret = " \u2190 en d\u00fc\u015f\u00fck" if i == 0 else ""
            cozum += f"  {k}: {d} {birim}{isaret}\n"
        cozum += (
            f"\nEn d\u00fc\u015f\u00fck {olcum}: **{secilen[en_dusuk_idx]}** ({min(degerler)} {birim})\n\n"
            f"$\\boxed{{\\text{{{secilen[en_dusuk_idx]}}} = {min(degerler)} \\text{{ {birim}}}}}$"
        )

    elif tip == "ortalama":
        toplam = sum(degerler)
        ort = toplam / n
        soru = (
            f"A\u015fa\u011f\u0131daki tablodaki {olcum} de\u011ferlerinin ortalamas\u0131 ka\u00e7t\u0131r?\n\n"
            + tablo
        )
        cozum = (
            f"**Ortalama = Toplam \u00f7 Say\u0131 adedi**\n\n"
            f"**1. Ad\u0131m \u2013 T\u00fcm de\u011ferleri topla:**\n"
            f"  {' + '.join(map(str, degerler))} = {toplam}\n\n"
            f"**2. Ad\u0131m \u2013 Say\u0131 adedine b\u00f6l:**\n"
            f"  {toplam} \u00f7 {n} = {ort:.2f}\n\n"
            f"$\\boxed{{{ort:.2f} \\text{{ {birim}}}}}$"
        )

    elif tip == "toplam":
        toplam = sum(degerler)
        soru = (
            f"A\u015fa\u011f\u0131daki tablodaki t\u00fcm {olcum} de\u011ferlerinin toplam\u0131 ka\u00e7t\u0131r?\n\n"
            + tablo
        )
        cozum = (
            f"T\u00fcm de\u011ferleri toplayal\u0131m:\n\n"
        )
        ara_toplam = 0
        for i, (k, d) in enumerate(zip(secilen, degerler)):
            ara_toplam += d
            if i == 0:
                cozum += f"  {d}"
            else:
                cozum += f" + {d} = {ara_toplam}"
        cozum += (
            f"\n\nToplam {olcum}: **{toplam} {birim}**\n\n"
            f"$\\boxed{{{toplam} \\text{{ {birim}}}}}$"
        )

    else:  # karsilastirma
        if n < 2:
            # Fallback: en az 2 eleman
            n = 2
            secilen = random.sample(kategoriler, n)
            degerler = [random.randint(lo, hi) for _ in range(n)]
        idx1, idx2 = random.sample(range(n), 2)
        fark = abs(degerler[idx1] - degerler[idx2])
        buyuk = secilen[idx1] if degerler[idx1] > degerler[idx2] else secilen[idx2]
        soru = (
            f"A\u015fa\u011f\u0131daki tabloda {secilen[idx1]} ile {secilen[idx2]} aras\u0131ndaki "
            f"{olcum} fark\u0131 ka\u00e7t\u0131r?\n\n"
            + tablo
        )
        cozum = (
            f"\u0130ki de\u011fer aras\u0131ndaki fark\u0131 bulal\u0131m:\n\n"
            f"  {secilen[idx1]}: {degerler[idx1]} {birim}\n"
            f"  {secilen[idx2]}: {degerler[idx2]} {birim}\n\n"
            f"  Fark = |{degerler[idx1]} - {degerler[idx2]}| = {fark} {birim}\n\n"
            f"  {buyuk} daha y\u00fcksek de\u011fere sahiptir.\n\n"
            f"$\\boxed{{{fark} \\text{{ {birim}}}}}$"
        )

    return soru, cozum, "Veri Okuma", s


# ══════════════════════════════════════════════
# 57. TEMEL FİZİK
# ══════════════════════════════════════════════
def gen_basic_physics():
    s = "medium"
    tip = random.choice(["newton", "ohm", "serbest_dusme", "is_enerji", "yogunluk"])

    if tip == "newton":
        # F = m * a
        alt_tip = random.choice(["kuvvet", "kutle", "ivme"])
        if alt_tip == "kuvvet":
            m = random.randint(2, 50)
            a = random.randint(2, 20)
            F = m * a
            soru = f"Kütlesi {m} kg olan bir cisme {a} m/s² ivme uygulanıyor. Cisme etkiyen net kuvvet kaç Newton'dur?"
            cozum = (
                f"**Newton'un 2. Hareket Yasası:** $F = m \\times a$\n\n"
                f"Verilen bilgiler:\n"
                f"  • Kütle ($m$) = {m} kg\n"
                f"  • İvme ($a$) = {a} m/s²\n\n"
                f"**Hesaplama:**\n"
                f"  $F = {m} \\times {a} = {F}$ N\n\n"
                f"**Birim kontrol:** kg × m/s² = N (Newton)  ✓\n\n"
                f"$\\boxed{{{F} \\text{{ N}}}}$"
            )
        elif alt_tip == "kutle":
            m = random.randint(2, 50)
            a = random.randint(2, 20)
            F = m * a
            soru = f"Bir cisme {F} N kuvvet uygulandığında {a} m/s² ivme kazanıyor. Cismin kütlesi kaç kg'dır?"
            cozum = (
                f"**Formül:** $F = m \\times a$ → $m = \\frac{{F}}{{a}}$\n\n"
                f"Verilen bilgiler:\n"
                f"  • Kuvvet ($F$) = {F} N\n"
                f"  • İvme ($a$) = {a} m/s²\n\n"
                f"**Hesaplama:**\n"
                f"  $m = \\frac{{{F}}}{{{a}}} = {m}$ kg\n\n"
                f"**Doğrulama:** ${m} \\times {a} = {F}$ N  ✓\n\n"
                f"$\\boxed{{{m} \\text{{ kg}}}}$"
            )
        else:  # ivme
            m = random.randint(2, 50)
            a = random.randint(2, 20)
            F = m * a
            soru = f"{m} kg kütleli bir cisme {F} N kuvvet uygulanıyor. Cismin ivmesi kaç m/s²'dir?"
            cozum = (
                f"**Formül:** $F = m \\times a$ → $a = \\frac{{F}}{{m}}$\n\n"
                f"Verilen bilgiler:\n"
                f"  • Kuvvet ($F$) = {F} N\n"
                f"  • Kütle ($m$) = {m} kg\n\n"
                f"**Hesaplama:**\n"
                f"  $a = \\frac{{{F}}}{{{m}}} = {a}$ m/s²\n\n"
                f"$\\boxed{{{a} \\text{{ m/s²}}}}$"
            )

    elif tip == "ohm":
        # V = I * R (Ohm Yasası)
        alt_tip = random.choice(["gerilim", "akim", "direnc"])
        if alt_tip == "gerilim":
            I = random.choice([0.5, 1, 1.5, 2, 2.5, 3, 4, 5])
            R = random.randint(2, 100)
            V = round(I * R, 1)
            soru = f"Bir devrede akım {I} A ve direnç {R} Ω ise gerilim kaç Volt'tur?"
            cozum = (
                f"**Ohm Yasası:** $V = I \\times R$\n\n"
                f"Verilen bilgiler:\n"
                f"  • Akım ($I$) = {I} A (Amper)\n"
                f"  • Direnç ($R$) = {R} Ω (Ohm)\n\n"
                f"**Hesaplama:**\n"
                f"  $V = {I} \\times {R} = {V}$ V\n\n"
                f"**Birim kontrol:** A × Ω = V (Volt)  ✓\n\n"
                f"$\\boxed{{{V} \\text{{ V}}}}$"
            )
        elif alt_tip == "akim":
            I = random.choice([0.5, 1, 1.5, 2, 2.5, 3, 4, 5])
            R = random.randint(2, 100)
            V = round(I * R, 1)
            soru = f"Bir devrede gerilim {V} V ve direnç {R} Ω ise akım kaç Amper'dir?"
            cozum = (
                f"**Ohm Yasası:** $V = I \\times R$ → $I = \\frac{{V}}{{R}}$\n\n"
                f"Verilen bilgiler:\n"
                f"  • Gerilim ($V$) = {V} V\n"
                f"  • Direnç ($R$) = {R} Ω\n\n"
                f"**Hesaplama:**\n"
                f"  $I = \\frac{{{V}}}{{{R}}} = {I}$ A\n\n"
                f"$\\boxed{{{I} \\text{{ A}}}}$"
            )
        else:  # direnc
            I = random.choice([0.5, 1, 1.5, 2, 2.5, 3, 4, 5])
            R = random.randint(2, 100)
            V = round(I * R, 1)
            soru = f"Bir devrede gerilim {V} V ve akım {I} A ise direnç kaç Ohm'dur?"
            cozum = (
                f"**Ohm Yasası:** $V = I \\times R$ → $R = \\frac{{V}}{{I}}$\n\n"
                f"Verilen bilgiler:\n"
                f"  • Gerilim ($V$) = {V} V\n"
                f"  • Akım ($I$) = {I} A\n\n"
                f"**Hesaplama:**\n"
                f"  $R = \\frac{{{V}}}{{{I}}} = {R}$ Ω\n\n"
                f"$\\boxed{{{R} \\text{{ Ω}}}}$"
            )

    elif tip == "serbest_dusme":
        # g = 10 m/s² (kolaylık için)
        g = 10
        alt_tip = random.choice(["yukseklik", "hiz", "sure"])

        if alt_tip == "yukseklik":
            # h = (1/2) * g * t^2
            t = random.randint(1, 8)
            h = g * t * t // 2
            soru = (
                f"Bir cisim serbest bırakılıyor ($g = {g}$ m/s², başlangıç hızı = 0). "
                f"{t} saniye sonra ne kadar düşmüş olur?"
            )
            cozum = (
                f"**Serbest düşme formülü:** $h = \\frac{{1}}{{2}} g t^2$\n\n"
                f"Verilen bilgiler:\n"
                f"  • $g = {g}$ m/s² (yerçekimi ivmesi)\n"
                f"  • $t = {t}$ s (süre)\n"
                f"  • $v_0 = 0$ (başlangıç hızı)\n\n"
                f"**Hesaplama:**\n"
                f"  $h = \\frac{{1}}{{2}} \\times {g} \\times {t}^2$\n"
                f"  $= \\frac{{1}}{{2}} \\times {g} \\times {t*t}$\n"
                f"  $= {g//2} \\times {t*t}$\n"
                f"  $= {h}$ m\n\n"
                f"$\\boxed{{{h} \\text{{ m}}}}$"
            )

        elif alt_tip == "hiz":
            # v = g * t
            t = random.randint(1, 10)
            v = g * t
            soru = (
                f"Serbest düşen bir cismin {t} saniye sonundaki hızı kaç m/s'dir? "
                f"($g = {g}$ m/s², $v_0 = 0$)"
            )
            cozum = (
                f"**Formül:** $v = v_0 + g \\times t$\n\n"
                f"$v_0 = 0$ (başlangıç hızı) olduğundan:\n\n"
                f"  $v = 0 + {g} \\times {t} = {v}$ m/s\n\n"
                f"Cisim {t} saniye sonunda **{v} m/s** hıza ulaşır.\n\n"
                f"$\\boxed{{{v} \\text{{ m/s}}}}$"
            )

        else:  # sure
            # t = sqrt(2h/g)
            t = random.randint(2, 8)
            h = g * t * t // 2
            soru = (
                f"{h} metre yükseklikten serbest bırakılan bir cisim kaç saniyede yere ulaşır? "
                f"($g = {g}$ m/s²)"
            )
            cozum = (
                f"**Formül:** $h = \\frac{{1}}{{2}} g t^2$ → $t = \\sqrt{{\\frac{{2h}}{{g}}}}$\n\n"
                f"Verilen bilgiler:\n"
                f"  • $h = {h}$ m\n"
                f"  • $g = {g}$ m/s²\n\n"
                f"**Hesaplama:**\n"
                f"  $t = \\sqrt{{\\frac{{2 \\times {h}}}{{{g}}}}}$\n"
                f"  $= \\sqrt{{\\frac{{{2*h}}}{{{g}}}}}$\n"
                f"  $= \\sqrt{{{2*h//g}}}$\n"
                f"  $= {t}$ s\n\n"
                f"**Doğrulama:** $h = \\frac{{1}}{{2}} \\times {g} \\times {t}^2 = {h}$ m  ✓\n\n"
                f"$\\boxed{{{t} \\text{{ s}}}}$"
            )

    elif tip == "is_enerji":
        # W = F * d
        alt_tip = random.choice(["is", "kuvvet", "mesafe"])
        F = random.randint(10, 200)
        d = random.randint(2, 50)
        W = F * d

        if alt_tip == "is":
            soru = (
                f"Bir cisme {F} N kuvvet uygulanarak {d} metre boyunca taşınıyor. "
                f"Yapılan iş kaç Joule'dür?"
            )
            cozum = (
                f"**İş Formülü:** $W = F \\times d$ (kuvvet, yer değiştirme yönünde)\n\n"
                f"Verilen bilgiler:\n"
                f"  • Kuvvet ($F$) = {F} N\n"
                f"  • Mesafe ($d$) = {d} m\n\n"
                f"**Hesaplama:**\n"
                f"  $W = {F} \\times {d} = {W}$ J\n\n"
                f"**Birim kontrol:** N × m = J (Joule)  ✓\n\n"
                f"$\\boxed{{{W} \\text{{ J}}}}$"
            )
        elif alt_tip == "kuvvet":
            soru = (
                f"Bir cisim {d} metre taşınıyor ve toplam {W} J iş yapılıyor. "
                f"Uygulanan kuvvet kaç Newton'dur?"
            )
            cozum = (
                f"**Formül:** $W = F \\times d$ → $F = \\frac{{W}}{{d}}$\n\n"
                f"  $F = \\frac{{{W}}}{{{d}}} = {F}$ N\n\n"
                f"$\\boxed{{{F} \\text{{ N}}}}$"
            )
        else:  # mesafe
            soru = (
                f"{F} N kuvvetle {W} J iş yapılıyor. "
                f"Cisim kaç metre taşınmıştır?"
            )
            cozum = (
                f"**Formül:** $W = F \\times d$ → $d = \\frac{{W}}{{F}}$\n\n"
                f"  $d = \\frac{{{W}}}{{{F}}} = {d}$ m\n\n"
                f"$\\boxed{{{d} \\text{{ m}}}}$"
            )

    else:  # yogunluk
        # ρ = m / V
        alt_tip = random.choice(["yogunluk", "kutle", "hacim"])
        maddeler = [
            ("Su", 1.0), ("Buz", 0.92), ("Demir", 7.87), ("Alüminyum", 2.70),
            ("Bakır", 8.96), ("Altın", 19.3), ("Ahşap", 0.6), ("Cam", 2.5),
            ("Beton", 2.4), ("Kurşun", 11.3),
        ]
        madde, rho = random.choice(maddeler)
        V = random.choice([2, 3, 4, 5, 10, 15, 20, 25, 50, 100])
        m = round(rho * V, 1)

        if alt_tip == "yogunluk":
            soru = (
                f"Kütlesi {m} g ve hacmi {V} cm³ olan bir maddenin yoğunluğu nedir? "
                f"Bu madde ne olabilir?"
            )
            cozum = (
                f"**Yoğunluk Formülü:** $\\rho = \\frac{{m}}{{V}}$\n\n"
                f"Verilen bilgiler:\n"
                f"  • Kütle ($m$) = {m} g\n"
                f"  • Hacim ($V$) = {V} cm³\n\n"
                f"**Hesaplama:**\n"
                f"  $\\rho = \\frac{{{m}}}{{{V}}} = {rho}$ g/cm³\n\n"
                f"Bu yoğunluk **{madde}** ile eşleşmektedir.\n\n"
                f"**Bilgi:** Yoğunluğu 1 g/cm³'den büyük maddeler suda batar, küçük olanlar yüzer.\n"
                f"{madde} suda {'batar' if rho > 1 else 'yüzer'}.\n\n"
                f"$\\boxed{{{rho} \\text{{ g/cm³}}}}$"
            )
        elif alt_tip == "kutle":
            soru = (
                f"Yoğunluğu {rho} g/cm³ olan {madde}'dan {V} cm³ alındığında kütlesi kaç gram olur?"
            )
            cozum = (
                f"**Formül:** $\\rho = \\frac{{m}}{{V}}$ → $m = \\rho \\times V$\n\n"
                f"  $m = {rho} \\times {V} = {m}$ g\n\n"
                f"$\\boxed{{{m} \\text{{ g}}}}$"
            )
        else:  # hacim
            soru = (
                f"{m} gram {madde}'nin hacmi kaç cm³'tür? "
                f"({madde}'nin yoğunluğu: {rho} g/cm³)"
            )
            cozum = (
                f"**Formül:** $\\rho = \\frac{{m}}{{V}}$ → $V = \\frac{{m}}{{\\rho}}$\n\n"
                f"  $V = \\frac{{{m}}}{{{rho}}} = {V}$ cm³\n\n"
                f"$\\boxed{{{V} \\text{{ cm³}}}}$"
            )

    return soru, cozum, "Temel Fizik", s


# ══════════════════════════════════════════════
# TÜYO: Generator listesi (ağırlıklı)
# ══════════════════════════════════════════════


# ══════════════════════════════════════════════
# 55. ZAMAN HESABI
# ══════════════════════════════════════════════
def gen_time_calculation():
    s = "medium"

    tip = random.choice(["tarih_ekleme", "saat_ekleme", "tarih_farki", "gun_hesabi"])

    ay_isimleri = {
        1: "Ocak", 2: "\u015eubat", 3: "Mart", 4: "Nisan", 5: "May\u0131s", 6: "Haziran",
        7: "Temmuz", 8: "A\u011fustos", 9: "Eyl\u00fcl", 10: "Ekim", 11: "Kas\u0131m", 12: "Aral\u0131k"
    }
    gun_isimleri = {
        0: "Pazartesi", 1: "Sal\u0131", 2: "\u00c7ar\u015famba",
        3: "Per\u015fembe", 4: "Cuma", 5: "Cumartesi", 6: "Pazar"
    }

    if tip == "tarih_ekleme":
        yil = random.randint(2020, 2026)
        ay = random.randint(1, 12)
        max_gun = calendar.monthrange(yil, ay)[1]
        gun = random.randint(1, max_gun)
        eklenen_gun = random.randint(10, 90)
        yon = random.choice(["sonra", "\u00f6nce"])

        baslangic = datetime(yil, ay, gun)
        if yon == "sonra":
            bitis = baslangic + timedelta(days=eklenen_gun)
        else:
            bitis = baslangic - timedelta(days=eklenen_gun)

        soru = (
            f"{gun} {ay_isimleri[ay]} {yil} tarihinden {eklenen_gun} g\u00fcn {yon} "
            f"hangi tarihtir?"
        )

        # Ad\u0131m ad\u0131m g\u00f6ster
        cozum = (
            f"**Ba\u015flang\u0131\u00e7 tarihi:** {gun} {ay_isimleri[ay]} {yil}\n\n"
            f"**{eklenen_gun} g\u00fcn {yon}** hesaplayal\u0131m.\n\n"
        )

        if yon == "sonra":
            kalan = eklenen_gun
            temp_date = baslangic
            adim = 1
            while kalan > 0:
                temp_yil = temp_date.year
                temp_ay = temp_date.month
                temp_gun = temp_date.day
                ay_sonu = calendar.monthrange(temp_yil, temp_ay)[1]
                kalan_ay_gun = ay_sonu - temp_gun
                if kalan <= kalan_ay_gun:
                    temp_date = temp_date + timedelta(days=kalan)
                    cozum += f"  **Ad\u0131m {adim}:** {kalan} g\u00fcn ileri \u2192 {temp_date.day} {ay_isimleri[temp_date.month]} {temp_date.year}\n"
                    kalan = 0
                else:
                    kalan -= (kalan_ay_gun + 1)
                    sonraki_ay_ilk = datetime(temp_yil if temp_ay < 12 else temp_yil + 1,
                                               temp_ay + 1 if temp_ay < 12 else 1, 1)
                    cozum += f"  **Ad\u0131m {adim}:** {kalan_ay_gun + 1} g\u00fcn ileri ({ay_isimleri[temp_ay]} sonu) \u2192 1 {ay_isimleri[sonraki_ay_ilk.month]} {sonraki_ay_ilk.year} (kalan: {kalan} g\u00fcn)\n"
                    temp_date = sonraki_ay_ilk
                    adim += 1
        else:
            kalan = eklenen_gun
            temp_date = baslangic
            adim = 1
            while kalan > 0:
                temp_gun = temp_date.day
                if kalan < temp_gun:
                    temp_date = temp_date - timedelta(days=kalan)
                    cozum += f"  **Ad\u0131m {adim}:** {kalan} g\u00fcn geri \u2192 {temp_date.day} {ay_isimleri[temp_date.month]} {temp_date.year}\n"
                    kalan = 0
                else:
                    kalan -= temp_gun
                    onceki_ay_son = temp_date - timedelta(days=temp_gun)
                    cozum += f"  **Ad\u0131m {adim}:** {temp_gun} g\u00fcn geri (ay ba\u015f\u0131na) \u2192 {onceki_ay_son.day} {ay_isimleri[onceki_ay_son.month]} {onceki_ay_son.year} (kalan: {kalan} g\u00fcn)\n"
                    temp_date = onceki_ay_son
                    adim += 1

        cozum += (
            f"\n**Sonu\u00e7:** {bitis.day} {ay_isimleri[bitis.month]} {bitis.year}"
            f" ({gun_isimleri[bitis.weekday()]})\n\n"
            f"$\\boxed{{{bitis.day} \\text{{ {ay_isimleri[bitis.month]} }} {bitis.year}}}$"
        )

    elif tip == "saat_ekleme":
        saat = random.randint(0, 23)
        dakika = random.randint(0, 59)
        ek_saat = random.randint(1, 8)
        ek_dk = random.randint(5, 55)
        yon = random.choice(["sonra", "\u00f6nce"])

        baslangic_dk = saat * 60 + dakika
        eklenen_dk = ek_saat * 60 + ek_dk

        if yon == "sonra":
            toplam_dk = baslangic_dk + eklenen_dk
        else:
            toplam_dk = baslangic_dk - eklenen_dk

        # Normalize (24 saatlik sistem)
        toplam_dk = toplam_dk % (24 * 60)
        sonuc_saat = toplam_dk // 60
        sonuc_dk = toplam_dk % 60

        soru = (
            f"Saat {saat:02d}:{dakika:02d}'ten {ek_saat} saat {ek_dk} dakika {yon} "
            f"saat ka\u00e7t\u0131r?"
        )

        # Dakikalar\u0131 topla
        ara_dk = dakika + ek_dk if yon == "sonra" else dakika - ek_dk
        elde_saat = 0
        if yon == "sonra":
            if ara_dk >= 60:
                elde_saat = ara_dk // 60
                ara_dk_kalan = ara_dk % 60
            else:
                ara_dk_kalan = ara_dk
            yeni_saat = (saat + ek_saat + elde_saat) % 24
        else:
            if ara_dk < 0:
                elde_saat = 1
                ara_dk_kalan = ara_dk + 60
            else:
                ara_dk_kalan = ara_dk
            yeni_saat = (saat - ek_saat - elde_saat) % 24

        cozum = (
            f"**1. Ad\u0131m \u2013 Dakikalar\u0131 hesapla:**\n"
            f"  {dakika} {'+ ' if yon == 'sonra' else '- '}{ek_dk} = {ara_dk} dakika\n"
        )
        if yon == "sonra" and ara_dk >= 60:
            cozum += f"  {ara_dk} \u2265 60 \u2192 {ara_dk_kalan} dakika + {elde_saat} saat elde\n"
        elif yon == "\u00f6nce" and dakika - ek_dk < 0:
            cozum += f"  {ara_dk} < 0 \u2192 {ara_dk_kalan} dakika (bir \u00f6nceki saatten 60 dakika ald\u0131k)\n"
        cozum += (
            f"\n**2. Ad\u0131m \u2013 Saatleri hesapla:**\n"
            f"  {saat} {'+ ' if yon == 'sonra' else '- '}{ek_saat}"
            + (f" + {elde_saat} (elde)" if elde_saat > 0 and yon == "sonra" else "")
            + (f" - {elde_saat} (bor\u00e7)" if elde_saat > 0 and yon == "\u00f6nce" else "")
            + f" = {yeni_saat} saat\n\n"
            f"**Sonu\u00e7:** {sonuc_saat:02d}:{sonuc_dk:02d}\n\n"
            f"$\\boxed{{{sonuc_saat:02d}:{sonuc_dk:02d}}}$"
        )

    elif tip == "tarih_farki":
        yil = random.randint(2020, 2026)
        ay1 = random.randint(1, 10)
        gun1 = random.randint(1, 28)
        tarih1 = datetime(yil, ay1, gun1)
        fark_gun = random.randint(15, 120)
        tarih2 = tarih1 + timedelta(days=fark_gun)

        soru = (
            f"{gun1} {ay_isimleri[ay1]} {yil} ile "
            f"{tarih2.day} {ay_isimleri[tarih2.month]} {tarih2.year} aras\u0131nda ka\u00e7 g\u00fcn vard\u0131r?"
        )

        cozum = (
            f"\u0130ki tarih aras\u0131ndaki g\u00fcn fark\u0131n\u0131 ay ay hesaplayal\u0131m:\n\n"
        )
        temp = tarih1
        toplam = 0
        adim = 1
        while temp.month != tarih2.month or temp.year != tarih2.year:
            ay_sonu = calendar.monthrange(temp.year, temp.month)[1]
            kalan_gun = ay_sonu - temp.day
            if temp.month == tarih1.month and temp.year == tarih1.year:
                kalan_gun = ay_sonu - temp.day
            else:
                kalan_gun = ay_sonu
                temp = datetime(temp.year, temp.month, 1)
            sonraki = datetime(temp.year if temp.month < 12 else temp.year + 1,
                               temp.month + 1 if temp.month < 12 else 1, 1)
            gun_sayisi = (sonraki - temp).days
            cozum += f"  **Ad\u0131m {adim}:** {ay_isimleri[temp.month]} {temp.year}: {gun_sayisi - (temp.day - 1) if adim == 1 else gun_sayisi} g\u00fcn\n"
            toplam += gun_sayisi - (temp.day - 1) if adim == 1 else gun_sayisi
            temp = sonraki
            adim += 1
        # Son ay\u0131n g\u00fcnleri
        if tarih2.day > 0:
            cozum += f"  **Ad\u0131m {adim}:** {ay_isimleri[tarih2.month]} {tarih2.year}: {tarih2.day} g\u00fcn\n"
            toplam += tarih2.day

        cozum += (
            f"\n**Toplam:** {fark_gun} g\u00fcn\n\n"
            f"$\\boxed{{{fark_gun} \\text{{ g\u00fcn}}}}$"
        )

    else:  # gun_hesabi
        # "X ay\u0131n\u0131n ka\u00e7 g\u00fcn\u00fc var?" veya "Y y\u0131l art\u0131k y\u0131l m\u0131?"
        alt_tip = random.choice(["ay_gunu", "artik_yil"])
        if alt_tip == "ay_gunu":
            yil = random.randint(2020, 2028)
            ay = random.randint(1, 12)
            gun_sayisi = calendar.monthrange(yil, ay)[1]
            artik = calendar.isleap(yil)

            soru = f"{yil} y\u0131l\u0131n\u0131n {ay_isimleri[ay]} ay\u0131 ka\u00e7 g\u00fcnd\u00fcr?"
            cozum = (
                f"**Ay g\u00fcn say\u0131lar\u0131 tablosu:**\n"
                f"  Ocak: 31 | \u015eubat: {'29 (art\u0131k y\u0131l)' if artik else '28'} | Mart: 31 | Nisan: 30\n"
                f"  May\u0131s: 31 | Haziran: 30 | Temmuz: 31 | A\u011fustos: 31\n"
                f"  Eyl\u00fcl: 30 | Ekim: 31 | Kas\u0131m: 30 | Aral\u0131k: 31\n\n"
            )
            if ay == 2:
                cozum += (
                    f"**Art\u0131k y\u0131l kontrol\u00fc ({yil}):**\n"
                    f"  {yil} \u00f7 4 = {yil/4:.1f} \u2192 {'tam b\u00f6l\u00fcn\u00fcr' if yil % 4 == 0 else 'tam b\u00f6l\u00fcnmez'}\n"
                )
                if yil % 100 == 0:
                    cozum += f"  {yil} \u00f7 100 = {yil/100:.0f} \u2192 y\u00fczy\u0131l s\u0131n\u0131r\u0131, 400'e de b\u00f6l\u00fcnmeli\n"
                    cozum += f"  {yil} \u00f7 400 = {yil/400:.2f} \u2192 {'tam b\u00f6l\u00fcn\u00fcr' if yil % 400 == 0 else 'tam b\u00f6l\u00fcnmez'}\n"
                cozum += f"  \u2234 {yil} {'art\u0131k y\u0131ld\u0131r' if artik else 'art\u0131k y\u0131l de\u011fildir'} \u2192 \u015eubat = {gun_sayisi} g\u00fcn\n\n"
            cozum += f"$\\boxed{{{gun_sayisi} \\text{{ g\u00fcn}}}}$"

        else:  # artik_yil
            yil = random.choice([1900, 2000, 2020, 2024, 2023, 2100, 2400, 1996, 2004, 2025])
            artik = calendar.isleap(yil)
            soru = f"{yil} y\u0131l\u0131 art\u0131k y\u0131l m\u0131d\u0131r?"
            cozum = (
                f"**Art\u0131k y\u0131l kurallar\u0131:**\n"
                f"  1. 4'e tam b\u00f6l\u00fcn\u00fcyorsa \u2192 art\u0131k y\u0131l **aday\u0131**\n"
                f"  2. 100'e tam b\u00f6l\u00fcn\u00fcyorsa \u2192 art\u0131k y\u0131l **de\u011fildir** (istisna: kural 3)\n"
                f"  3. 400'e tam b\u00f6l\u00fcn\u00fcyorsa \u2192 art\u0131k y\u0131l**d\u0131r**\n\n"
                f"**{yil} y\u0131l\u0131 i\u00e7in kontrol:**\n"
                f"  {yil} \u00f7 4 = {yil / 4:.1f} \u2192 {'tam b\u00f6l\u00fcn\u00fcr \u2713' if yil % 4 == 0 else 'tam b\u00f6l\u00fcnmez \u2717'}\n"
            )
            if yil % 4 == 0:
                cozum += f"  {yil} \u00f7 100 = {yil / 100:.1f} \u2192 {'tam b\u00f6l\u00fcn\u00fcr' if yil % 100 == 0 else 'tam b\u00f6l\u00fcnmez'}\n"
                if yil % 100 == 0:
                    cozum += f"  {yil} \u00f7 400 = {yil / 400:.1f} \u2192 {'tam b\u00f6l\u00fcn\u00fcr \u2713' if yil % 400 == 0 else 'tam b\u00f6l\u00fcnmez \u2717'}\n"
            cozum += (
                f"\n**Sonu\u00e7:** {yil} {'art\u0131k y\u0131ld\u0131r (\u015eubat = 29 g\u00fcn)' if artik else 'art\u0131k y\u0131l de\u011fildir (\u015eubat = 28 g\u00fcn)'}\n\n"
                f"$\\boxed{{\\text{{{('Evet' if artik else 'Hay\u0131r')}}}}}$"
            )

    return soru, cozum, "Zaman Hesabı", s



# ══════════════════════════════════════════════
# 56. TEMEL KİMYA
# ══════════════════════════════════════════════
def gen_basic_chemistry():
    s = "medium"
    tip = random.choice(["mol_hesabi", "denklem_denklestirme", "periyodik_tablo"])

    # Sık kullanılan elementler ve mol kütleleri (g/mol)
    ELEMENTLER = {
        "H": ("Hidrojen", 1, 1.008),
        "He": ("Helyum", 2, 4.003),
        "C": ("Karbon", 6, 12.011),
        "N": ("Azot", 7, 14.007),
        "O": ("Oksijen", 8, 15.999),
        "Na": ("Sodyum", 11, 22.990),
        "Mg": ("Magnezyum", 12, 24.305),
        "Al": ("Alüminyum", 13, 26.982),
        "Si": ("Silisyum", 14, 28.086),
        "P": ("Fosfor", 15, 30.974),
        "S": ("Kükürt", 16, 32.065),
        "Cl": ("Klor", 17, 35.453),
        "K": ("Potasyum", 19, 39.098),
        "Ca": ("Kalsiyum", 20, 40.078),
        "Fe": ("Demir", 26, 55.845),
        "Cu": ("Bakır", 29, 63.546),
        "Zn": ("Çinko", 30, 65.380),
        "Ag": ("Gümüş", 47, 107.868),
        "Au": ("Altın", 79, 196.967),
        "Pb": ("Kurşun", 82, 207.200),
    }

    # Yaygın bileşikler: (formül, isim, mol kütlesi)
    BILESIKLER = [
        ("H₂O", "Su", 18.015),
        ("CO₂", "Karbondioksit", 44.009),
        ("NaCl", "Sodyum klorür (yemek tuzu)", 58.443),
        ("H₂SO₄", "Sülfürik asit", 98.079),
        ("NaOH", "Sodyum hidroksit", 39.997),
        ("CaCO₃", "Kalsiyum karbonat", 100.087),
        ("Fe₂O₃", "Demir(III) oksit", 159.688),
        ("C₆H₁₂O₆", "Glikoz", 180.156),
        ("NH₃", "Amonyak", 17.031),
        ("HCl", "Hidroklorik asit", 36.461),
        ("CH₄", "Metan", 16.043),
        ("C₂H₅OH", "Etanol", 46.069),
        ("MgO", "Magnezyum oksit", 40.304),
        ("Al₂O₃", "Alüminyum oksit", 101.961),
        ("KOH", "Potasyum hidroksit", 56.106),
    ]

    AVOGADRO = 6.022e23

    if tip == "mol_hesabi":
        alt_tip = random.choice(["kutle_to_mol", "mol_to_kutle", "mol_to_tanecik", "tanecik_to_mol"])
        formul, isim, mol_kutlesi = random.choice(BILESIKLER)

        if alt_tip == "kutle_to_mol":
            mol_sayi = random.choice([0.5, 1, 1.5, 2, 2.5, 3, 4, 5])
            kutle = round(mol_sayi * mol_kutlesi, 2)
            soru = f"{kutle} gram {isim} ({formul}) kaç moldür?"
            cozum = (
                f"**Formül:** $n = \\frac{{m}}{{M}}$\n\n"
                f"Burada:\n"
                f"  • $m$ = kütle = {kutle} g\n"
                f"  • $M$ = mol kütlesi = {mol_kutlesi} g/mol\n\n"
                f"**Hesaplama:**\n"
                f"  $n = \\frac{{{kutle}}}{{{mol_kutlesi}}} = {mol_sayi}$ mol\n\n"
                f"Yani {kutle} gram {isim}, **{mol_sayi} mol**'dür.\n\n"
                f"$\\boxed{{{mol_sayi} \\text{{ mol}}}}$"
            )

        elif alt_tip == "mol_to_kutle":
            mol_sayi = random.choice([0.25, 0.5, 1, 1.5, 2, 3, 4, 5])
            kutle = round(mol_sayi * mol_kutlesi, 2)
            soru = f"{mol_sayi} mol {isim} ({formul}) kaç gramdır?"
            cozum = (
                f"**Formül:** $m = n \\times M$\n\n"
                f"Burada:\n"
                f"  • $n$ = mol sayısı = {mol_sayi} mol\n"
                f"  • $M$ = mol kütlesi = {mol_kutlesi} g/mol\n\n"
                f"**Hesaplama:**\n"
                f"  $m = {mol_sayi} \\times {mol_kutlesi} = {kutle}$ g\n\n"
                f"$\\boxed{{{kutle} \\text{{ g}}}}$"
            )

        elif alt_tip == "mol_to_tanecik":
            mol_sayi = random.choice([0.5, 1, 2, 3, 5])
            tanecik = mol_sayi * AVOGADRO
            soru = f"{mol_sayi} mol {isim} ({formul}) kaç tanecik (molekül) içerir?"
            cozum = (
                f"**Formül:** Tanecik sayısı = $n \\times N_A$\n\n"
                f"Burada:\n"
                f"  • $n$ = mol sayısı = {mol_sayi} mol\n"
                f"  • $N_A$ = Avogadro sayısı = $6.022 \\times 10^{{23}}$ tanecik/mol\n\n"
                f"**Hesaplama:**\n"
                f"  Tanecik = ${mol_sayi} \\times 6.022 \\times 10^{{23}}$\n"
                f"  $= {mol_sayi * 6.022:.3f} \\times 10^{{23}}$\n\n"
                f"$\\boxed{{{mol_sayi * 6.022:.3f} \\times 10^{{23}} \\text{{ tanecik}}}}$"
            )

        else:  # tanecik_to_mol
            mol_sayi = random.choice([0.5, 1, 2, 3, 5])
            tanecik_katsayi = round(mol_sayi * 6.022, 3)
            soru = (
                f"${tanecik_katsayi} \\times 10^{{23}}$ tanecik {isim} ({formul}) "
                f"kaç moldür?"
            )
            cozum = (
                f"**Formül:** $n = \\frac{{\\text{{Tanecik sayısı}}}}{{N_A}}$\n\n"
                f"  $n = \\frac{{{tanecik_katsayi} \\times 10^{{23}}}}{{6.022 \\times 10^{{23}}}}$\n\n"
                f"  $n = \\frac{{{tanecik_katsayi}}}{{6.022}} = {mol_sayi}$ mol\n\n"
                f"$\\boxed{{{mol_sayi} \\text{{ mol}}}}$"
            )

    elif tip == "denklem_denklestirme":
        # Önceden denkleştirilmiş denklemler (reaktanlar → ürünler, katsayılar)
        denklemler = [
            # (denkleştirilmemiş, denkleştirilmiş, açıklama)
            ("H₂ + O₂ → H₂O",
             "2H₂ + O₂ → 2H₂O",
             {"H": (4, 4), "O": (2, 2)},
             "Hidrojenin yanması"),
            ("Fe + O₂ → Fe₂O₃",
             "4Fe + 3O₂ → 2Fe₂O₃",
             {"Fe": (4, 4), "O": (6, 6)},
             "Demirin oksidasyonu"),
            ("N₂ + H₂ → NH₃",
             "N₂ + 3H₂ → 2NH₃",
             {"N": (2, 2), "H": (6, 6)},
             "Amonyak sentezi (Haber)"),
            ("CH₄ + O₂ → CO₂ + H₂O",
             "CH₄ + 2O₂ → CO₂ + 2H₂O",
             {"C": (1, 1), "H": (4, 4), "O": (4, 4)},
             "Metanın yanması"),
            ("Na + Cl₂ → NaCl",
             "2Na + Cl₂ → 2NaCl",
             {"Na": (2, 2), "Cl": (2, 2)},
             "Sodyum klorür oluşumu"),
            ("Al + O₂ → Al₂O₃",
             "4Al + 3O₂ → 2Al₂O₃",
             {"Al": (4, 4), "O": (6, 6)},
             "Alüminyumun oksidasyonu"),
            ("C₃H₈ + O₂ → CO₂ + H₂O",
             "C₃H₈ + 5O₂ → 3CO₂ + 4H₂O",
             {"C": (3, 3), "H": (8, 8), "O": (10, 10)},
             "Propanın yanması"),
            ("Mg + HCl → MgCl₂ + H₂",
             "Mg + 2HCl → MgCl₂ + H₂",
             {"Mg": (1, 1), "H": (2, 2), "Cl": (2, 2)},
             "Magnezyum-asit reaksiyonu"),
            ("CaCO₃ → CaO + CO₂",
             "CaCO₃ → CaO + CO₂",
             {"Ca": (1, 1), "C": (1, 1), "O": (3, 3)},
             "Kalsiyum karbonat ayrışması"),
            ("Zn + HCl → ZnCl₂ + H₂",
             "Zn + 2HCl → ZnCl₂ + H₂",
             {"Zn": (1, 1), "H": (2, 2), "Cl": (2, 2)},
             "Çinko-asit reaksiyonu"),
        ]

        denklestirmemis, denklestirmis, atom_kontrol, aciklama = random.choice(denklemler)

        soru = (
            f"Aşağıdaki kimyasal denklemi denkleştiriniz:\n\n"
            f"  {denklestirmemis}"
        )
        cozum = (
            f"**Reaksiyon:** {aciklama}\n\n"
            f"Denkleştirilmemiş: {denklestirmemis}\n\n"
            f"**Adım adım denkleştirme:**\n\n"
            f"Her iki taraftaki atom sayılarını eşitlemeliyiz.\n\n"
        )
        for atom, (sol, sag) in atom_kontrol.items():
            cozum += f"  {atom}: Sol = {sol}, Sağ = {sag}  ✓\n"
        cozum += (
            f"\n**Denkleştirilmiş denklem:**\n"
            f"  {denklestirmis}\n\n"
            f"Kütle korunumu sağlandı: Her iki taraftaki atom sayıları eşit.  ✓\n\n"
            f"$\\boxed{{{denklestirmis}}}$"
        )

    else:  # periyodik_tablo
        alt_tip = random.choice(["sembol_bul", "atom_no", "kutle_bul", "grup_bul"])
        sembol = random.choice(list(ELEMENTLER.keys()))
        isim, atom_no, kutle = ELEMENTLER[sembol]

        if alt_tip == "sembol_bul":
            soru = f"{isim} elementinin kimyasal sembolü nedir?"
            cozum = (
                f"**Periyodik tabloda {isim}:**\n\n"
                f"  • Sembol: **{sembol}**\n"
                f"  • Atom numarası: {atom_no}\n"
                f"  • Atom kütlesi: {kutle} g/mol\n\n"
                f"Sembol, elementin Latince veya İngilizce adının kısaltmasıdır.\n"
                f"Örneğin {isim} → {sembol}\n\n"
                f"$\\boxed{{{sembol}}}$"
            )

        elif alt_tip == "atom_no":
            soru = f"{isim} ({sembol}) elementinin atom numarası kaçtır?"
            cozum = (
                f"**Atom numarası**, bir atomun çekirdeğindeki **proton sayısını** gösterir.\n\n"
                f"Periyodik tabloda {isim} ({sembol}):\n"
                f"  • Atom numarası (Z) = {atom_no}\n"
                f"  • Bu, çekirdekte {atom_no} proton olduğu anlamına gelir.\n"
                f"  • Nötr atomda elektron sayısı da {atom_no}'dir.\n\n"
                f"$\\boxed{{{atom_no}}}$"
            )

        elif alt_tip == "kutle_bul":
            soru = f"{isim} ({sembol}) elementinin atom kütlesi (mol kütlesi) kaçtır?"
            cozum = (
                f"**Atom (mol) kütlesi**, bir mol atomun gram cinsinden kütlesidir.\n\n"
                f"Periyodik tablodan:\n"
                f"  • {isim} ({sembol})\n"
                f"  • Atom numarası: {atom_no}\n"
                f"  • Atom kütlesi: **{kutle} g/mol**\n\n"
                f"Bu, 1 mol {isim} = $6.022 \\times 10^{{23}}$ adet {isim} atomu = {kutle} gram demektir.\n\n"
                f"$\\boxed{{{kutle} \\text{{ g/mol}}}}$"
            )

        else:  # grup_bul
            # Basit periyot/grup bilgisi
            periyot_grup = {
                "H": (1, 1, "Ametal"), "He": (1, 18, "Soygaz"),
                "C": (2, 14, "Ametal"), "N": (2, 15, "Ametal"),
                "O": (2, 16, "Ametal"), "Na": (3, 1, "Alkali metal"),
                "Mg": (3, 2, "Toprak alkali metal"), "Al": (3, 13, "Metal"),
                "Si": (3, 14, "Yarı metal"), "P": (3, 15, "Ametal"),
                "S": (3, 16, "Ametal"), "Cl": (3, 17, "Halojen"),
                "K": (4, 1, "Alkali metal"), "Ca": (4, 2, "Toprak alkali metal"),
                "Fe": (4, 8, "Geçiş metali"), "Cu": (4, 11, "Geçiş metali"),
                "Zn": (4, 12, "Geçiş metali"), "Ag": (5, 11, "Geçiş metali"),
                "Au": (6, 11, "Geçiş metali"), "Pb": (6, 14, "Metal"),
            }
            periyot, grup, tur = periyot_grup[sembol]
            soru = f"{isim} ({sembol}) elementi periyodik tabloda hangi periyot ve grupta yer alır?"
            cozum = (
                f"**{isim} ({sembol})**\n\n"
                f"  • Atom numarası: {atom_no}\n"
                f"  • Periyot: **{periyot}** (elektron katman sayısı)\n"
                f"  • Grup: **{grup}**\n"
                f"  • Türü: **{tur}**\n\n"
                f"Periyot, atomdaki elektron katmanı sayısını gösterir.\n"
                f"Grup, son katmandaki elektron sayısıyla ilgilidir.\n\n"
                f"$\\boxed{{\\text{{Periyot {periyot}, Grup {grup} ({tur})}}}}$"
            )

    return soru, cozum, "Temel Kimya", s


GENERATORS = [
    (gen_addition, 3),
    (gen_subtraction, 3),
    (gen_multiplication, 3),
    (gen_division, 2),
    (gen_division_remainder, 2),
    (gen_fraction_addition, 3),
    (gen_fraction_subtraction, 3),
    (gen_fraction_multiplication, 3),
    (gen_fraction_division, 3),
    (gen_exponents, 2),
    (gen_square_root, 2),
    (gen_linear_equation, 3),
    (gen_linear_equation_neg, 2),
    (gen_quadratic_simple, 2),
    (gen_system_of_equations, 2),
    (gen_inequality, 2),
    (gen_absolute_value, 2),
    (gen_percentage, 3),
    (gen_percentage_change, 3),
    (gen_profit_loss, 2),
    (gen_speed_time_distance, 2),
    (gen_work_problem, 2),
    (gen_arithmetic_sequence, 2),
    (gen_geometric_sequence, 2),
    (gen_gcd_lcm, 2),
    (gen_prime_factorization, 2),
    (gen_arithmetic_mean, 2),
    (gen_median, 2),
    (gen_mode, 2),
    (gen_probability, 2),
    (gen_sets, 2),
    (gen_area_rectangle, 2),
    (gen_area_triangle, 2),
    (gen_area_circle, 2),
    (gen_volume, 2),
    (gen_pythagorean, 2),
    (gen_angles, 2),
    (gen_decimal_operations, 2),
    (gen_fraction_decimal_percent, 2),
    (gen_scientific_notation, 1),
    (gen_proportion, 2),
    (gen_algebraic_expansion, 2),
    (gen_logarithm, 2),
    (gen_trigonometry, 2),
    (gen_range, 2),
    (gen_permutation, 2),
    (gen_combination, 2),
    (gen_factoring, 2),
    (gen_simple_interest, 2),
    (gen_compound_interest, 2),
    (gen_logic, 3),
    (gen_unit_conversion, 3),
    (gen_number_systems, 3),
    (gen_data_reading, 3),
    (gen_time_calculation, 3),
    (gen_basic_chemistry, 3),
    (gen_basic_physics, 3),
]

# Ağırlıkları normalize et
FUNCS = [f for f, w in GENERATORS]
WEIGHTS = [w for _, w in GENERATORS]


def _uret_tek_qa():
    func = random.choices(FUNCS, weights=WEIGHTS, k=1)[0]
    try:
        return func()
    except Exception:
        return None


def generate_synthetic_jsonl(filename="temel_matematik_90k.jsonl", num_samples=90000):
    """
    Her soru ayrı bir JSON objesi olarak JSONL formatında kaydedilir.
    """
    print(f"Toplam {num_samples} soru üretiliyor → {filename}")
    print(f"Generator sayısı: {len(FUNCS)}\n")

    toplam_qa = 0
    hata = 0

    with open(filename, 'w', encoding='utf-8') as f:
        while toplam_qa < num_samples:
            res = _uret_tek_qa()
            if res is None:
                hata += 1
                continue
            
            soru, cozum, tur, zorluk = res
            
            obj = {
                "id": get_random_id(),
                "prompt": soru,
                "cevap": cozum,
                "soru türü": tur,
                "zorluk": zorluk
            }
            
            f.write(json.dumps(obj, ensure_ascii=False) + '\n')
            toplam_qa += 1

            if toplam_qa % 10000 == 0:
                print(f"  ✓ {toplam_qa:,} / {num_samples:,} soru üretildi.")

    print(f"\n✅ Tamamlandı!")
    print(f"   Toplam soru   : {toplam_qa:,}")
    print(f"   Üretim hatası : {hata}")
    print(f"📁 Çıktı: {filename}")


if __name__ == "__main__":
    # Hızlı test:
    # generate_synthetic_jsonl("test_100.jsonl", 100)

    # Tam üretim:
    generate_synthetic_jsonl("basic_math.jsonl", 1000000)