Rejtjelezés

import base64

def szoveg_kodolas(eredeti_szoveg):

    # Szöveg kódolása Base64 formátumba

    szoveg_bytes = eredeti_szoveg.encode('utf-8')

    kodolt_bytes = base64.b64encode(szoveg_bytes)

    kodolt_szoveg = kodolt_bytes.decode('utf-8')

    return kodolt_szoveg

def szoveg_visszafejtes(kodolt_szoveg):

    # Kódolt szöveg visszafejtése

    kodolt_bytes = kodolt_szoveg.encode('utf-8')

    eredeti_bytes = base64.b64decode(kodolt_bytes)

    eredeti_szoveg = eredeti_bytes.decode('utf-8')

    return eredeti_szoveg

# Felhasználói bemenet

bekert_szoveg = input("Kérlek, adj meg egy szöveget: ")

# Műveletek végrehajtása és kiírása

kodolt = szoveg_kodolas(bekert_szoveg)

visszafejtett = szoveg_visszafejtes(kodolt)

print(f"\nEredeti szöveg: {bekert_szoveg}")

print(f"Kódolt szöveg: {kodolt}")

print(f"Visszafejtett szöveg: {visszafejtett}")

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

Kérlek, adj meg egy szöveget: szabolaszloistvan

Eredeti szöveg: szabolaszloistvan

Kódolt szöveg: c3phYm9sYXN6bG9pc3R2YW4=

Visszafejtett szöveg: szabolaszloistvan

** Process exited - Return Code: 0 **

futtatas; https://www.online-python.com/

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

Kérlek, adj meg egy szöveget: 312495863456718949829459235692435

Eredeti szöveg: 312495863456718949829459235692435

Kódolt szöveg: MzEyNDk1ODYzNDU2NzE4OTQ5ODI5NDU5MjM1NjkyNDM1

Visszafejtett szöveg: 312495863456718949829459235692435

import base64

def base64_dekodolas(kodolt_szoveg):

    try:

        # A sztringet bájtokká (bytes) kell alakítani, mert a base64 ezt várja

        bajt_adat = kodolt_szoveg.encode('utf-8')

        

        # Dekódolás

        dekodolt_bajt = base64.b64decode(bajt_adat)

        

        # A bájtokat visszaalakítjuk olvasható szöveggé (string)

        eredeti_szoveg = dekodolt_bajt.decode('utf-8')

        return eredeti_szoveg

        

    except Exception as e:

        return f"Hiba történt a dekódolás során: {e}"

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

if __name__ == "__main__":

    # Ez a kódolt szöveg a "Hello Világ!" kifejezést takarja

    kodolt_pelda = "SGVsbG8gViliZyE="

    

    eredmeny = base64_dekodolas(kodolt_pelda)

    print(f"Eredeti szöveg: {eredmeny}")

Gomb

import tkinter as tk

def gomb_kattintas():

    print("Megnyomtad a gombot!")

# Főablak létrehozása

ablak = tk.Tk()

ablak.title("Nyomógomb Példa")

ablak.geometry("300x200") # Ablak mérete

# Gomb létrehozása és beállításai

gomb = tk.Button(

    ablak, 

    text="Kattints ide!", 

    font=("Arial", 14), 

    bg="#4CAF50", 

    fg="white", 

    padx=10, 

    pady=10, 

    command=gomb_kattintas

)

# Gomb elhelyezése az ablak közepén

gomb.pack(expand=True)

# Az ablak futtatása

ablak.mainloop()

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

RSA kulcsok generálása és visszafejtése

import secrets

import random

# 1. Miller-Rabin prímteszt

def miller_rabin(n, k=5):

    if n < 2: return False

    if n in (2, 3): return True

    if n % 2 == 0: return False

    # n-1 = 2^s * d felbontás

    d = n - 1

    s = 0

    while d % 2 == 0:

        d //= 2

        s += 1

    for _ in range(k):

        a = secrets.randbelow(n - 3) + 2

        x = pow(a, d, n)

        if x == 1 or x == n - 1:

            continue

        for _ in range(s - 1):

            x = pow(x, 2, n)

            if x == n - 1:

                break

        else:

            return False

    return True

# 2. Nagy prím generálása adott bitszámmal

def generate_large_prime(bits=1024):

    while True:

        # Páratlan szám generálása

        n = secrets.randbits(bits) | (1 << bits - 1) | 1

        if miller_rabin(n):

            return n

# 3. Kiterjesztett euklideszi algoritmus

# ax + by = gcd(a,b). Visszatérési érték: (gcd, x, y)

