Ma egymásba ágyazunk két while-ciklust. Ez azt jelenti, hogy az egyik ciklus a másik ciklus belsejében van.
Ennek kapcsán jut eszembe, hogy van egy furcsa állás is: a beágyazott szoftverfejlesztő, ahol a szoftverfejlesztőt beágyazzák. Hogy hova, az attól függ: leggyakrabban egy másik szoftverfejlesztőbe. Ja nem, mégis inkább arról lehet szó, hogy a fejvadászok nem értik, hogy mi a pék az, akit keresnek, meg a helyesírással is hadilábon állnak: az állás neve természetesen beágyazottszoftver-fejlesztő, azaz olyan szoftverfejlesztő, aki beágyazott szoftvereket fejleszt.
Na, most, hogy kipanaszkodtam és -gúnyolódtam magam, vissza az egymásba ágyazott ciklusokhoz:
A programunk, az ő teljes dicsfényében:
sor = 0 while sor < 25: oszlop = 0 while oszlop < sor+1: #ez a ciklus felel egy sor kiírásáért print('O', end='') oszlop += 1 print('') sor += 1
Nagyon feltűnő benne a behúzások szerepe: a belső ciklus sorai kétszer annyira vannak behúzva, mint a külsőé. Mintegy mellékesen megismerkedünk a print egy újabb paraméterével, az end-del. Az end apalértelmezett értéke ‘\n’ azaz newline, azaz soremelés, azaz a print, ha másként nem szólunk, soremeléssel zárja a kiírást.
Természetesen annyi ciklust ágyazol egymásba, amennyit nem szégyellsz. Még azt is elmondom, hogy a fenti feladat megvalósítása tipikusan nem előltesztelő ciklussal történik (mi ilyennel csináltuk), hanem számlálóssal, de a Pythonban ilyen nincs, ahogy azt már a múltkor említettem neked. Majd megtanuljuk szimulálni a bejárós ciklussal, ami viszont van, és nagyon remek, és akkor még visszatérünk ehhez a feladathoz.
Feladatok:
A feladatokról már rég mondtam, úgyhogy ismét elmondom: először megpróbálod egyedül megoldani őket, és csak akkor lesel, ha nem megy. Ha már az elején lesel, átvágod magadat:P
F0011a: Módosítsd a fenti programot úgy, hogy minden sorban csak az utolsó O-t írja ki, azaz a végére kapjunk egy átlót O-betűkből! (Megoldás itt.)
F0011b: Módosítsd úgy az a) feladat megoldását, hogy az O-betű jobbra-balra ingázzon a képernyőn, mondjuk tízszer! (Megoldás itt.)
F0011c: Oldd meg a 3x+4y=52 egyenletet, keresd meg az összes megoldást a természetes számok halmazán! Két egymásba ágyazott ciklust érdemes használnod, a külső az egyik változót pörgeti, a belső a másikat. (Megoldás itt.) (A feladat Zsakó László et al: Programozási feladatok, Kossuth, 1997-ből származik.)
F0011d: Ezt a feladat az előzőhöz képest nem ad újdonságot, csak a begyakoroltatás a célja. Ne az előző feladat átírásával, hanem a nulláról oldd meg! Bergengócia piacán 102 tallérért almát vettünk. A jonatán 15 tallérba, a golden 12 tallérba kerül darabonként. Melyikből hány darabot vásároltunk? (A feladat Juhász-Kiss: Programozási Ismeretek, Műszaki, 2011-ből származik.)
F0011e: Az előző két feladat bármelyikét írd át úgy, hogy az első megoldás megtalálása után nyugodjon meg, és ne keressen többet! Súgok: érdemes a while feltételét úgy átírni, hogy egy logikai változótól (van_e_megoldás_már) függjön a ciklusba való belépés, és amikor találunk megoldást, állítsuk True-ra ennek a változónak az értékét.
A múltkor a végtelen ciklusból igyekeztünk kilépni. Legközelebb megismerkedünk a véletlenszámokkal, a modulokkal és a konstansokkal.
Kedves raerek!
Az nem baj, ha nekem könnyebb úgy gondolkodni hogy a ciklusokban a számlálást mindig 1-ről indítom, nem pedig 0-ról? Mert így ugye azt tudjuk mondani, hogy az első sorban a változó értéke 1, a második sorban 2 stb.. Vagy inkább szokjam meg a 0-ról indítást, mert később, bonyolultabb kódoknál ennek lesz jelentősége?
A másik kérdés, csak mert korábban már hangsúlyoztad, hogy a pythonban egy dolgot többféleképpen is lekódolhatunk, csak az egyik megoldás nagyon elegáns, a másik viszont nem “pythonos”: oszlop < sor + 1 helyett nem elegánsabb az oszlop <= sor ?
Ezzel a 2 változtatással így nézne ki a lecke alap példéja:
sor = 1
while sor <= 25:
oszlop = 1
while oszlop <= sor:
print('O', end='')
oszlop += 1
print('')
sor += 1
Utolsó kérdésem: Nem gond, ha Notepad++ programot használok IDLE helyett?
Bocsánat a hosszú hozzászólásért…
ronaldinhogaucho
KedvelésKedvelés
Halihó! Szóval az úgy van, hogy érdemes lehet megszokni a 0-val való kezdést, majd látod, hogy a listák mindig a 0. (nulladik) elemmel kezdődnek. Az oszlop-sor problémával meg az van, hogy _nekem_ így érthetőbb, de ebben az esetben így elsőre semmi nem jut eszembe, amiért érdemes volna magadra eröltetni az én gondolatvilágomat, úgyhogy ne is tedd – írd úgy, ahogy neked jobb – hiszen az a fontos:)
KedvelésKedvelés
Köszönöm a válaszodat!
KedvelésKedvelés
F0011C-re egy megoldás egyetlen while használatával:
x=0
y=0
while 3*x + 4*y 52:
x+=1
y=0
KedvelésKedvelés
Na, akkor még egyszer, hátha most nem marad le a fele: 🙂
x=0
y=0
while 3*x + 4*y 52:
x+=1
y=0
KedvelésKedvelés
Esetleg zárójelek között? 🙂
(((((
x=0
y=0
while 3*x + 4*y 52:
x+=1
y=0
)))))
KedvelésKedvelés
HELP!!!!
Kedves ráérek,
Amikor bemásolom ide az egyik alternatív megoldást, akkor miért tünteti el a felét az oldal random?
KedvelésKedvelés
Öööö. Nemtom, ilyet még nem láttam. Tedd fel ide: https://pastebin.com/ , és a hozzászólásodban adj linket! Regisztrálni nem muszáj, de szerintem érdemes.
KedvelésKedvelés
Köszi, így kissé rövidebb, de remélhetőleg eredményesebb:
szóval a p0011c feladatra egyetlen while felhasználásával készült megoldás:
https://pastebin.com/vugQtb2s
KedvelésKedvelés
Nocsak, erre nem is gondoltam volna!
(nem enged a tiedre válaszolni, azért ide írom)
KedvelésKedvelés
A jó megoldás szerintem:
x = 0
y = 0
while x*3 + y*4 != 52:
x += 1
if x*3 + y*4 < 52:
y += 1
print('x= ', x, '. y= ', y, '.', sep = '')
KedvelésKedvelés
Mégsem jó! Ez csak egy megoldást talál! 😦
KedvelésKedvelés
Szuper ez az oktató sorozatod, eddig is már sokat segített és szerintem ez után is sokat fog!
Alig várom a következő leckéket!
Csak így tovább!
🙂
KedvelésKedvelés
Kedves ráérek!
Sokszor eljuttottam arra a pontra Dec20-tól, hogy most már kifogytam az ötletekből, kérek tőled segítséget. Aztán jött egy újabb ötlet/kísérlet ami tovább lökött a megoldás felé. Most viszont megakadtam. A történet hátterében egy saját feladat megoldása állt: meghatározni, hogy 1583 már1 től kezdődően melyik lesz az adott év Márc1-nek hétköznapja. Aztán a vezérhangya tovább tobzódott! Mi lenne, ha a Big bumm első napjának hétköznapja feltételezve, hogy:
-pontosan 14500000000.000 évvel ezelőtt történt a tavasz első napján:)
-a Gergely naptárat használjuk az idők kezdetétől azzal a módosítással, hogy
-minden 4000. év nem szökőév (John Herschel alapján)
Jött is egy megoldás, :
hetkozn=[‘Hétfő’,’Kedd’,’Szerda’,’Csütörtök’,’Péntek’,’Szombat’,’Vasárnap’,]
ev=14500000000 #”Azúr2019. évében” pont 14.5milliárd ezelőtt Márc1-n kezdődött minden
i,c,nap=0,0,None
evm=0
print ev #csak ellenőrzés gyanánt kell
while i!=ev:
if i%4==0 or (i%400==0 & i%4000!=0): #szökőévek ha 4-gyel osztható ill. 400-al
while c!=366: #366-szor pörgesse végig a hétköznapokat (mert szökőév)
if evm%7==0: #ha evm=7 vagy annál nagyobb akkor indexálási hiba lép fel
evm=evm%7
nap=hetkozn[evm]
evm+=1
c+=1
print i, evm #csak ellenőrzés gyanánt kell
else:
while c!=365: #365-ször pörgesse végig a hétköznapokat (mert szökőév)
if evm%7==0:
evm=evm%7
nap=hetkozn[evm]
evm+=1
c+=1
print i, evm
i+=1
print”
print’A nagy Bumm’,nap,’-n történt.’
A gondom, hogy elsőre végrehajtja a while ciklust és 1x vált is az i változó. Azonban utána végtelen ciklusba ragad. Miért? Ha if-t, elif-t helyettesítek be az else helyére akkor viszont nincs végrehajtva az i+=1 hanem a print parancsra ugrik. Viszont az i+=1-t nem engedi ki -jogosan- a cikluson kívülre. Hogyan lehetne ezzel a gondolatmenettel befejezni jól a programot. (Természetesen teszteléskor kisebb számokat használtam:) )
KedvelésKedvelés
Szóval most értem rá első komolyabb pillantást vetni, és már ott elakadok, hogy az identálást nem tudom reprodukálni:) Tedd fel pastebinre, ha még érdekes.
KedvelésKedvelés
Üdv, az F0011e feladat megoldása végül is mi?
Köszi
KedvelésKedvelés
A behúzásokra, ha másképp nem, a videó alapján rájössz:)
És szívesen, örülök, ha okos lettél.
x = 0
van_e_már_megoldás = False
while x <= 52 and not van_e_már_megoldás:
y = 0
while 3*x + 4*y <= 52 and not van_e_már_megoldás:
if 3*x + 4*y == 52:
print('x=', x, 'y=', y, 'az egyik megoldás.')
van_e_mar_megoldas = True
y += 1
x += 1
KedvelésKedvelés
Kedves Joco
Itt az én saját megoldásom 🙂
A legvégén levő ‘break’ egy olyan parancs amely kitör a loop-ból vagyis a ciklusból.
Megadtam egy változót ami 0 majd minden eggyes futáskor +1 számot kap. A végén a feltétel megadja, hogy
ha megoldás megegyezik eggyel akkor befejezi a programot.
#15x + 12y = 102
x = 0
megoldás = 0
while 15*x <= 102:
x += 1
y = 0
while 15*x + 12*y <= 102:
y += 1
if 15*x + 12*y == 102:
print('Az x=',x,' az y=',y, sep='')
megoldás += 1
if megoldás == 1:
break
KedvelésKedvelés
Szia! Először is Hálásan Köszönöm azt, amit itt összehoztál! Hiánypótló – szerintem 🙂
F0011b
ez így is elfogadható?
n = 0
while n <= 10:
sor = 0
while sor < 25:
oszlop = 0
while oszlop < sor: # ez a ciklus felel egy sor kiírásáért
oszlop += 1
print(' ', end='')
print('o')
sor += 1
sor = 0
while sor sor: # ez a ciklus felel egy sor kiírásáért
oszlop -= 1
print(‘ ‘, end=”)
print(‘o’)
sor += 1
n += 1
KedvelésKedvelés
vagyis : https://pastebin.com/W9zr2WDT
KedvelésKedvelés
Sőt, remek:)
KedvelésKedvelés