PASCAL. Hogyan tudom kiíratni egymás alá a 4-el oszható számokat? (1től 20-ig)

És akkor jöjjön egy vicces, bár komolyan belegondolva tanulságos megoldás:

begin

WriteLn(4);

WriteLn(8);

WriteLn(12);

WriteLn(16);

WriteLn(20);

end.

Előnyei: Nem igényel változókat, így kevesebb memóriát foglal. Nincsenek ciklusok, műveletek, így gyorsabb is. A lefordított program is kisebb lehet.

Hátránya: Nem univerzális, az 1 és 1000 közötti négyjegyű számok kiírásához nem elég egyetlen paramétert megváltoztatni.

Nota bene főiskolán volt egy feladat, hogy kellett írni egy programot, ami kiírja 1 és 1000 között azon prímszámokat, amiben nem szerepel páros számjegy. Mindenki univerzális megoldást csinált, ahol ez az 1000 lehetne akár 10 000 is. Az egyik srác viszont papíron kiválogatta, hogy melyik számokat is kell kiírni, és a fentihez hasonló módon simán számokat írt ki sorban. Mindenki röhögött, kivéve a tanárt. A tanár megadta a maximum pontot a feladatra, hiszen a feladat adott volt, a program végrehajtja a feladatot hibátlanul, tehát a megoldásban nincs hiba. És ez elgondolkodtatott, és néha eszembe jut. Néha az ember lehet, hogy jobban jár, ha nem a programmal számoltat ki bizonyos dolgokat, hanem előre kiszámolja (akárhogy, programmal, excel táblával, papíron), és a program kvázi részeredményként csak felhasznál egy adatsort. Néha hatékonyabb kódot lehet ezzel a szemlélettel írni. Ha a paraméterezhetőség, univerzalitás nem szempont, akkor ez is egy járható út.

@#11:

Jé, hasonlókat én is írtam, csak illendőségből nem raktam be, de igazad van, ez is belefér. Az én változataim (szintén ReadLn nélkül):

begin WriteLn(4,#10#13,8,#10#13,12,#10#13,16,#10#13,20) end.

begin WriteLn(#52#10#13#56#10#13#49#50#10#13#49#54#10#13#50#48) end.

@#10: „le is írtam, miért elég egy sornyi kód.”

Kárba veszett fáradság volt. Értelmes ember csak közölte volna, mi a baja a hozzászólásoddal -- ha még igaza is lett volna, az éppen elég ok a bosszúságra.

A lepontozós troll voltaképpen elég szomorú helyzetben van. Nincs meg a lehetősége, hogy artikulálja az akcióit, ezért rád van bízva, hogy melyik értelmezés szerez neked nagyobb örömöt:

      1. Az illető egy fogyatékos értelmű, gyermeteg lélek, aki azt hiszi, hogy a jó válaszok leértékelése valami zavart okoz majd, és ezt mulatságosnak találja.

      2. Nem éri fel ésszel a válaszod értelmét, ezért tévesen ítéli meg.

      3. Magadra haragítottad, és ezért törleszteni akar -- például egy másik kérdésnél majmot csináltál belőle valami szócsatában, és most ott próbál ártani neked a maga együgyű módján, ahová a szűkös korlátai terelték. Bonyodalmasabb lenne arra várni, amikor majd te mondasz valami támadhatót, meg aztán hátha az a csetepaté sem úgy sül el, mint szeretné...

Akárhogyan is, a lepontozós trollkodásból nem lehet fölénnyel kijönni. A troll maga deklarálja alacsonyabb rendűségét, annak meg egy anonim oldalon nem sok jelentősége van, hogy tudod-e a nickjét, anélkül is lenézett pária marad.

Na ne már srácok! Képesek lennétek oszthatóságot vizsgálni?? Ahelyett, hogy egyszerűen kiírnátok a 4 többszöröseit? Az egész csak 5 ciklus lenne.

while szorzat>=20 do

begin

szorzat = szorzat * i

end;

#12 > begin WriteLn(4,#10#13,8,#10#13,12,#10#13,16,#10#13,20) end.

Igen, ha a kód olvashatóságát is feláldozzuk, akkor ez még tömörebb megoldás, és egy nüansznyival hatékonyabb is. Bár akkor már a második megoldás még tetszetősebb, mert az elsőnél még mindig konvertálni kell belül a számokat szöveggé. A második egyszerűen, az egy lépésben kiírja a programban eleve tárolt végeredményt, mint sortöréseket tartalmazó stringet.

@#15:

Persze, persze... nem is kell komolyan venni.

Újabb kísérlet, általánosabban:

var hatar, oszto : integer;

begin

Write('Határérték: ');

ReadLn(hatar);

Write('Osztó: ');

ReadLn(oszto);

for hatar := 1 to hatar div oszto do WriteLn(hatar * oszto);

ReadLn;

end.

#17 a for ciklusodban azzal, hogy ezt írod "hatar := 1" egyből át is írod az eredetileg megadott határt, mivel rég pascaloztam vagy egyszer fog lefutni és kiírja a négyet vagy egyszer se. (bár asszem a for egyszer így is úgy is lefut) (for i := 1 to hatar div oszto do WriteLn(hatar * oszto); -val már működne. De ez se elegáns, mert minden egyes ciklus során elosztja a határ az osztóval ami fölösleges erőforrás pazarlás. A jobb megoldás ha ragaszkodsz a kódhoz, hogy közvetlen osztó beolvasása után határ:=határ div oszto-t és akkor a for már mehet határig)

Amúgy nem jutott volna eszembe :(( de a 13-as megoldása a legelegánsabb.

#17:

"a for ciklusodban azzal, hogy ezt írod "hatar := 1" egyből át is írod az eredetileg megadott határt..."

Nagyon örülök, amiért erre fölhívtad a figyelmet, ha most az egyszer tévedtél is.

Igen, erre az érdekességre kellett volna Kérdezőnek fölneszelnie, ha nem tojna bele magasról a saját kérdésébe. Ebben a furcsa szösszenetben éppen az lett volna a játék, hogy a fordító nem azt műveli, amit parasztlogikával elvárnál tőle. Tehát bizony, hogy nem osztogat ciklusban, hanem igen okosan, csak egyszer, amikor a határértéket kiszámolja. Ezt megjegyzi valahol (nem a megadott két változó valamelyikében), és hatar változó értékét a továbbiakban már nem fúrja-faragja, hanem csak -- ciklusváltozóként újrahasznosítva -- lépteti 1-től az imént kiszámolt ciklushatárig. Lehet, hogy egy ilyen vicc valóban messze van a legelegánsabb megoldástól, de szerintem annyira azért nem is trampli, mint ahogy elképzelted. Meg aztán ez sem tanulságok nélkül való.