def extended_gcd(a, b):

    if a == 0:

        return b, 0, 1

    gcd, x1, y1 = extended_gcd(b % a, a)

    x = y1 - (b // a) * x1

    y = x1

    return gcd, x, y

# Moduláris inverz számítás (a * x = 1 mod m)

def mod_inverse(a, m):

    gcd, x, y = extended_gcd(a, m)

    if gcd != 1:

        raise ValueError("A moduláris inverz nem létezik.")

    return x % m

# 4. RSA Kulcsgenerálás

def generate_rsa_keys(bits=512):

    p = generate_large_prime(bits)

    q = generate_large_prime(bits)

    n = p * q

    phi_n = (p - 1) * (q - 1)

    # Nyilvános kulcs (e) választása

    while True:

        e = secrets.randbelow(phi_n)

        if e > 1 and extended_gcd(e, phi_n)[0] == 1:

            break

    # Titkos kulcs (d) számítása

    d = mod_inverse(e, phi_n)

    

    return (e, n), (d, n)

# 5. Titkosítás

def encrypt(public_key, plaintext):

    e, n = public_key

    # Üzenet (karakterlánc) konvertálása számmá

    message = int.from_bytes(plaintext.encode('utf-8'), 'big')

    cipher = pow(message, e, n)

    return cipher

# 6. Visszafejtés

def decrypt(private_key, ciphertext):

    d, n = private_key

    message = pow(ciphertext, d, n)

    # Szám konvertálása vissza karakterlánccá

    try:

        byte_length = (message.bit_length() + 7) // 8

        plaintext_bytes = message.to_bytes(byte_length, 'big')

        return plaintext_bytes.decode('utf-8')

    except Exception:

        return "Hiba a visszafejtés során"

# --- Példa futtatás ---

if __name__ == "__main__":

    print("RSA kulcsok generálása folyamatban...")

    public_key, private_key = generate_rsa_keys(bits=256) # Teszteléshez rövidebb kulcs

    

    print(f"\nNyilvános kulcs (e, n):\n{public_key}")

    print(f"\nTitkos kulcs (d, n):\n{private_key}")

    

    message = "Titkos üzenet a kriptográfiához!"

    print(f"\nEredeti üzenet: {message}")

    

    # Titkosítás

    ciphertext = encrypt(public_key, message)

    print(f"\nTitkosított szöveg (számként): {ciphertext}")

    

    # Visszafejtés

    decrypted_message = decrypt(private_key, ciphertext)

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

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

Válasz

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

RSA kulcsok generálása folyamatban...

Nyilvános kulcs (e, n):

(1920916985852970459043629395409263969246621197918328070322237977929018840074419703965021760537109678079016866773330106596487429181662092659033763396896187, 8165416843091695222455265542795392256816772823855224489218066336246731692834273371865217084702507589613323755519638859146226123292805743590636779649319161)

Titkos kulcs (d, n):

(4735353450344245588049210762751135074215273281857045509341616675421219264946593318403009021903920390000489040394670078412221784391920284130359943066135155, 8165416843091695222455265542795392256816772823855224489218066336246731692834273371865217084702507589613323755519638859146226123292805743590636779649319161)

Eredeti üzenet: Titkos üzenet a kriptográfiához!

Titkosított szöveg (számként): 8081259975579316313307267154334539515924421916623907674871938229155170337519114633688855096916952942088667274952408298601570158158950773970345505682334131

Visszafejtett üzenet: Titkos üzenet a kriptográfiához!

** Process exited - Return Code: 0 **

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

import os

from cryptography.hazmat.primitives.asymmetric import rsa

from cryptography.hazmat.primitives import serialization

# 1. RSA kulcspár generálása

print("Kulcspár generálása folyamatban...")

private_key = rsa.generate_private_key(

    public_exponent=65537,

    key_size=4096

)

public_key = private_key.public_key()

# 2. Privát kulcs mentése PEM formátumban

private_pem = private_key.private_bytes(

    encoding=serialization.Encoding.PEM,

    format=serialization.PrivateFormat.TraditionalOpenSSL,

    encryption_algorithm=serialization.NoEncryption() # Jelszavas védelemhez lásd a dokumentációt

)

with open('private_key.pem', 'wb') as f:

    f.write(private_pem)

# 3. Nyilvános kulcs mentése PEM formátumban

public_pem = public_key.public_bytes(

    encoding=serialization.Encoding.PEM,

    format=serialization.PublicFormat.SubjectPublicKeyInfo

)

with open('public_key.pem', 'wb') as f:

    f.write(public_pem)

print("A kulcsok sikeresen elkészültek és mentésre kerültek.")

print("Privát kulcs: private_key.pem")

print("Nyilvános kulcs: public_key.pem")

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

átlátok rajtad mint Ahogy Hans Castorp madame Chauchat testén

Kicsit más

import tkinter as tk

import math

W = H = 858

root = tk.Tk()

root.title("Animation")

canvas = tk.Canvas(root, width=W, height=H, bg="black", highlightthickness=0)

canvas.pack()

p = [

    ("gray", 0.3, 45, 0.47, 35),

    ("orange", 0.7, 72, 0.35, 42),

    ("blue", 0.8, 108, 0.3, 78),

    ("red", 0.5, 144, 0.24, 84),

    ("brown", 1.5, 198, 0.13, 98),

    ("yellow", 1.2, 252, 0.1, 52),

    ("light blue", 0.1, 306, 0.07, 76),

    ("blue", 0.1, 360, 0.05, 360),

]

b = []

for c, sz, t, sb, inc in p:

    b.append([c, sz * 20, t, sb, math.radians(inc), 0, 0, 0])

h_angle = 0

objects = []

def draw_circle(x, y, r, color):

    return canvas.create_oval(x - r, y - r, x + r, y + r, fill=color, outline=color)

def animate():

    global h_angle

    canvas.delete("all")

    for j, d in enumerate(b):

        d[5] += d[3]

        r = math.radians(d[5])

        x = d[2] * math.cos(r)

        y = d[2] * math.sin(r)

        i = d[4]

        px = x - y * 0.5

        py = y * math.cos(i) * math.sin(i) + (x + y * math.cos(i) * 0.866) * 0.5

        draw_circle(W / 2 + px, H / 2 + py, max(2, d[1]), d[0])

        if j == 2:

            hx = W / 2 + px + 15 * math.cos(h_angle)

            hy = H / 2 + py + 15 * math.sin(h_angle)

            draw_circle(hx, hy, 6, "white")

            h_angle += 0.5

    root.after(16, animate)

animate()

root.mainloop()

Mindössze 6 sor a naprendszer működésének modellezése pythonban

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

6 sorban

----------

import turtle, math; w=turtle.Screen(); w.setup(858,858); w.bgcolor("black"); w.tracer(0); n=turtle.Turtle("circle"); n.color("yellow"); n.shapesize(3); n.up(); b, p=[], [("gray",.3,45,.47,35),("orange",.7,72,.35,42),("blue",.8,108,.3,78),("red",.5,144,.24,84),("brown",1.5,198,.13,98),("yellow",1.2,252,.1,52),("light blue",.1,306,.07,76),("blue",.1,360,.05,360)]

for c,sz,t,sb,inc in p: pt=turtle.Turtle("circle"); pt.color(c); pt.shapesize(sz); pt.up(); b.append([pt,t,sb,math.radians(inc),0]); h=turtle.Turtle("circle"); h.color("white"); h.shapesize(0.3); h.up(); hs=0

while True:

    for j,d in enumerate(b): d[4]+=d[2]; r=math.radians(d[4]); x,y,i=d[1]*math.cos(r),d[1]*math.sin(r),d[3]; d[0].goto(x-y*0.5,y*math.cos(i)*math.sin(i)+(x+y*math.cos(i)*0.866)*0.5);

    if j==2: h.goto(d[0].xcor()+15*math.cos(hs),d[0].ycor()+15*math.sin(hs)); hs+=0.5

    w.update()

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

Emulálás; https://onecompiler.com/tkinter#draft-a4w4

Naprendszer mojo nyelven

# A bolygó tulajdonságainak definiálása

struct Planet:

    var name: String

    var x: Float64

    var y: Float64

    var vx: Float64

    var vy: Float64

    var mass: Float64

    var radius: Float64

    fn __init__(inout self, name: String, x: Float64, y: Float64, vx: Float64, vy: Float64, mass: Float64, radius: Float64):

        self.name = name

        self.x = x

        self.y = y

        self.vx = vx

        self.vy = vy

        self.mass = mass

        self.radius = radius

# Gravitációs erő számítása (G = 1 egyszerűsített értékkel)

fn update_positions(inout planets: List[Planet], dt: Float64):

    let G: Float64 = 1.0

    for i in range(len(planets)):

        var p1 = planets[i]

        var fx: Float64 = 0.0

        var fy: Float64 = 0.0

        for j in range(len(planets)):

            if i == j:

                continue

            var p2 = planets[j]

            let dx = p2.x - p1.x

            let dy = p2.y - p1.y

            let dist = (dx * dx + dy * dy).sqrt()

            if dist > 0.0:

                let force = (G * p1.mass * p2.mass) / (dist * dist)

                fx += force * (dx / dist)

                fy += force * (dy / dist)

        # F = m * a alapján gyorsulás és sebesség frissítése

        planets[i].vx += (fx / p1.mass) * dt

        planets[i].vy += (fy / p1.mass) * dt

    # Pozíciók frissítése sebesség alapján

    for i in range(len(planets)):

        planets[i].x += planets[i].vx * dt

        planets[i].y += planets[i].vy * dt

fn main() raises:

    # Python modulok importálása a vizualizációhoz

    let plt = Python.import_module("matplotlib.pyplot")

    let animation = Python.import_module("matplotlib.animation")

    # Kezdőértékek megadása (Nap, Föld, Mars, Vénusz)

    var planets = List[Planet]()

    planets.append(Planet("Nap", 0.0, 0.0, 0.0, 0.0, 1000.0, 20.0))

    planets.append(Planet("Föld", 100.0, 0.0, 0.0, 3.16, 10.0, 5.0))

    planets.append(Planet("Mars", 150.0, 0.0, 0.0, 2.58, 6.0, 4.0))

    planets.append(Planet("Vénusz", 70.0, 0.0, 0.0, 3.78, 8.0, 4.5))

    let fig = plt.figure(figsize=(8, 8))

    let ax = fig.add_subplot(1, 1, 1)

    fn animate(frame: Int) raises:

        update_positions(planets, 0.05)

        ax.clear()

        ax.set_xlim(-200, 200)

        ax.set_ylim(-200, 200)

        ax.grid(True)

        # Bolygók kirajzolása

        for i in range(len(planets)):

            let p = planets[i]

            let color = "y" if p.name == "Nap" else "b" if p.name == "Föld" else "r" if p.name == "Mars" else "orange"

            ax.scatter(p.x, p.y, s=p.radius * 5, color=color)

            ax.annotate(p.name, (p.x, p.y + 2))

    let ani = animation.FuncAnimation(fig, animate, frames=200, interval=20)

    plt.show()

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

matplotlib kell hozzá

C++-ban a naprendszer szimuláció

Ez a program egy 2D-s Naprendszer-szimulációt rajzol ki és futtat le, amelyben 8 bolygó kering a sárga színű Nap körül, miközben a külső bolygó körül egy kis hold is látható.A látvány és a program működése a következő főbb elemekből áll:Ablakméret és háttér: Egy \(858 \times 858\) pixel méretű ablak nyílik meg, fekete háttérrel.A Nap: A képernyő pontos közepén \((429, 429)\) egy sárga színű kör \((r = 30)\) helyezkedik el.Bolygók: A nap körül 8 különböző színű és méretű bolygó kering saját sugarú pályán (a Merkúrtól a Neptunusz jellegéig) a következő tulajdonságokkal:Különböző sugarú pályákon és sebességgel mozognak (a belső bolygók gyorsabban, a külsők lassabban).Méretük és színük egyedi (pl. a Jupiter barna, a Neptunusz kék).Hold: A legkülső bolygóhoz (a nyolcadikhoz, ami szintén kék színű) hozzá van kötve egy apró fehér hold, amely a bolygó körül kering.(Megjegyzés: A kód végén az ablakot frissítő window.clear(), window.draw() és window.display() hívások hiányoznak, így az ablak megnyílna, de a bolygók nem mozognának, vagy lefagynának. 

Telepitsd az SFML-t ; sudo apt-get install libsfml-dev

program futtatása;

#include <SFML/Graphics.hpp>

#include <vector>

#include <cmath>

const double PI = std::acos(-1.0);

struct Planet {

    sf::CircleShape shape;

    double radius;

    double speed;

    double inclination;

    double angleInc;

    double currentAngle;

};

int main() {

    sf::RenderWindow window(sf::VideoMode(858, 858), "Orbit Simulation");

    window.setFramerateLimit(60);

    sf::CircleShape sun(30.f);

    sun.setFillColor(sf::Color::Yellow);

    sun.setOrigin(30.f, 30.f);

    sun.setPosition(429.f, 429.f);

    std::vector<Planet> planets = {

        {sf::CircleShape(12.f), 45.0, 0.47, 35.0, 35.0, 0.0},

        {sf::CircleShape(20.f), 72.0, 0.35, 42.0, 42.0, 0.0},

        {sf::CircleShape(24.f), 108.0, 0.30, 78.0, 78.0, 0.0},

        {sf::CircleShape(15.f), 144.0, 0.24, 84.0, 84.0, 0.0},

        {sf::CircleShape(35.f), 198.0, 0.13, 98.0, 98.0, 0.0},

        {sf::CircleShape(28.f), 252.0, 0.10, 52.0, 52.0, 0.0},

        {sf::CircleShape(8.f),  306.0, 0.07, 76.0, 76.0, 0.0},

        {sf::CircleShape(8.f),  360.0, 0.05, 360.0, 360.0, 0.0}

    };

    // Színek beállítása

    sf::Color colors[] = {sf::Color(128, 128, 128), sf::Color(255, 165, 0), sf::Color::Blue,

                          sf::Color::Red, sf::Color::SaddleBrown, sf::Color::Yellow, 

                          sf::Color::Cyan, sf::Color::Blue};

    for (size_t i = 0; i < planets.size(); ++i) {

        planets[i].shape.setFillColor(colors[i]);

        planets[i].shape.setOrigin(planets[i].shape.getRadius(), planets[i].shape.getRadius());

    }

    sf::CircleShape moon(3.f);

    moon.setFillColor(sf::Color::White);

    moon.setOrigin(3.f, 3.f);

    double moonAngle = 0;

    while (window.isOpen()) {

        sf::Event event;

        while (window.pollEvent(event)) {

            if (event.type == sf::Event::Closed)

                window.close();

        }

        // Logika

        for (auto& p : planets) {

            p.currentAngle += p.speed;

            double rad = p.currentAngle * (PI / 180.0);

            double incRad = p.inclination * (PI / 180.0);

            double x = p.radius * std::cos(rad);

            double y = p.radius * std::sin(rad);

            double screenX = x - y * 0.5;

            double screenY = y * std::cos(incRad) * std::sin(incRad) + (x + y * std::cos(incRad) * 0.866) * 0.5;

            p.shape.setPosition(429.f + screenX, 429.f + screenY);

        }

        // Hold pozíció (3. bolygóhoz, azaz az index 2-höz csatolva)

        moonAngle += 0.5;

        moon.setPosition(planets[2].shape.getPosition().x + 15 * std::cos(moonAngle * (PI / 180.0)),

                         planets[2].shape.getPosition().y + 15 * std::sin(moonAngle * (PI / 180.0)));

        // Renderelés

        window.clear(sf::Color::Black);

        window.draw(sun);

        for (const auto& p : planets) {

            window.draw(p.shape);

        }

        window.draw(moon);

        window.display();

    }

    return 0;

}

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

Nekem futott!

Arc rajzolása

--------

import turtle

# Ablak beállítása

ablak = turtle.Screen()

ablak.title("Mosolygós arc")

ablak.bgcolor("white")

# A rajzoló teknőc létrehozása

ceruza = turtle.Turtle()

ceruza.speed(5) # Rajzolás sebessége (1-10)

ceruza.pensize(3) # Vonalvastagság

# 1. A fej megrajzolása (sárga kör)

ceruza.penup()

ceruza.goto(0, -150) # A kör aljához mozgatás

ceruza.pendown()

ceruza.fillcolor("yellow")

ceruza.begin_fill()

ceruza.circle(150)

ceruza.end_fill()

# Szemek beállítása és rajzolása

ceruza.fillcolor("black")

# Bal szem

ceruza.penup()

ceruza.goto(-50, 50)

ceruza.pendown()

ceruza.begin_fill()

ceruza.circle(20)

ceruza.end_fill()

# Jobb szem

ceruza.penup()

ceruza.goto(50, 50)

ceruza.pendown()

ceruza.begin_fill()

ceruza.circle(20)

ceruza.end_fill()

# 3. Az orr (háromszög)

ceruza.penup()

ceruza.goto(0, 20)

ceruza.pendown()

ceruza.fillcolor("black")

ceruza.begin_fill()

ceruza.setheading(210) # Irány beállítása

for _ in range(3):

    ceruza.forward(30)

    ceruza.left(120)

ceruza.end_fill()

# 4. A száj (mosoly)

ceruza.penup()

ceruza.goto(-60, -30)

ceruza.pendown()

ceruza.setheading(-60) # Lefelé és jobbra néz

ceruza.circle(60, 120) # Ív rajzolása

# A teknőc eltüntetése a rajz végén

ceruza.hideturtle()

# Az ablak nyitva tartása kattintásig

turtle.done()

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

import turtle

# Ablak beállítása

ablak = turtle.Screen()

ablak.bgcolor("skyblue")

ablak.title("Rajzoljunk egy házat!")

# A teknőc (rajzoló) létrehozása

haz = turtle.Turtle()

haz.pensize(3)

haz.speed(3)

# 1. A ház alapja (Négyzet)

haz.color("blue", "yellow") # Toll színe kék, kitöltő szín sárga

haz.begin_fill()

for _ in range(4):

    haz.forward(150)

    haz.right(90)

haz.end_fill()

# 2. A tető (Háromszög)

haz.color("red", "red") # Toll színe piros, kitöltő szín piros

haz.begin_fill()

haz.left(45)

haz.forward(106)

haz.right(90)

haz.forward(106)

haz.end_fill()

# Felkészülés az ajtó és ablak rajzolására

haz.penup()

haz.goto(40, -50)

haz.pendown()

# 3. Az ajtó

haz.color("brown", "brown")

haz.begin_fill()

haz.left(45)

haz.forward(50)

haz.right(90)

haz.forward(30)

haz.right(90)

haz.forward(50)

haz.end_fill()

# Felkészülés az ablak rajzolására

haz.penup()

haz.goto(10, -10)

haz.pendown()

# 4. Az ablak

haz.color("black", "lightblue")

haz.begin_fill()

for _ in range(4):

    haz.forward(30)

    haz.right(90)

haz.end_fill()

# Ablak bezárásához kattintásra van szükség

haz.hideturtle()

turtle.done()

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

Forma-1 python

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

import matplotlib.pyplot as plt

import matplotlib.patches as patches

import numpy as np

def rajzol_f1_auto():

    # Ábra és koordinátarendszer inicializálása

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

    ax.set_facecolor('#0d1117') # Sötét háttér a sci-fi hatáshoz

    

    # 1. Kasztni és alsó aerodinamikai elemek (Sidepods & Floor)

    kasztni = patches.Polygon([[ -5, 0.8], [2, 1.2], [6, 1.2], [7, 0.5], [ -5, 0.5]], closed=True, color='#c92a2a', zorder=3)

    padlolemez = patches.Polygon([[ -6, 0.2], [7.5, 0.2], [7.5, 0.5], [-6, 0.5]], closed=True, color='#1a1a1a', zorder=2)

    orrunk = patches.Polygon([[ -5, 0.8], [ -7, 0.5], [ -5, 0.5]], closed=True, color='#c92a2a', zorder=3)

    

    ax.add_patch(kasztni)

    ax.add_patch(padlolemez)

    ax.add_patch(orrunk)

    

    # 2. Aerodinamikai légterelők (Orr-kúp szárnyak és terelőlapok)

    # Első szárny elemek

    elso_szarny_fo = patches.Polygon([[-7.5, 0.1], [-7.5, 0.8], [-7.0, 0.8], [-6.8, 0.1]], closed=True, color='#e0e0e0', zorder=3)

    elso_szarny_veg = patches.Polygon([[-7.5, 0.1], [-7.2, 1.3], [-6.8, 1.3], [-6.8, 0.1]], closed=True, color='#2b8a3e', zorder=3)

    ax.add_patch(elso_szarny_fo)

    ax.add_patch(elso_szarny_veg)

    

    # Bargeboard és oldalsó légterelők (aerodinamikai elemek)

    bargeboard1 = patches.Polygon([[-1, 0.5], [-0.5, 1.8], [0, 1.8], [-0.2, 0.5]], closed=True, color='#2b8a3e', zorder=3)

    bargeboard2 = patches.Polygon([[0.5, 0.5], [0.8, 1.6], [1.2, 1.6], [1.3, 0.5]], closed=True, color='#fab005', zorder=3)

    ax.add_patch(bargeboard1)

    ax.add_patch(bargeboard2)

    # 3. Kerekek és felfüggesztés (Gumiabroncsok)

    elso_gumi = patches.Circle((-5, 0.2), 0.6, color='#212529', zorder=4)

    elso_felni = patches.Circle((-5, 0.2), 0.35, color='#adb5bd', zorder=5)

    hatso_gumi = patches.Circle((5, 0.2), 0.6, color='#212529', zorder=4)

    hatso_felni = patches.Circle((5, 0.2), 0.35, color='#adb5bd', zorder=5)

    

    ax.add_patch(elso_gumi)

    ax.add_patch(elso_felni)

    ax.add_patch(hatso_gumi)

    ax.add_patch(hatso_felni)

    

    # Felfüggesztés háromszögek

    felfuggesztes_elso = patches.Polygon([[-5, 0.8], [-4.5, 0.5], [-5.5, 0.5]], closed=True, color='#6c757d', zorder=3)

    felfuggesztes_hatso = patches.Polygon([[5, 0.8], [4.5, 0.5], [5.5, 0.5]], closed=True, color='#6c757d', zorder=3)

    ax.add_patch(felfuggesztes_elso)

    ax.add_patch(felfuggesztes_hatso)

    # 4. Hátsó szárny (Rear Wing)

    hatso_szarny_fo = patches.Polygon([[6.5, 0.5], [6.5, 2.8], [7.5, 2.8], [7.5, 0.5]], closed=True, color='#e0e0e0', zorder=3)

    hatso_szarny_veglap = patches.Polygon([[6.8, 0.2], [6.6, 3.1], [7.6, 3.1], [7.4, 0.2]], closed=True, color='#c92a2a', zorder=2)

    allvany = patches.Polygon([[7.0, 0.5], [7.0, 1.8], [7.2, 1.8], [7.2, 0.5]], closed=True, color='#212529', zorder=2)

    ax.add_patch(hatso_szarny_fo)

    ax.add_patch(hatso_szarny_veglap)

    ax.add_patch(allvany)

    # 5. Halo (Fejvédő keret)

    halo = patches.Polygon([[-1, 1.5], [0.5, 1.5], [0.1, 1.2], [-0.5, 1.2]], closed=True, color='#adb5bd', zorder=4)

    ax.add_patch(halo)

    # 6. Matrica-minták és szponzorcsíkok

    # Cápauszony a motorborításon (Shark fin)

    shark_fin = patches.Polygon([[2.2, 1.2], [4.5, 2.2], [4.8, 1.2]], closed=True, color='#fab005', zorder=3)

    ax.add_patch(shark_fin)

    

    # Oldaldoboz matrica (Vonalak)

    matrica1 = patches.Polygon([[ -3, 0.7], [ -2, 1.1], [0, 1.1], [-1, 0.7]], closed=True, color='#e0e0e0', zorder=3)

    matrica2 = patches.Polygon([[ -3.5, 0.6], [ -2.5, 1.0], [ -1.5, 1.0], [-2.2, 0.6]], closed=True, color='#ffec99', zorder=3)

    ax.add_patch(matrica1)

    ax.add_patch(matrica2)

    # 7. Matricák (Feliratok és rajtszám)

    ax.text(-5.5, 0.8, '1', fontsize=36, fontweight='bold', color='white', zorder=5) # Rajtszám

    ax.text(-2, 0.85, 'PIRELLI', fontsize=10, fontweight='bold', color='black', zorder=4, rotation=10)

    ax.text(2, 0.85, 'SHELL', fontsize=12, fontweight='bold', color='white', zorder=4)

    # 8. Légáramlat-vonalak (Aerodinamikai szimuláció hullámokkal)

    x_flow = np.linspace(-9, 8, 100)

    # Áramlási vonalak ábrázolása Matplotlib-pel

    for y_offset in np.linspace(0.5, 3.0, 6):

        ax.plot(x_flow, y_offset + 0.1 * np.sin(x_flow), color='#00d2be', alpha=0.5, linewidth=2, zorder=1)

    # Térkép beállítások (Ne mutassa a tengelyeket)

    ax.set_xlim(-10, 9)

    ax.set_ylim(-0.5, 4)

    ax.axis('off')

    

    plt.title("Formula 1 - Koncepció és Aerodinamika", color='white', fontsize=16)

    plt.show()

rajzol_f1_auto()

Tervezés

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

import numpy as np

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d.art3d import Poly3DCollection

def draw_sports_car():

    fig = plt.figure(figsize=(12, 8))

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

    ax.set_title("3D Részletes Sportautó", fontsize=16, pad=20)

    # 1. Alváz és alsó test (X, Y, Z koordináták)

    chassis_x = np.array([[-1.5, 1.5, 1.5, -1.5, -1.5],

                          [-1.5, 1.5, 1.5, -1.5, -1.5]])

    chassis_y = np.array([[-0.8, -0.8, 0.8, 0.8, -0.8],

                          [-0.8, -0.8, 0.8, 0.8, -0.8]])

    chassis_z = np.array([[0.2, 0.2, 0.2, 0.2, 0.2],

                          [0.6, 0.6, 0.6, 0.6, 0.6]])

    ax.plot_wireframe(chassis_x, chassis_y, chassis_z, color='crimson', linewidth=2)

    # 2. Tető és ablakok

    roof_x = np.array([[-0.6, 0.8, 0.8, -0.6, -0.6],

                       [-0.6, 0.8, 0.8, -0.6, -0.6]])

    roof_y = np.array([[-0.6, -0.6, 0.6, 0.6, -0.6],

                       [-0.6, -0.6, 0.6, 0.6, -0.6]])

    roof_z = np.array([[0.6, 0.6, 0.6, 0.6, 0.6],

                       [1.3, 1.3, 1.1, 1.1, 1.3]])

    ax.plot_wireframe(roof_x, roof_y, roof_z, color='darkred', linewidth=2)

    # Első és hátsó szélvédő összekötése

    windshield_x = np.array([[-0.6, -0.6], [0.8, 0.8]])

    windshield_y = np.array([[-0.6, 0.6], [-0.6, 0.6]])

    windshield_z = np.array([[0.6, 0.6], [0.6, 0.6]])

    ax.plot_wireframe(windshield_x, windshield_y, windshield_z, color='darkred', linewidth=2)

    # 3. Első és hátsó lökhárító / spoiler

    bumper_x = np.array([[-1.5, -1.8, -1.8, -1.5], [-1.5, -1.8, -1.8, -1.5]])

    bumper_y = np.array([[-0.6, -0.6, 0.6, 0.6], [-0.6, -0.6, 0.6, 0.6]])

    bumper_z = np.array([[0.3, 0.3, 0.3, 0.3], [0.5, 0.5, 0.5, 0.5]])

    ax.plot_wireframe(bumper_x, bumper_y, bumper_z, color='lightcoral', linewidth=2)

    # Hátsó spoiler

    spoiler_x = np.array([[1.5, 1.8, 1.8, 1.5], [1.5, 1.8, 1.8, 1.5]])

    spoiler_y = np.array([[-0.8, -0.8, 0.8, 0.8], [-0.8, -0.8, 0.8, 0.8]])

    spoiler_z = np.array([[0.6, 0.6, 0.6, 0.6], [0.9, 0.9, 0.9, 0.9]])

    ax.plot_wireframe(spoiler_x, spoiler_y, spoiler_z, color='black', linewidth=2)

    # 4. Kerekek kirajzolása (Hengerek paraméteres egyenleteivel)

    theta = np.linspace(0, 2 * np.pi, 20)

    wheel_r = 0.35

    wheel_w = 0.2

    wheel_centers = [(-1.0, -0.85, 0.3), (1.0, -0.85, 0.3), 

                     (-1.0, 0.85, 0.3), (1.0, 0.85, 0.3)]

    for cx, cy, cz in wheel_centers:

        x = cx + wheel_r * np.cos(theta)

        y = cy + np.zeros_like(theta)

        z = cz + wheel_r * np.sin(theta)

        ax.plot3D(x, y, z, color='dimgray', linewidth=4)

        

        # Keréktárcsák (felnik)

        fenni_x = cx + (wheel_r * 0.5) * np.cos(theta)

        fenni_z = cz + (wheel_r * 0.5) * np.sin(theta)

        ax.plot3D(fenni_x, y, fenni_z, color='silver', linewidth=2)

    # 5. Fényszórók

    headlight_x = np.array([[-1.5, -1.6], [-1.5, -1.6]])

    headlight_y = np.array([[-0.6, -0.6], [0.6, 0.6]])

    headlight_z = np.array([[0.4, 0.4], [0.4, 0.4]])

    ax.plot_wireframe(headlight_x, headlight_y, headlight_z, color='gold', linewidth=4)

    # 6. Tengelyek beállítása és formázás

    ax.set_xlim([-2.0, 2.0])

    ax.set_ylim([-2.0, 2.0])

    ax.set_zlim([0, 1.5])

    ax.set_xlabel('Hosszúság (X)')

    ax.set_ylabel('Szélesség (Y)')

    ax.set_zlabel('Magasság (Z)')

    # Háttérszín és rács beállítások a látványosabb 3D élményért

    ax.w_xaxis.set_pane_color((1.0, 1.0, 1.0, 1.0))

    ax.w_yaxis.set_pane_color((0.9, 0.9, 0.9, 1.0))

    ax.w_zaxis.set_pane_color((0.95, 0.95, 0.95, 1.0))

    plt.show()

if __name__ == "__main__":

    draw_sports_car()

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

https://colab.research.google.com/drive/1WwvRJhJxCHYK_qG3Ybiz4fqpmEkurgEf

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

3D autó

import numpy as np

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d.art3d import Poly3DCollection

def draw_car():

    fig = plt.figure(figsize=(10, 6))

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

    # 1. Karosszéria pontok (3D koordináták)

    car_body = np.array([

        [-1.5, -0.8, -0.5],  # 0: bal hátsó alsó

        [ 1.5, -0.8, -0.5],  # 1: jobb hátsó alsó

        [ 1.5,  0.8, -0.5],  # 2: jobb első alsó

        [-1.5,  0.8, -0.5],  # 3: bal első alsó

        [-1.5, -0.8,  0.3],  # 4: bal hátsó felső

        [ 1.0, -0.8,  0.3],  # 5: jobb hátsó felső

        [ 1.0,  0.8,  0.3],  # 6: jobb első felső

        [-1.5,  0.8,  0.3],  # 7: bal első felső

        [-0.5, -0.8,  0.8],  # 8: tető hátsó

        [ 0.5, -0.8,  0.8],  # 9: tető jobb

        [ 0.5,  0.8,  0.8],  # 10: tető első

        [-0.5,  0.8,  0.8]   # 11: tető bal

    ])

    # Az oldalak és a tető meghatározása pontindexek alapján

    faces = [

        [0, 1, 2, 3],   # Alváz

        [4, 5, 6, 7],   # Törzs felső része

        [8, 9, 10, 11], # Tető

        [0, 3, 7, 4],   # Hátfal

        [1, 2, 6, 5],   # Orrfal

        [3, 2, 6, 7],   # Jobb oldal

        [0, 1, 5, 4],   # Bal oldal

        [4, 5, 9, 8],   # Hátsó szélvédő

        [7, 6, 10, 11], # Első szélvédő

    ]

    # Karosszéria rajzolása

    body_collection = Poly3DCollection([car_body[face] for face in faces], alpha=0.6)

    body_collection.set_facecolor('red')

    body_collection.set_edgecolor('black')

    ax.add_collection3d(body_collection)

    # 2. Kerekek rajzolása (hengerekkel)

    wheel_radius = 0.3

    wheel_width = 0.2

    

    # [x, y, z] koordináták a 4 kerékhez

    wheel_positions = [

        [-1.1, -0.8, -0.5], # Bal hátsó

        [ 1.1, -0.8, -0.5], # Jobb hátsó

        [-1.1,  0.8, -0.5], # Bal első

        [ 1.1,  0.8, -0.5]  # Jobb első

    ]

    theta = np.linspace(0, 2 * np.pi, 20)

    z_values = np.linspace(-wheel_width/2, wheel_width/2, 10)

    theta, z_values = np.meshgrid(theta, z_values)

    for wx, wy, wz in wheel_positions:

        # Henger felület egyenletek

        x_circle = wheel_radius * np.cos(theta) + wx

        y_circle = np.full_like(theta, wy) + z_values

        z_circle = wheel_radius * np.sin(theta) + wz

        

        ax.plot_surface(x_circle, y_circle, z_circle, color='darkgray', edgecolor='black')

    # Tengelyek beállítása

    ax.set_xlabel('X tengely')

    ax.set_ylabel('Y tengely')

    ax.set_zlabel('Z tengely')

    # Grafikon határok beállítása, hogy arányos legyen

    ax.set_box_aspect([3, 2, 2])

    ax.set_xlim([-2, 2])

    ax.set_ylim([-2, 2])

    ax.set_zlim([-1, 1.5])

    plt.title("3D Autó - Matplotlib")

    plt.show()

if __name__ == "__main__":

    draw_car()

Sakktábla

--------

import matplotlib.pyplot as plt

import numpy as np

# A 3D vizualizáció beállítása

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

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

ax.set_box_aspect([1, 1, 0.4]) # Laposabbá teszi a táblát

# --- 1. SAKKTÁBLA LÉTREHOZÁSA ---

board_size = 8

x = np.arange(board_size)

y = np.arange(board_size)

xx, yy = np.meshgrid(x, y)

# Sakktábla mintázat (fekete-fehér)

colors = np.where((xx + yy) % 2 == 0, 'w', 'k')

# Mezők lerakása 3D-ben

for i in range(board_size):

    for j in range(board_size):

        color = 'gray' if colors[i, j] == 'w' else 'saddlebrown' # Világos/sötét mezők

        ax.bar3d(i, j, 0, 1, 1, 0.1, color=color, edgecolor='black')

# --- 2. BÁBUK DEFINIÁLÁSA ---

def draw_piece(ax, x_pos, y_pos, piece_type, color):

    z_base = 0.1  # A bábú alja a tábla tetején van

    

    # Bástya (henger)

    if piece_type == 'Rook':

        height = 0.5

        ax.bar3d(x_pos + 0.2, y_pos + 0.2, z_base, 0.6, 0.6, height, color=color)

    

    # Huszár (gúla / henger kombináció stilizálva)

    elif piece_type == 'Knight':

        height = 0.5

        x_c, y_c = x_pos + 0.5, y_pos + 0.5

        ax.plot([x_c], [y_c], [z_base + height], marker='^', markersize=25, color=color)

        ax.bar3d(x_pos + 0.3, y_pos + 0.3, z_base, 0.4, 0.4, height, color=color)

        

    # Futó (kúp / gömb)

    elif piece_type == 'Bishop':

        height = 0.6

        ax.bar3d(x_pos + 0.3, y_pos + 0.3, z_base, 0.4, 0.4, height, color=color)

        u, v = np.mgrid[0:2*np.pi:20j, 0:np.pi:10j]

        x_sphere = 0.2 * np.cos(u) * np.sin(v) + x_pos + 0.5

        y_sphere = 0.2 * np.sin(u) * np.sin(v) + y_pos + 0.5

        z_sphere = 0.2 * np.cos(v) + z_base + height

        ax.plot_surface(x_sphere, y_sphere, z_sphere, color=color)

    # Vezér (korona vagy magas henger)

    elif piece_type == 'Queen':

        height = 0.8

        ax.bar3d(x_pos + 0.25, y_pos + 0.25, z_base, 0.5, 0.5, height, color=color)

        

    # Király (kereszt vagy magas henger)

    elif piece_type == 'King':

        height = 0.9

        ax.bar3d(x_pos + 0.25, y_pos + 0.25, z_base, 0.5, 0.5, height, color=color)

    # Gyalog (kisebb henger + gömb)

    elif piece_type == 'Pawn':

        height = 0.4

        ax.bar3d(x_pos + 0.3, y_pos + 0.3, z_base, 0.4, 0.4, height, color=color)

        # Gömb a gyalog tetejére

        u, v = np.mgrid[0:2*np.pi:20j, 0:np.pi:10j]

        x_sphere = 0.2 * np.cos(u) * np.sin(v) + x_pos + 0.5

        y_sphere = 0.2 * np.sin(u) * np.sin(v) + y_pos + 0.5

        z_sphere = 0.2 * np.cos(v) + z_base + height

        ax.plot_surface(x_sphere, y_sphere, z_sphere, color=color)

# --- 3. BÁBUK FELHELYEZÉSE (Kezdőállás) ---

# Sötét bábuk (feketék)

black_color = 'darkslategray'

white_color = 'whitesmoke'

# Gyalogok elhelyezése

for i in range(8):

    draw_piece(ax, i, 1, 'Pawn', black_color)

    draw_piece(ax, i, 6, 'Pawn', white_color)

# Tisztek elhelyezése

pieces_order = ['Rook', 'Knight', 'Bishop', 'Queen', 'King', 'Bishop', 'Knight', 'Rook']

for i, piece in enumerate(pieces_order):

    draw_piece(ax, i, 0, piece, black_color)

    draw_piece(ax, i, 7, piece, white_color)

# --- 4. GRAFIKA MEGJELENÍTÉSE ---

ax.set_xlabel('X tengely')

ax.set_ylabel('Y tengely')

ax.set_zlabel('Z tengely')

ax.set_xlim(-1, 9)

ax.set_ylim(-1, 9)

ax.set_zlim(0, 2)

plt.title("3D Sakktábla Pythonban")

plt.show()

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

futtatás; https://onecompiler.com/pygame#draft-j95w

Biliárdgolyó

import pygame

pygame.init()

screen = pygame.display.set_mode((600, 400))

pygame.display.set_caption("Pygame Sample")

clock = pygame.time.Clock()

x, y, dx, dy, r = 300, 200, 4, 3, 24

running = True

while running:

    for event in pygame.event.get():

        if event.type == pygame.QUIT:

            running = False

    x += dx

    y += dy

    if x - r < 0 or x + r > 600: dx = -dx

    if y - r < 0 or y + r > 400: dy = -dy

    screen.fill((20, 24, 40))

    pygame.draw.circle(screen, (233, 30, 99), (x, y), r)

    pygame.display.flip()

    clock.tick(60)

pygame.quit()

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

Föld hold keringése

import turtle

import math

# Ablak beállítása

ablak = turtle.Screen()

ablak.bgcolor("black")

ablak.title("Naprendszer szimuláció")

# A Nap

nap = turtle.Turtle()

nap.shape("circle")

nap.color("yellow")

nap.shapesize(3, 3)

# A Föld

fold = turtle.Turtle()

fold.shape("circle")

fold.color("blue")

fold.shapesize(0.8, 0.8)

fold.up()

# A Hold

hold = turtle.Turtle()

hold.shape("circle")

hold.color("white")

hold.shapesize(0.3, 0.3)

hold.up()

szog = 0

hold_szog = 0

# Fő ciklus

while True:

    # A Föld keringése a Nap körül

    x_fold = 150 * math.cos(math.radians(szog))

    y_fold = 150 * math.sin(math.radians(szog))

    fold.goto(x_fold, y_fold)

    

    # A Hold keringése a Föld körül

    x_hold = x_fold + 30 * math.cos(math.radians(hold_szog))

    y_hold = y_fold + 30 * math.sin(math.radians(hold_szog))

    hold.goto(x_hold, y_hold)

    

    szog += 0.5      # Föld keringési sebessége

    hold_szog += 2   # Hold keringési sebessége

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

Biliárd

import turtle

import math

# Ablak beállítása

ablak = turtle.Screen()

ablak.title("Biliárdasztal szimuláció")

ablak.bgcolor("green")

ablak.setup(width=600, height=400)

# Asztal keret (dákó)

asztal = turtle.Turtle()

asztal.color("brown")

asztal.pensize(20)

asztal.penup()

asztal.goto(-290, -190)

asztal.pendown()

for _ in range(2):

    asztal.forward(580)

    asztal.left(90)

    asztal.forward(380)

    asztal.left(90)

asztal.hideturtle()

# Golyó létrehozása

golyo = turtle.Turtle()

golyo.shape("circle")

golyo.color("white")

golyo.penup()

golyo.speed(0)

# Golyó mozgási paraméterei

golyo.dx = 3

golyo.dy = 2

# Játék ciklus

while True:

    golyo.setx(golyo.xcor() + golyo.dx)

    golyo.sety(golyo.ycor() + golyo.dy)

    # Ütközés a falakkal (X tengely)

    if golyo.xcor() > 270 or golyo.xcor() < -270:

        golyo.dx *= -1

        

    # Ütközés a falakkal (Y tengely)

    if golyo.ycor() > 170 or golyo.ycor() < -170:

        golyo.dy *= -1

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

https://onecompiler.com/pygame#draft-k47t

Kollégiumi tapasztalataim

A család viselkedése, az apa és az anya viszonya, a légkör, egy tizenéves gyermek esetén gyakran torzítja el a gyermek  plasztikus személyiségét. A tanár készen kapja az elrontott gyermeket, gyakran tehetetlen szemlélője a gyermek dűhkitéseinek. A hiperaktivitás, az introvertáltság, vagy a zárkózottság, az extravertáltság, csak a jéghegy csúcsa és inkább védekezés a gyermek részéről. Az ADHD (figyelemhiányos hiperaktivitás zavar, és a OCD kényszerbetegségek is visszavezethetők a szülői családi háttér torzulásaira.A szülői felügyelet megszűnésével a strukturálatlan környezet és a közös élettér a kollégiumban gyakran felerősíti a kaotikus mindennapokat. A kollégiumi nevelő kezében nincsenek eszközök. A mobilfüggőség, a játékfüggőség és az internetfüggőség rövidre zárja a gyermekek jövájét. A felelősség hiánya, a túlzott szabadság, a rendezetlenség és a szervezetlenség, a közö élettér megosztja a felelősséget, emiatt a környezet pillanatok alatt kaotikussá válik. A folyamatosan jövő-menő szobatársak és a folyosói zajok teljesen ellehetetlenítik a fókuszálást a gyerek szétszórt és zavarosott lesz. A felelősség a szervezett élet a határidők és az előadások könnyen elmaradnak. Alvászavarok: A kötetlen éjszakai szocializáció és a felborult bioritmus súlyosbítja a napközbeni figyelmetlenséget. Éjszakai játékok, a pihenés elmaradása. A gyerek élénkitőt és stimulánst használ, energia ital, kávé, nyugtató, altaló féjdalomcsillapitók. Káosz, rendetlenség, kosz, mocsok mindenütt. Alvás és fizikai biztonság, alvási apmoe alakul ki. Használjanak aktív zajszűrős fejhallgatót nappal, éjszakára pedig fehér- vagy zöldzaj-alkalmazást a beszűrődő hangok elnyomására. Nem tudjuk a gyerekek milyen gyógyszereket tartanak titokban aszekrényükben, mert nincs joga a nevelőnek a szekrényvizetre. Házirend, elfogadása. A dyslexia (olvasási nehézség) vagy egyéb kognitív zavarok. Mozgásszervi és strukturális betegségek. Cerebrális parézis (CP): Az egyik leggyakoribb, mozgászavart okozó központi idegrendszeri rendellenesség, amely a méhen belüli vagy a szülés körüli agykárosodás következménye.Izomtónus-zavar: Rohamokkal járó és genetikai kórképek epilepszia: ismétlődő, az agyi elektromos tevékenység zavara miatt kialakuló görcsrohamokkal járó állapot. Lehet még autoimmunbetegség, gyógyszer allergia, függőség. Gyulladásos és egyéb neurológiai kórképek Neuroimmunológiai betegségek: Az idegrendszert érintő autoimmun folyamatok. Neurometabolikus zavarok: Az idegrendszer anyagcsere-betegségei. Szorongás félelem, fóbia, fejfájás és migrén: Gyermekkorban is jelentkező, rendszeres fájdalommal járó neurológiai tünet. A viselkedés, a hangulat vagy a kognitív funkciók hirtelen megváltozása, az ismétlődő fejfájás, a fejlődési mérföldkövek elmaradása, vagy a görcsös rohamok mind gyermekneurológiai vizsgálatot indokolnak.Az idegrendszeri betegségek tüneteiről és hivatalos ellátási formáiról tájékozódhat az Egészségvonal oldalán, vagy a ritkább, komplex kórképekkel kapcsolatban. A gyermekkori viselkedészavarok gyakran dühkitörésekben, agresszióban, szabályszegő vagy destruktív viselkedésben nyilvánulnak meg. Ezek mögött sokszor mélyebb érzelmi, családi vagy környezeti problémák húzódnak. A tünetek felismerése és a megfelelő támogatás kulcsfontosságú a gyermek fejlődése szempontjából.A gyermekkori viselkedészavarok mögött gyakran neurológiai vagy pszichés tényezők állnak. A viselkedészavar fogalmát gyakori félreérté övezi. Ilyen esetekben nem arról van szó, hogy a gyermek „rossz” lenne, hanem arról, hogy eltérő módon fejlődik az idegrendszere, így bizonyos dolgokra másképp reagál, más reakciói lesznek. A gyermekkori viselkedészavar felderítésében, kivizsgálásában gyermekneurológus tud segítséget nyújtani.Mi az a gyermekkori viselkedészavar? A gyermekkori viselkedészavarok egyre inkább a figyelem középpontjába kerülnek, mind a szülők, mind pedig a pedagógusok, szakemberek részéről. A viselkedészavar egy gyűjtőfogalom, mely olyan állapotokat takar, melyekben a gyermek magatartása hosszabb időn keresztül jelentősen eltér a kortársai viselkedésétől olyan mértékben, hogy az nehezíti az iskolai beilleszkedést és a szociális életét. A viselkedészavar nem egy-egy alkalmi dühkitörés vagy hiszti, hanem ismétlődő viselkedési minták, melyek a gyermek életkorának megfelelő normákat túllépik. Ilyen intenzív viselkedési minta például, amikor a gyermek gyakran megszegi a szabályokat, engedetlenül, agresszívan viselkedik, impulzív, esetleg dühkitörései/dührohamai vannak. Előfordulhat, hogy ezek a tünetek neurológiai, de akár pszichiátriai zavar részeként jelennek meg. Mi a gyermekkori viselkedészavar oka? A viselkedészavarok kialakulásának hátterében több tényező áll. Ezek között lehetnek biológiai, környezeti és pszichológiai okok, melyek egyaránt szerepet játszhatnak. Neurológiai szempontból gyakran meghatározhatók genetikai hajlamok, melyek az idegrendszer eltérő működését okozhatják. Például ADHD és autizmus esetében gyakran előfordul családi halmozódás. A gyermekkori viselkedészavar kialakulásának kockázatát növelhetik az agy fejlődési rendellenességei, koraszülés, oxigénhiányos állapotok. Az idegrendszer működésének zavara befolyásolja, hogy a gyermek mennyire képes szabályozni a viselkedését és értelmezését. Összességében tehát az alábbi tényezők állhatnak leggyakrabban a gyermekkori viselkedészavar mögött: genetikai tényezők: sok esetben megfigyelhető családi halmozódás (pl. ADHD) neurológiai eltérések: agyfejlődési zavarok, koraszülöttség, epilepszia neurokémiai egyensúlyzavar: ingerület átvivő anyagok szintjének eltérései (dopamin, szerotonin) környezeti hatások: traumák, bántalmazás, elhanyagolás A viselkedés szabályozásért felelős agyi területek, különösen a prefrontális kéreg, a frontális lebenyekben található funkciók csak az iskoláskor végére fejlődnek ki teljesen. Ez azt jelenti, hogy a fiatalabb gyerekek érzelmi szabályozása még kezdetleges, ezért természetesen is lehet impulzívabb. Azonban, ha ez a fejlődés jelentősen lelassul vagy eltér a normálistól, akkor alakulhatnak ki a gyermekkori viselkedészavarok. A gyermekkori viselkedészavar tünetei A gyermekkori viselkedészavar tünetei változatosak lehetnek, többféle módon mutatkozhatnak meg. Fontos, hogy akkor lehet gyermekkori viselkedészavarról beszélni, ha a tünetek hosszabb ideje, tartósan (kb. legalább 6 hónapja) fennállnak. A tünetek attól függnek, hogy milyen típusú viselkedészavarról van szó, azonban elmondható, hogy az alábbi tünetek utalhatnak arra, hogy erről van szó:Gyermekkori viselkedészavar 

•  nehézség a figyelem fenntartásában
• állandó mozgásigény, nyugtalanság
• szabályok figyelmen kívül hagyása
• impulzivitás, meggondolatlan cselekedetek
• társas helyzetben visszahúzódás
• gyakori dühkitörések, agresszió
• szorongás, félelem, indokolatlan stressz
• érzelemszabályozási nehézségek
• hiperaktivitás

Ezek a tünetek tehát utalhatnak gyermekkori viselkedészavarra, azonban nem szabad megijedni, ha egy-egy alkalommal ezek előfordulnak. Ugyanakkor mindenképpen fel kell keresni gyermek neurológust, ha a tünetek állandóan jelen vannak, hosszabb ideje. A  gyermekkori viselkedészavar fajtái A gyermekkori viselkedészavarok több típusa ismert, melyek különböző neurológiai és pszichológiai jellemzőkkel bírnak. A leggyakrabban előforduló típusok közé tartozik az ADHD, az autizmus, az oppozíciós magatartászavar és a magatartászavar, szorongásos és depressziós zavarok.  ADHD – figyelemhiányos hiperaktivitási-zavar Az ADHD talán a leggyakoribb gyermekkori viselkedészavar. Jellemzője, hogy a gyermek nehezen figyel oda, rendkívül mozgékonyak, izegnek-mozognak, nem tudnak várni a sorukra. Az ADHD mögött az agy dopamin- és noradrenalin-rendszerének működési zavara áll. Tehát az ADHD-ról egyértelműen kijelenthető, hogy nem nevelési probléma áll a zavar hátterében, hanem valódi, bizonyítható idegrendszeri eltérésről van szó.  Autizmus spektrumzavar (ASD) Az autizmus spektrumzavar esetében arról van szó, hogy a gyermek nehezebben értelmezi a társas helyzeteket. Ide tartozhat az, hogy szokatlanul kommunikál vagy éppen nem reagál másokra. Gyakran végez ismétlődő mozgásokat, érdeklődési köre szűk. Jellemző továbbá a szenzoros érzékenység. Az autizmus az ADHD-hoz jellemzően szintén neurológiai eredetű fejlődési zavar, melynek genetikai háttere is ismert. Oppozíciós magatartászavar (ODD) Az oppozíciós magatartászavarnál gyakori a dacosság, a felnőttek, idősebbek szándékos bosszantása, a szabályok rendszeres megszegése, illetve a gyakran megjelenő dühkitörések. Az ODD már egészen kiskorban, gyakran óvodáskorban jelentkezik, és sokszor társul hozzá ADHD vagy szorongásos zavar.  Magatartászavar (Conduct Disorder) Az oppozíciós magatartászavarral ellentétben a magatartászavar egy súlyosabb forma. A viselkedészavar jellemzője, hogy a gyermek mások testi -, és vagy lelki épségét veszélyeztetni. Gyakran agresszív, gyakran hazudik, rongál vagy lop. Ilyen esetben mielőbbi szakemberi beavatkozás szükséges, mert az a típus felnőttkorban is folytatódhat.  Szorongásos és depressziós zavarok Ugyan ezek nem tipikus gyermekkori viselkedészavarok, azonban egyes tünetek egyezhetnek. Gyakran jelentkezik visszahúzódás, ingerlékenység, koncentrációs nehézség. Azért fontos megemlíteni, mert a belső feszültség gyermekek esetében könnyebben és gyakrabban viselkedésben csapódik le.  A gyermekkori viselkedészavar kivizsgálása A gyermekkori viselkedészavar kivizsgálásának célja, hogy feltárja a gyermek viselkedésének hátterében álló tényezőket. A kivizsgálás során a pontos anamnézis felvétel elsődleges, mert sok mindenben segítheti a gyermekneurológust. Elsődleges információ a gyermek fejlődési és egészségügyi előzményei; ennek része lehet a terhesség alatti és születés közbeni történések, esetleges koraszülés, idegrendszeri sérülések vagy korábbi betegségek feltérképezése. Ezek az információk mind azért lehetnek fontosak, mert segítenek feltérképezni, hogy volt-e olyan történés, ami befolyásolhatta az idegrendszer fejlődését.  Gyermekkori viselkedészavar - Neurológiai Központ  A családtagok pszichés állapota, a nevelési szokások, a gyermek társas környezete is mind hatással lehetnek a viselkedés alakulására. A neurológiai vizsgálat segít feltárni, hogy van-e a gyermekkori viselkedészavar mögött valamilyen organikus ok vagy egyéb neurológiai eltérés. Ilyen esetben képalkotó vizsgálatok segíthetnek a diagnózis felállításában.   A gyermekkori viselkedészavar kezelése A gyermekkori viselkedészavar kezelése során figyelembe kell venni, hogy milyen jellegű eltérésről van szó. Ez lehet neurológiai, pszichológiai, illetve környezeti tényező is; ezek gyakran együtt is jelen lehetnek, különösen a neurológiai és pszichológiai tényezők. A kezelés célja a gyermek életminőségének javítása, az érzelmi, szociális és kognitív fejlődés elősegítése.  Alapvetően a legfontosabb, hogy a gyermek megtanulja felismerni a saját viselkedési mintázatait, és ezekhez önszabályozó stratégiákat sajátít el. A kognitív viselkedésterápia idősebb gyermekek esetében lehet hatékony. Ezekben egy iskolapszichológus, neuropszichológus tud segíteni.  Bizonyos esetekben, különösen ADHD vagy súlyosabb magatartászavar esetén gyógyszeres kezelés is szükséges és indokolt lehet. A megfelelően beállított gyógyszerek (stimulánsok, figyelemjavító szerek) segítenek az agyi neurotranszmitterek működésének kiegyensúlyozásában. Ezzel tulajdonképpen a figyelmi és önszabályozási funkciók „támogatást” kapnak. A gyermekkori viselkedészavar kezelése nagyban függ attól, hogy milyen jellegű a viselkedészavar. A kezelés minden esetben személyre szabott, figyelembe véve a gyermek sajátosságait is.

Rajz pythonnal

import matplotlib.pyplot as plt

import numpy as np

# Az ablak beállítása

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

ax.set_facecolor('#1a1a1a') # Sötét háttér

# --- Karosszéria ---

car_x = np.array([-3, -2.5, -1, 1.5, 3.2, 3.5, 3.3, 2, 1, -1.5, -3, -3])

car_y = np.array([0, 0, 1, 1.4, 1.4, 0.8, 0.3, 0.3, 0.6, 0.6, 0.3, 0])

ax.fill(car_x, car_y, color='#E50914', zorder=2) # Piros sportautó

# --- Szélvédő és Ablakok ---

window_x = np.array([-0.8, 0.8, 1.8, 1.3, -0.6])

window_y = np.array([1.2, 1.2, 0.8, 0.8, 0.8])

ax.fill(window_x, window_y, color='#8AB4F8', zorder=3) # Világoskék üveg

# --- Kerekek ---

# Első kerék

theta = np.linspace(0, 2*np.pi, 100)

wheel1_x = 0.6 + 0.6 * np.cos(theta)

wheel1_y = 0.3 + 0.6 * np.sin(theta)

ax.fill(wheel1_x, wheel1_y, color='#212121', zorder=4)

ax.fill(wheel1_x * 0.7, wheel1_y * 0.7, color='#E0E0E0', zorder=5)

# Hátsó kerék

wheel2_x = -2.2 + 0.6 * np.cos(theta)

wheel2_y = 0.3 + 0.6 * np.sin(theta)

ax.fill(wheel2_x, wheel2_y, color='#212121', zorder=4)

ax.fill(wheel2_x * 0.7 + (-0.6 * 0.3), wheel2_y * 0.7, color='#E0E0E0', zorder=5)

# --- Első és hátsó lámpák ---

# Fényszóró

headlight_x = np.array([3.2, 3.5, 3.4])

headlight_y = np.array([0.8, 0.8, 0.6])

ax.fill(headlight_x, headlight_y, color='#FFFF00', zorder=3)

# Hátsó lámpa

taillight_x = np.array([-2.8, -3.0, -3.0, -2.8])

taillight_y = np.array([0.6, 0.6, 0.4, 0.4])

ax.fill(taillight_x, taillight_y, color='#FFA500', zorder=3)

# --- Spoiler (Hátsó szárny) ---

spoiler_x = np.array([2.8, 3.2, 3.2, 2.8])

spoiler_y = np.array([0.3, 0.3, 0.8, 0.9])

ax.fill(spoiler_x, spoiler_y, color='#333333', zorder=2)

# Koordinátatengelyek elrejtése a szép vizuális élményért

ax.set_xlim(-4, 4)

ax.set_ylim(-0.5, 2.5)

ax.axis('off')

# Megjelenítés

plt.title("Sportautó Matplotlib-pel", color='white', fontsize=16)

plt.show()

Palcikaember

import matplotlib.pyplot as plt

def ember_rajzolas():

    # Új rajzfelület (ablak) létrehozása

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

    

    # 1. Fej (Kör)

    # Paraméterek: középpont (x, y), sugár

    fej = plt.Circle((0, 3.5), 0.7, color='black', fill=False, linewidth=3)

    ax.add_patch(fej)

    

    # 2. Törzs (Vonal)

    # Paraméterek: [x1, x2], [y1, y2]

    ax.plot([0, 0], [2.8, 1.0], color='black', linewidth=3)

    

    # 3. Karok (Vonalak)

    ax.plot([0, -1.0], [2.5, 2.0], color='black', linewidth=3) # Bal kar

    ax.plot([0, 1.0], [2.5, 2.0], color='black', linewidth=3)  # Jobb kar

    

    # 4. Lábak (Vonalak)

    ax.plot([0, -0.8], [1.0, 0], color='black', linewidth=3)   # Bal láb

    ax.plot([0, 0.8], [1.0, 0], color='black', linewidth=3)    # Jobb láb

    # Grafikon beállítások a szép arányokért és megjelenésért

    ax.set_xlim(-2, 2)

    ax.set_ylim(-0.5, 5)

    ax.set_aspect('equal')

    ax.axis('off') # A rácsvonalak eltüntetése

    

    # A rajz megjelenítése

    plt.title("Emberi test (pálcikaember)", fontsize=14)

    plt.show()

# Program futtatása

ember_rajzolas()

Az emberi agy felépítése

import numpy as np

import matplotlib.pyplot as plt

# Agyféltekék kontúrjai matematikai görbékkel (polinomok és hullámok)

theta = np.linspace(0, 2 * np.pi, 1000)

# Bal és jobb agyfélteke külső íve

x_left = -2.5 * np.cos(theta) - np.cos(5 * theta) / 2

y_left = 1.5 * np.sin(theta) + np.sin(3 * theta) / 3

x_right = 2.5 * np.cos(theta) + np.cos(5 * theta) / 2

y_right = 1.5 * np.sin(theta) + np.sin(3 * theta) / 3

# Kérges test (Corpus Callosum) - a két félteke összekötése

x_mid = np.linspace(-1.5, 1.5, 200)

y_mid = -0.1 * x_mid**2 + 0.2

# Agyhullámok/sulcusok (redők) szimulációja

x_waves = np.linspace(-2.0, 2.0, 100)

y_waves = 0.1 * np.sin(15 * x_waves) * np.exp(-x_waves**2 / 2)

# Rajzfelület inicializálása

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

# Kontúrok megrajzolása

plt.plot(x_left - 0.5, y_left, color='#E74C3C', linewidth=3, label='Bal félteke')

plt.plot(x_right + 0.5, y_right, color='#3498DB', linewidth=3, label='Jobb félteke')

plt.plot(x_mid, y_mid, color='#9B59B6', linewidth=4, label='Kérges test')

# Belső barázdák kirajzolása ismétlődő mintákkal

for i in np.linspace(-1.0, 1.0, 5):

    plt.plot(x_waves + i, y_waves + i/2, color='#2C3E50', alpha=0.6)

    plt.plot(x_waves + i, y_waves - i/2, color='#2C3E50', alpha=0.6)

# Kisagy (Cerebellum) szimuláció

x_cerebellum = np.linspace(-1.8, -0.5, 200)

y_cerebellum = -1.2 - np.sqrt(1 - ((x_cerebellum + 1.1) / 0.7)**2) * 0.8

plt.plot(x_cerebellum, y_cerebellum, color='#F39C12', linewidth=3, label='Kisagy')

# Beállítások a letisztult megjelenésért

plt.title('Emberi agy stilizált ábrázolása', fontsize=16)

plt.axis('off') # Tengelyek eltüntetése

plt.legend(loc='upper right')

# Megjelenítés

plt.show()

Mandelbrot halmaz szimuláció pythonban

A Mandelbrot-halmaz egy síkbeli alakzat, amelyet egy alapvetően nagyon egyszerű algebrai összefüggés bonyolultabb (végtelennel kapcsolatos, analitikus fogalmakat, határértékszámítást igénylő) elemzése ad meg, rajzol ki. Ezeknek az összefüggéseknek a még legegyszerűbb (bár nem az egyetlen lehetséges) megközelítési módja a komplex számok felhasználásával történhet. A Mandelbrot-halmaz a komplex számsíkon ábrázolható alakzat, amely számsík geometriailag semmiben sem különbözik a jól ismert („euklideszi”) síktól, csak a pontok számokkal való leírása más.

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

import numpy as np

import matplotlib.pyplot as plt

def mandelbrot(h, w, max_iter=256):

    """Létrehozza a Mandelbrot-halmazt numpy tömbként."""

    y, x = np.ogrid[-1.5:1.5:h*1j, -2.5:0.5:w*1j]

    c = x + 1j * y

    z = c

    divtime = max_iter + np.zeros(z.shape, dtype=int)

    for i in range(max_iter):

        z = z**2 + c

        diverge = z * np.conj(z) > 2**2  # Divergencia vizsgálata

        div_now = diverge & (divtime == max_iter)

        divtime[div_now] = i

        z[diverge] = 2  # Megelőzi a túlcsordulást

    return divtime

# A kép felbontása (növelésével szebb, de lassabb lesz a kép)

width, height = 1000, 800

iterations = 100

# Szimuláció futtatása

fraktal = mandelbrot(height, width, max_iter=iterations)

# Látványos megjelenítés

plt.figure(figsize=(10, 8), dpi=150)

plt.imshow(fraktal, extent=[-2.5, 0.5, -1.5, 1.5], cmap='twilight_shifted')

plt.axis('off') # Eltünteti a tengelyeket a látványért

plt.title("Mandelbrot-halmaz", color='white', fontsize=14)

# Háttérszín feketére állítása a szebb kontrasztért

ax = plt.gca()

ax.set_facecolor('black')

plt.show()

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

Eredmény;

A Mandelbrot-halmaz körlapjainak és a szatelliták kardiodlapjainak a határciklusai az adott lapra jellemző hosszúságúak. Ezeknek a lapoknak a helye egyértelműen megadja a határciklusok hosszát. Minden körlap érintkezik egy alaptesttel, egy nagyobb körlappal, vagy kardioiddal.

Egy lap határciklusainak hossza megegyezik az ugyanazt az alaptestet érintő két nála nagyobb szomszédos lap határciklusainak hosszának összegével. Ha csak kisebb lapok vannak, akkor az alaptest járul hozzá az összeghez. A leghíresebb próbálkozás a Mandelbulb, egy háromdimenziós szerkezet, amit a térbeli Mandelbrot-halmaznak is neveznek.

import math

import random

from PIL import Image

# K p m rete

imgx = 512

imgy = 512

image = Image.new("RGB", (imgx, imgy))

pixels = image.load()

# Param terek

maxIt = 128  # Maxim lis iter ci s sz m

power = 8    # A Mandelbulb hatv nya

xa = -1.5

xb = 1.5

ya = -1.5

yb = 1.5

# V letlenszer  forgat si sz gek a 3D t r 2D-s lek pez s hez

pi2 = math.pi * 2.0

xy = random.random() * pi2

xz = random.random() * pi2

yz = random.random() * pi2

sxy = math.sin(xy); cxy = math.cos(xy)

sxz = math.sin(xz); cxz = math.cos(xz)

syz = math.sin(yz); cyz = math.cos(yz)

# Iter ci s folyamat

for i in range(imgx):

    for j in range(imgy):

        # Koordin t k normaliz l sa

        x0 = xa + (xb - xa) * i / imgx

        y0 = ya + (yb - ya) * j / imgy

        z0 = 0.0

        # Forgat s a 3D t rben

        # X tengely k r li forgat s

        x1 = x0

        y1 = y0 * cxy - z0 * sxy

        z1 = y0 * sxy + z0 * cxy

        # Y tengely k r li forgat s

        x2 = x1 * cxz + z1 * sxz

        y2 = y1

        z2 = -x1 * sxz + z1 * cxz

        # Z tengely k r li forgat s

        x = x2 * cyz - y2 * syz

        y = x2 * syz + y2 * cyz

        z = z2

        

        cx, cy, cz = x, y, z # Kezd pont (C)

        

        # Mandelbulb iter ci 

        for iteration in range(maxIt):

            r = math.sqrt(x*x + y*y + z*z)

            if r > 2.0:

                # Sz nez s az iter ci k sz ma alapj n

                brightness = int(iteration * 255 / maxIt)

                pixels[i, j] = (brightness, brightness // 4, brightness // 2)

                break

            

            # G mbkoordin t k sz m t sa

            theta = math.atan2(math.sqrt(x*x + y*y), z)

            phi = math.atan2(y, x)

            

            # Hatv nyoz s  s a pont eltol sa

            zr = r ** power

            theta = theta * power

            phi = phi * power

            

            # Vissza a Descartes-koordin tarendszerbe

            x = zr * math.sin(theta) * math.cos(phi) + cx

            y = zr * math.sin(theta) * math.sin(phi) + cy

            z = zr * math.cos(theta) + cz

        else:

            # Ha a pont a halmaz r sze marad

            pixels[i, j] = (0, 0, 0)

# A k p ment se  s megjelen t se

image.save("mandelbulb_cross_section.png")

image.show()

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

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