2. hét - Feladatok

Másodfokú egyenlet gyökei

Kérje be a program egy másodfokú egyenlet a, b, és c tényezőit, és számolja ki, hogy hány valós gyöke van az egyenletnek!

import math

a = float(input("Adja meg az a értékét: "))
b = float(input("Adja meg az b értékét: "))
c = float(input("Adja meg az c értékét: "))

D = b ** 2 - 4 * a * c

if D > 0:
    # Két megoldás lesz
    x1 = (-b + math.sqrt(D)) / (2 * a)
    x2 = (-b - math.sqrt(D)) / (2 * a)
    print(f"x1 = {x1}")
    print(f"x2 = {x2}")
elif D == 0:
    # Egy megoldás lesz
    x = (-b) / (2 * a)
    print(f"x = {x}")
else:
    print("Nincs valós megoldás.")

Elvárt kimenetek:

#  a   b   c   kimenet
#  2  -1  -6   x1 = 2, x2 = -1.5
#  2  -4   2   x = 1
#  1   2  10   Nincs valós gyök

Tartály

Szeretnénk egy tartály lefesteni (zárt henger) Egy vödör festékkel 2nm felületet lehet lefesteni.

A program kérje be a tartály sugarát és magasságát. Adja meg, hogy hány vödör festéket kell venni.

import math

# Felület: 2 * r * math.pi * h + 2 * r ** 2 * math.pi

r = float(input("Adja meg a henger sugarát: "))
h = float(input("Adja meg a henger magasságát: "))

palast = 2 * r * math.pi * h
alap = r ** 2 * math.pi

A = alap * 2 + palast
vodor = math.ceil(A / 2)

print(f"A tartály lefestéséhez {vodor} db vödörre lesz szükség.")

Példa kimenet:

# Magasság: 2
# Sugár: 0.6
# Megoldás 5 vödör kell.

Prímtényezős felbontás

Bemenet: egész szám

Kiírni: prímtényezők

Megvalósítandó algoritmus:

# BE: x

# oszto = 2

# CIKLUS x > 1
#     HA oszto-vel osztható
#         x = x / oszto
#         KI: oszto
#     HA NEM osztható oszto-val
#         oszto = oszto + 1
# CIKLUS VÉGE

x = int(input("Adjon meg egy számot: "))
oszto = 2
while x > 1:
    if x % oszto == 0:
        print(oszto)
        x = x / oszto
    else:
        oszto = oszto + 1

Számsorok

import random

szamsor = []

for i in range(100):
    szamsor.append(random.randint(1, 100))

legkisebb = 0
legnagyobb = 0
osszeg = 0
szorzat = 1

for i,n in enumerate(szamsor):
    if n < szamsor[legkisebb]:
        legkisebb = i
    if n > szamsor[legnagyobb]:
        legnagyobb = i
    osszeg += n
    szorzat *= n

print(f"A sorozat legkisebb eleme: {szamsor[legkisebb]} (a sorozat {legkisebb}. eleme)")
print(f"A sorozat legnagyobb eleme: {szamsor[legnagyobb]} (a sorozat {legnagyobb}. eleme)")
print(f"A sorozat elemeinek összege: {osszeg}")
print(f"A sorozat elemeinek szorzata: {szorzat}")

Fogyasztás

Elindulunk egy útra tele tankkal. Döntse el, hogy az út során kell-e tankolni.

Be: fogyasztás (liter/100km), tank méretét (liter), megtett út hossza (km)

fogyasztas = float(input("Adja meg a fogyasztást [liter/100km]: "))
tank = float(input("Adja meg a tank méretét [liter]: "))
ut = float(input("Adja meg az út hosszát [km]: "))

# fogyasztas: liter / 100km
# tank:       liter
# max_ut:     km
max_ut = tank / fogyasztas * 100

if max_ut > ut:
    print("Nem kell megállni tankolni.")
else:
    print("Meg kell állni tankolni az út során.")

Faktoriális

A program adja meg a bemeneti szám faktoriálisát!

Az órán a breakpointok és a debugger használatát néztük meg ezen a példán keresztül.

# n! = 1 * ... * n-1 * n

n = int(input("Adjon meg egy számot: "))

x = 1

for i in range(1, n + 1):
    x = x * i

print(f"n! = {x}")

Sziget

Bemenet: random generált 1000 elemű sorozat [-100;100]

1. rész: minden n<0 írjunk át 0-ra

[-1, -5, 2, 5, -7, 12] -> [ 0, 0, 2, 5, 0, 12]

2. rész: legtöbb elemből álló sziget megkeresése

import random

szamsor = []

for i in range(1000):
    uj = max(0, random.randint(-100, 100))
    szamsor.append(uj)

legnagyobb_sziget_index = -1
legnagyobb_sziget_meret = -1

sziget_index = 0
sziget_meret = 0

szamsor.append(0)

for i in range(len(szamsor)):
    print(i)

for i,n in enumerate(szamsor):
    if n > 0:
        if sziget_meret == 0:
            sziget_index = i
        sziget_meret = i - sziget_index + 1
    else:
        if sziget_meret > legnagyobb_sziget_meret:
            legnagyobb_sziget_index = sziget_index
            legnagyobb_sziget_meret = sziget_meret
        sziget_meret = 0

start = legnagyobb_sziget_index
end = legnagyobb_sziget_index + legnagyobb_sziget_meret
legnagyobb_sziget = szamsor[start-1:end+1]
print(legnagyobb_sziget)

Sziget (egyszerűbb változat)

Generáljunk egy 1000 elemű tömböt, melynek elemei az [-100;100] tartományba esnek.

Egy szigetnek számít az összes egymást követő pozitív szám.

1. rész: minden n<0 írjunk át 0-ra

2. Határozzuk meg a szigetek számát

import random

szamsor = []

for i in range(1000):
    szamsor.append(random.randint(-100, 100))

# 1. rész
for i,n in enumerate(szamsor):
    if n < 0:
        szamsor[i] = 0

# 2. rész
sziget_szam = 0
elozo_pozitiv = False
szamsor.append(0)
for i,n in enumerate(szamsor):
    if n > 0:
        elozo_pozitiv = True
    elif elozo_pozitiv == True:
        sziget_szam += 1
        elozo_pozitiv = False

print(f"Szigetek száma: {sziget_szam}")

Szöveg léptetés

Várt kimenet:

# P i t a g o r a s z
# i t a g o r a s z P
# t a g o r a s z P i
# a g o r a s z P i t
# ...
# z P i t a g o r a s

Algoritmus:

# CIKLUS 10-szer
#     CIKLUS a tömb kiírásához... # Csak kiírás, nem változik tömb
#     CIKLUS VÉGE

#     CIKLUS a léptetéshez... # Itt változik a tömb, nincs kiírás
#     CIKLUS VÉGE
# CIKLUS VÉGE

nev = ['P', 'i', 't', 'a', 'g', 'o', 'r', 'a', 's', 'z']

for i in range(10):
    for c in nev:
        print(c, end=" ")
    print("")

    elso = nev[0]
    for i in range(len(nev) - 1):
        nev[i] = nev[i+1]
    nev[9] = elso

print("MÁSIK MEGOLDÁS")

for i in range(10):
    for c in nev:
        print(c, end=" ")
    print("")
    nev.append(nev[0])
    del nev[0]