Egy feladat különböző megoldásai Pythonban

Ebben a bejegyzésben szeretném megmutatni, hogyan oldjunk meg egy feladatot különböző módokon. A leghosszabb megoldás használható az alacsonyabb szintű programnyelvekben is (C, Java stb.), viszont a Python rövidítési lehetőségeit kihasználva gyors és rövid programot kapunk.

A feladat: írassuk ki egymás után, vesszővel és helyközzel elválasztva a négyzetszámokat ezerig.

Első körben elemezzük a feladatot: mi az a négyzetszám, mennyi lehet belőle, megtalálom-e máshol is a megoldást, hogy tudjam majd magam ellenőrizni stb. Lényeg az, hogy 1, 2, 3... négyzetéről, vagyis 1, 4, 9, ... számokról van szó, egészen 1000-ig.

Ezt az alacsony szintű programnyelvekben úgy tudjuk megoldani, hogy listába gyűjtjük a négyzetszámokat ezerig, utána kiírjuk őket figyelve arra, hogy az utolsó után ne legyen vessző. Van olyan programozó, aki úgy írja a programot, hogy csak 1000-re legyen jó és van aki úgy, hogy ha másik számot adnak meg, akkor is működjön.

• Vezessünk be egy cel változót a max. számnak (cél, érted, most 1000 leszaz értéke :-).
• Alkossunk egy üres listát a négyzetszámokhoz: negyzet.
• Egy ciklussal töltsük fel a négyzetszámokkal.
• Írassuk ki úgy, hogy az utolsó előtti számig legyen a számok között vessző és szóköz, az utolsónál ne legyen - ezt külön írjuk ki.

cel = 1000
negyzet = []
i = 1
while i**2<=cel:
    negyzet.append(i**2)
    i += 1
for j in range(len(negyzet)-1):
    print(negyzet[j],end=", ")
print(negyzet[-1])

Ez szépen működik, az eredmény 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576, 625, 676, 729, 784, 841, 900, 961

Van egy olyan verzió is, ahol végtelen ciklust hozunk létre és ha a négyzetszám meghaladja a célt, kiugrunk a ciklusból:

cel = 1000
negyzet = []
i = 1
while True:
    if i**2>cel:
        break
    negyzet.append(i**2)
    i += 1
for j in range(len(negyzet)-1):
    print(negyzet[j],end=", ")
print(negyzet[-1])

Megcsinálhatjuk for ciklussal ugyanezt, nyilván a cél négyzetgyöke + 1-ig (vagyis a 0,5-ödik hatványa + 1-ig) kell menni vele. Ekkor rövidül a programkód, de már van benne egy kis matek.

cel = 1000
negyzet = []
for i in range(1,int(cel**0.5)+1):
    negyzet.append(i**2)
for j in range(len(negyzet)-1):
    print(negyzet[j],end=", ")
print(negyzet[-1])

Tovább rövidíthetünk, ha kihasználjuk a Python egyik rövidítési lehetőségét, vagyis hogy listát közvetlenül tudunk for-ral létrehozni. Ez a Python egy magas szintű lehetősége, aknázzuk kis a benne rejlő lehetőséget!

cel = 1000
negyzet = [i**2 for i in range(1,int(cel**0.5)+1)]
for j in range(len(negyzet)-1):
    print(negyzet[j],end=", ")
print(negyzet[-1])

A fenti megoldásoknál figyelni kellett a vesszőre kiíráskor: külön kellett kezelni az utolsó elemet. Ezt megteszi helyettünk a join() függvény, ami egy stringekből álló lista elválasztó jeles kiírására alkalmas. Vagyis a listába a négyzetszámok string alakjait tegyük be! Ekkor már csak 3 soros a programunk, és még mindig könnyen olvasható:

cel = 1000
negyzet = [str(i**2) for i in range(1,int(cel**0.5)+1)]
print(", ".join(negyzet))

Ha nem vezetünk be külön változót a célnak és a lista létrehozását berakjuk a join utasításba, egy sorban megoldható a program:

print(", ".join([str(i**2) for i in range(1,int(1000**0.5)+1)]))

Van aki azt gondolja, hogy a magas szintű jellemzők alkalmazása lelassítja a program futását. Hát nem! Az utolsó verzió 0,0156 másodperc alatt fut le, a legelső 0,156 alatt. Tízszeres időkülönbség!