- BIOS frissítés
- Samsung Galaxy Tab S11 - tizenegyes
- Szélvész tempót diktál a Team Group T-Force szériás SSD-je
- Milyen asztali (teljes vagy fél-) gépet vegyek?
- Hobby elektronika
- Milyen billentyűzetet vegyek?
- Intel Core i3 / i5 / i7 4xxx "Haswell" és "Haswell Refresh / Devil's Canyon" (LGA1150)
- Meghalt a Windows 10, éljen a Windows 10!
- Hisense LCD és LED TV-k
- AMD K6-III, és minden ami RETRO - Oldschool tuning
Új hozzászólás Aktív témák
-
alitak
senior tag
válasz
Wizardmon
#1447
üzenetére
Na nézegettem a problémát, és kitúrtam a polcomról egy öröknaptárt. Megírtam hozzá a programot:
program oroknaptar;
uses newdelay,crt;
var datum:record
ev,honap,nap:integer;
end;
x,kodszam:integer;
nap:string;
begin
clrscr;
datum.ev:=0;datum.honap:=0;datum.nap:=0;x:=0;kodszam:=0;
writeln('Add meg a szuletesed datumat, a honapot szammal add meg!');
write('Ev: ');readln(datum.ev);
write('Honap: ');readln(datum.honap);
write('Nap: ');readln(datum.nap);
if (datum.honap=1) or (datum.honap=2) then datum.ev:=datum.ev-1;
x:=trunc(datum.ev/100);
case x of
15,19,23,27,31:kodszam:=kodszam+1;
16,20,24,28,32:kodszam:=kodszam+0;
17,21,25,29,33:kodszam:=kodszam+5;
18,22,26,30,34:kodszam:=kodszam+3;
end;
x:=datum.ev mod 100;
case x of
0,28,56,84,6,34,62,90,17,45,73,23,51,79:kodszam:=kodszam+0;
1,29,57,85,7,35,63,91,12,40,68,96,18,46,74:kodszam:=kodszam+1;
2,30,58,86,13,41,69,97,19,47,75,24,52,80:kodszam:=kodszam+2;
3,31,59,87,8,36,64,92,14,42,70,98,25,53,81:kodszam:=kodszam+3;
4,32,60,88,10,38,66,94,21,49,77,27,55,83:kodszam:=kodszam+5;
5,33,61,89,11,39,67,95,16,44,72,22,50,78:kodszam:=kodszam+6;
9,37,65,93,15,43,71,99,20,48,76,26,54,82:kodszam:=kodszam+4;
end;
case datum.honap of
10:kodszam:=kodszam+0;
1,5:kodszam:=kodszam+1;
8:kodszam:=kodszam+2;
3,11:kodszam:=kodszam+3;
6,2:kodszam:=kodszam+4;
9,12:kodszam:=kodszam+5;
4,7:kodszam:=kodszam+6;
end;
case datum.nap of
1,8,15,22,29:kodszam:=kodszam+1;
2,9,16,23,30:kodszam:=kodszam+2;
3,10,17,24,31:kodszam:=kodszam+3;
4,11,18,25:kodszam:=kodszam+4;
5,12,19,26:kodszam:=kodszam+5;
6,13,20,27:kodszam:=kodszam+6;
7,14,21,28:kodszam:=kodszam+0;
end;
while kodszam>7 do kodszam:=kodszam-7;
case kodszam of
1:nap:='vasarnap';
2:nap:='hetfo';
3:nap:='kedd';
4:nap:='szerda';
5:nap:='csutortok';
6:nap:='pentek';
0:nap:='szombat';
end;
writeln;
write(datum.ev,'. ',datum.honap,'. ',datum.nap,'-ika ',nap);
end.
A matematikai részét ne kérdezzétek, mert nem tudom, nem én találtam ki a naptárat, csak megírtam rá a programot. Viszont 1582. október 15-étől működik, egészen 3499 december 31-éig. És jól! -
Lortech
addikt
válasz
Wizardmon
#1469
üzenetére
Itt egy megoldás, feltételezve, hogy 1900. 01. 01. hétfő volt.
így 1900 utáni dátumokra működik elvileg helyesen, bár nem nagyon teszteltem.
Próbáltam átláthatóra, és egyszerűre csinálni. Ha van másnak jobb megoldása, jöhet. ( konkrét forráskód formájában
)
Ha nem egyértelmű valahol, kérdezz.
program datum;
uses crt;
const
napok: array[0..6] of string[9] = ('hétfő', 'kedd', 'szerda', 'csütörtök', 'péntek', 'szombat',
'vasárnap');
honapok: array[1..12] of byte=(31,28,31,30,31,30,31,31,30,31,30,31);
var
eltnapok:longint;
i,ev:word;
ho, nap:byte;
begin
eltnapok:=0;
{ - meghatározandó nap dátumának bekérése - }
write('Év:');
readln(ev);
write('Hó:');
readln(ho);
write('Nap:');
readln(nap);
for i:=1900 to ev-1 do
if (i mod 400 = 0) or ((i mod 4 =0) and (i mod 100<>0)) then eltnapok:=eltnapok+366
else eltnapok:=eltnapok+365;
for i:=1 to ho-1 do
if (i=2) and ((ev mod 400 = 0) or ((i mod 4 =0) and (i mod 100<>0)))
then eltnapok:=eltnapok+29 else eltnapok:=eltnapok+honapok[ i ];
eltnapok:=eltnapok+nap-1;
writeln(eltnapok,napok[eltnapok mod 7]);
readln;
end.
ps: term. nem foglalkoztam a hibás inputok kiszűrésével.
[Szerkesztve] -
-
cucka
addikt
válasz
Wizardmon
#1447
üzenetére
na ez az első amit nem értek, miért -1re állítják?
gondolom azért, mert utána rögtön elindítja az évet beolvasó ciklust, és úgy gondolta, hogy így akkor is hibát fog dobni, ha nem írsz be semmit évnek. (rég volt pascal, de szerintem ez így fölösleges)
itt minek kell ennyi felhajtás ha az 'ev' csak 1 és 99 között lehet?
itt azért akkora felhajtás, mert aki írta a programot, az nem igazán gondolta át a problémát. valóban fölösleges.
egyébként meg ez egy nagyon kusza, bonyolult és csúnya megoldás szerintem -
Jester01
veterán
válasz
Wizardmon
#1443
üzenetére
A variálható rekord az olyan mint Pom-pom: bámulatosan tudja változtatni az alakját.
Tulajdonképpen több rekord egyben, amihez van egy mező ami megmondja melyik típusú is valójában. Igazából csak azért jó, mert takarékoskodik a memóriával, mert az egymást kizáró részeket ugyanarra a memóriacímre teszi. (MOD: plusz a különböző adatokat fix méretben tárolja, a legnagyobbnak megfelelő helyen)
Vegyünk egy hülye példát: legyen egy ''alakzat'' rekord amiben szakaszok és körök adatait akarod tárolni.
type
AlakTipus = (kor, szakasz);
Alakzat = record
x, y: integer;
case tipus: AlakTipus of
kor: (sugar: integer);
szakasz: (x2, y2: integer);
end;
end;
Ez tulajdonképpen 2 rekord, szakasz esetén (x, y, x2, y2) kör esetén pedig (x, y, sugar) tagokkal. A sugar és az x2, y2 tagok átfedik egymást, egyszerre nem lehet őket használni. Azt, hogy melyik van érvényben a tipus mondja meg.
cucka-hoz hasonlóan én is régen pascaloztam
MOD: zárójelek
[Szerkesztve] -
cucka
addikt
válasz
Wizardmon
#1443
üzenetére
variálható rekordról semmit. 6 éve nem programozok pascal-ban, az ilyen ritkán használt dolgokat elfelejtettem. egyébként ott a könyv, ott le kell legyen írva. (szerintem te is abból a computerbooks könyvből tanulsz, amiből annak idején én is. ha igen, akkor az jó, mert az egy nagyon szájbarágós, magyarázós könyv, szerintem abból meg lehet érteni ezeket a dolgokat).
[Szerkesztve] -
cucka
addikt
-
-
cucka
addikt
válasz
Wizardmon
#1428
üzenetére
először is mindkét program hibás, elsőben hiányzik az end a rekord deklarációjának végéről, másodikban elgépelted a begin-t.
másodszor nincs sok értelme, hogy 5-ször beolvasd a nevet/címet, majd belerakd ugyanabba az egy változóba a beolvasott értéket, még példaprogramban sem.
harmadszor meg próbáld mégis elolvasni és megérteni azt, amit az általad említett könyvben ír a rekordokról, illetve amit itt a fórumon írtak neked. az itt kapott segítség nagyon szájbarágós, ezekből illene azért megérteni, miről is van szó.
[Szerkesztve] -
#1430
Drótszamár
őstag
Wizardmon
#1428
Drótszamár
őstag
válasz
Wizardmon
#1428
üzenetére
Így első nekifutásra mind a kettő hibás
, ugyanis beolvasol 5x adatokat, de mindig ugyan abba a változóba, uh felülírod az előzőket.
Rekord esetén vegyél fel egy adatok = array[1..5] of adat tömböt, és mindig a tömb következő elemébe olvassál be.
Tehát readln(adat[x].akármi); , ahol az x a ciklusváltozó, az növekszik.
Az összetartozó adatokat legtöbbször rekordban érdemes tartani, mert ha szükség lesz csoportos adatezelésre, akkor könnyebb dolgod lesz.
pl vannak egy tömbben rekordok, és ezeket 2 másikba szét akarod válogatni.
tomb1 : array [1..sok] of rekord;
tomb2 : array[1..sok] of rekord;
tomb3 : array[1..sok] of rekord;
ilyenkor ha a tömb1-ből át akarsz másolni adatokat a tomb2-be akkor tomb2[x]:=tomb1[n];
És 1 művelettel 1 egész rekordot átmásoltál. Ha a rekord 10 elemből áll, akkor itt most 10 sor lett volna rekord nélkül. -
-
VladimirR
nagyúr
válasz
Wizardmon
#1423
üzenetére
minden tipusu valtozo arra valo, hogy taroljuk az adatokat
viszont nem lehet mindent eltarolni ugyanabban a 3 valtozoban (egy integer., egy real, meg egy string) - azaz lehet, csak vert izzadsz, mire megvalositod
bonyolultabb feladatok megoldasahoz (teszemazt egy korhazi kartotekrendszer, ahol a beteg kulonfele adatait kell tarolni) szukseges a bonyolultabb adatszerkezet hasznalata (hogy a valos adatoknak megfeleloen mindent el tudjunk tarolni, kesobbi felhasznalas celjabol)
ilyenkor jon jol peldaul a rekord, ahol minden egyes rekord egy beteg adatait tarolja - minden adatat, mint ahogy a korhazi kartonodon is van (ott figyel rajta a nev, bekerules ideje, kortortenet, kezeloorvos neve, orvossagok, datumok, vercsoport)
es igen, ahogy haladsz a programozassal, ugy valik majd egyre bonyollultabba, a kezdeti egyszeru programokat, ahol szepen sorban kovetik egymast az utasitasok, majd felvaltja a strukturalt programozas, ahol fuggvenyeket, eljarasoikat hasznalsz, kesobb pedig esetleg az objektumorientalt programozas
en azt javaslom, picit lassits le, eloszor az alapokat ertsd meg, az egyszeru adattipusokat (egeszek, lebegonpontos szamok, string-ek, logikai valtozok, majd ha ezek mar mind mennek, akkor a tombok, rekordok, s legvegul a pointerek) -
Lortech
addikt
válasz
Wizardmon
#1423
üzenetére
Minden típus arra való, hogy tároljuk az adatokat. A rekord típusnak bizony komoly létjogosultsága van, a fejlettebb nyelvekben még összetettebb, magasabb absztrakciójú típusok, adatszerkezetek lesznek meghatározóak (ojjektum
).
Képzelj el egy nyilvántartást, ahol személyek vannak, nyilvántartva, adataikkal. Egy-egy személyt jellemzi a neve, születési éve, címe és a többi. Megoldható, hogy létrehozol minden egyes adattagnak (mezőnek) egy-egy tömböt, és úgy tárolod ez az adatokat.
Pl van 100 személy, akkor lenne egy nev: array[1..100] of string[30] a nevek tárolására, egy hasonló tömb a címek tárolására, meg a többi adatnak is mindnek külön. Ezzel szemben rekordokkal megoldhatod úgyis, hogy létrehozol egyetlen egy rekord típust az összes adatnak egy-egy személyre. Azaz:
adatok = record
nev: string[30];
...
...
cim: string[40];
end;
és ebből az általad definiált összetett adattípusból létrehozol egy tömböt:
szemelyek: array[1..100] of adatok;
Tehát egy ''adatok'' nevű, _általad létrehozott rekord típusból álló 100 elemű tömb.
Mennyivel átláthatóbb és emberközelibb az utóbbi. (?) Számomra legalábbis az, és majd ha ezekkel az adatokkal műveleteket is akarsz végezni, pl kivenni egy személyt a listáról, akkor látni fogod, hogy programozni is sokkal egyszerűbb. Egyszerűen jobb, szebb megoldás.
[Szerkesztve] -
Lortech
addikt
válasz
Wizardmon
#1419
üzenetére
A type kulcsszó saját változó típus létrehozására használható. A pascal beépített változó típusai pl integer, byte, real, array. Ezek felhasználásával lehet újakat alkotni. /Illetve csak bizonyos típusokat lehet felhasználni _valóban ''új''_ típus alkotásához. Egyébként csak átnevezés/
Ez tipikusan olyan fogalom, amit példán keresztül lehet megérteni annak, aki még nem találkozott ilyennel.
Tehát egy példa:
a:
type
tomb: array[1..10] of byte;
var
t: tomb;
ez egyenlő az alábbival:
b:
t: array[1..10] of byte;
Az ''a'' esetben saját típust hozol létre a type kulcsszó után, tomb lett az új típusod neve, és ez a típus egy 10 elemű byte-array. Ezután a VAR kulcsszóval bevezetett változó deklarációs részben már úgy hivatkozhatsz az általad létrehozott típusra, mintha az a pascal egy beépített típusa lenne, tehát egy változónévhez hozzárendelheted. A b változatban ugyanazt leírtam, csak type nélkül, a kettő végeredményben megegyezik. Pascalban és a hozzá hasonló procedurális nyelvekben még nem annyira hangsúlyos a saját típusok létrehozása, és a lehetőségek is eléggé korlátozottak, inkább az átláthatóság és szemléletesség miatt van létjogosultsága mint funkcionalitásban. Egyelőre szerintem elég ennyi, ha valóban szükséged lesz a használatára, akkor már tudni fogod vsz.
[Szerkesztve] -
VladimirR
nagyúr
válasz
Wizardmon
#1419
üzenetére
ezzel definialsz uj adattipust, a mar meglevokbol
mint irtad, lehet felsorolt, tomb, rekord, de lehet barmilyen adattipus
tegyuk fel, hogy neked olyan adattipusra van szukseged, amiben egyutt tudod tarolni valakinek az adatait, mint pl nev, cim, szuletesi datum, suly, magassag
ehhez a legjobb, ha csinalsz egy rekord-ot es minden szemely adatait egy kulon rekordban tarolod
type adatlap=record
nev : string[80];
cim : string[80];
szul_dat : string[8];
szuly : real;
magassag : byte;
end;
ezzel csak az adattipust hoztad letre, a valtozot meg nem, azt itt is meg kell tenni, pl.:
var user1, user2 : adatlap;
vagy lehet az adatlapokat tomb-ben tarolni:
var users : array[1..100] of adatlap;
elobbi esetben egyszeruen user1.nev, user2.cim formaval hivatkozol a rekord elemeire, utobbiban pedig users[1].nev, users[2].cim formaban
de ettol egyszerubb pelda, hogy a fentebb hasznalt 80 karakter hosszu szoveg tarolasara alkalmas tipust hozunk letre:
type s80 = string[80];
amit aztan igy tudsz hasznalni:
var s : s80; -
ViragL
tag
válasz
Wizardmon
#1383
üzenetére
Nem csak rád céloztam, van itt más is aki hasonló cipőben jár. Konkrétan senkit nem akarok bántani, nyilván el kell kezdeni valahogy, engem az bosszant, hogy divat lett a kezdők között előbb kérdezni, minden háttérismeret nélkül és csak utánna megnézni a szakirodalmat.
Így a kezdő a fórumon választ kap a kérdésére, a válasz vagy jó vagy nem, de majdnem biztos, hogy hiányos. Aztán a kezdő ezekből az információkból próbál valamit alkotni és csodálkozik, hogy nem megy. Holott, ha előbb elolvasott volna egy témába vágó könyvet, vagy jegyzetet (lektorált jegyzetet, nem valami útszéli xart), akkor ott megtalálta volna azokat az információkat amikkel elkerülhette volna a hibát. Tehát ugyanott van, el kell olvasnia valamelyik szaikrodalmat. Tehát, szerintem, csak kiszúr magával az illető, ha az előbb említett módon jár el.
Már nem is értem, miért borultam ki, hiszen, ha valaki szereti a rögösebb utat, az járjon azon.
Annak örülök, hogy sértődés nem lett a dologbol. Mégegyszer hansúlyozom, nem konkrétan neked szántam az előbbi hozzászólásomat, hanem mindenkinek, aki azt a módszert követi. -
cucka
addikt
válasz
Wizardmon
#1369
üzenetére
inicializálás - ha létrehozol egy változót, akkor létrehozás pillanatában kap egy értéket. ez az inicializálás. ez lehet automatikus (implicit), amikor a fordító hozzárendeli mondjuk a 0 értéket (üres stringet, stb.), vagy kézi, amikor te mondod meg, hogy mennyi legyen az az érték (ezt ha jól emlékszem, nem támogatja a pascal). vagy hiányozhat, akkor az lesz az értéke, ami éppen azon a memóriaterületen volt, ahol tárolódik a változó.
[Szerkesztve] -
VladimirR
nagyúr
válasz
Wizardmon
#1369
üzenetére
amikor kezdoerteket adsz a valtozoidnak
tehat az nem eleg, hogy letrehozod a valtozot (tombot), kell neki adni valami erteket is, hogy ne 0-k, vagy a memoriaban talalt szemet legyen benne
pl.:
var i, j: byte;
x: array[ 1..3, 1..3 ] of byte;
begin
for i := 1 to 3 do
for j := 1 to 3 do
x[ i, j ] := i * 10 + j;
[...]
end.
ekkor a tomb elemeinek elso szamjegye ez egyik, masodik szamjegye a masik dimenzio index-e lesz -
VladimirR
nagyúr
válasz
Wizardmon
#1362
üzenetére
sorba irja, de ez nem a tomb elemeit irja ki, hanem a kovetkezot:
111213212223313233
ha a tomb elemeit akarod kiiratni, akkor:
write( x[ i, j ] );
ha azt akarod, hogy tablazatos legyen, magad kell megoldanod, pl.:
for i := 1 to 3 do
for j := 1 to 3 do begin
if j = 3 then
writeln( x [i, j ] : 4 )
else
write( x[ i, j ] : 4 );
end;
a write-ban a : 4 arra valo, hogy igy 4 karakter szelessegu helyet tart fenn a kiirandfo erteknek (byte eseteben ugye 3 a max szamjegy (0-255), es szep igy tablazatos format fogsz kapni)
1 2 3
1 2 3
1 2 3
azaz majdnem, ugyanis neked minden hulyeseget fog kiirni, mivel nem inicializaltad a tombot -
cucka
addikt
válasz
Wizardmon
#1362
üzenetére
először: az x tömbödet létrehoztad ugyan, de nem adtál egyik elemének sem értéket, így (ha jól emlékszem) minden eleme 0 lesz. tehát van egy 3x3-as táblázatod, minden cellájában 0.
másodszor: a ciklusodban a write-al nem a tömb értékeit iratod ki, hanem a ciklusváltozókat (ez az i és a j). ha lefuttatod a programot, akkor láthatod ezt, mert nem 0-kat fog kiírni. először a külső ciklus i=1 értékére fut le a ciklus magja, amiben szintén egy ciklus van, j-re. így első menetben azt kapod, hogy 111213. itt az 1.1.1 az i értéke, .1.2.3 pedig a j értéke. most a külső (i-s ciklus) magja lefutott 1-re, veszi a következő értéket, ami i=2, és megcsinálja rá ugyanazt, vagyis kiírja, hogy 212223. ezután lefut i=3-ra is tehát a végeredmény az lesz, hogy 111213212223313233.
harmadszor: a kiírás módját te szabod meg. itt például a write-al iratsz ki. write(i,j) azt jelenti, hogy egymás után kiírja az i és a j értékét. ha azt szeretnéd, hogy a tömb i. sorának j. elemét irasd ki, akkor write(x[i,j]) -vel teheted ezt meg. természetesen a belső ciklus magjában, tehát 9 kiiratás lesz, az összes lehetséges i,j értékre.
ha a külső (i változójú) ciklusodat úgy alakítod, hogy a benne lévő for után írjon ki egy üres sort, akkor táblázat-szerűen kapod az eredményt. (vigyázz, ekkor már több utasítás lesz a ciklus magjában, tehát kell a begin-end;) -
cucka
addikt
válasz
Wizardmon
#1360
üzenetére
tömb - vegyük azt, hogy szeretnél sok egyforma típusú adatokat tárolni. például van 200 számod és növekvő sorrendbe szeretnéd őket rendezni. ekkor használsz tömböt, ami tulajdonképpen azt a 200 számot reprezentálja. a tömbben mindegyik elemnek van egy sorszáma, ezt indexnek hívjuk. pascal-ban az indexek 1-től kezdődnek.
például létrehozol egy 10 elemű tömböt, amelyben egész számokat tárolsz:
var x: array [1..10] of integer;
ekkor a tömb elemeit x[ i ] formában éred el, és pont úgy kezeled, mint ha változók lennének, értéket adhatsz neki, számolhatsz vele, satöbbi. az egész tömböt az x változó jelenti, egyes elemeit meg az x[1], x[2], satöbbi. ha tegyük fel 200 számod van és statisztikát szeretnél készíteni (mondjuk egy iskola tanulóinak év végi átlagából szeretnél elolszlás-grafikont készíteni) akkor egy ilyen x tömbbe belepakolhatod a számokat. tömb nélkül létre kéne hozz 200 különálló változót, ami nem jó megoldás . a másik előnye, hogy ciklussal végigjárhatod a tömbödet.
a fent leírt egyszerű tömb tulajdonképpen egy (matematikai értelemben vett) vektor. mint excel-ben egy olyan táblázat, amelyiknek 1 sora vagy oszlopa van. vannak 2 dimenziós tömbök, ezek tulajdonképpen mátrixok (táblázatok). ezen kívül lehetnek sokdimenziós tömbök, ezeket már nehezebb elképzelni.
ha valami nem világos, kérdezz. egyébként az általad linkelt doksiban faszán le van írva ez.
[Szerkesztve] -
ViragL
tag
válasz
Wizardmon
#1356
üzenetére
Ha szerencséd van a prog.hu-n találsz néhány embert aki szivesen elmagyarázza neked amit nem értesz. Alternativaként ide is írhatod a kérdéseidet, úgy tünik én vagyok itt az ügyeletes válaszadó, tehát ha tudok válaszolok a kérdéseidre.
Mod: Látom már nem vagyok egyedül.
[Szerkesztve] -
cucka
addikt
-
N!tRo
tag
válasz
Wizardmon
#1356
üzenetére
Hello!
Az összetett adattípusokon belül mi érdekel?
Ciklusok.
Három ciklus van (tudomásom szerint)
a FOR ciklus, a REPEAT..UNTIL ciklus és a WHILE..DO ciklus.
FOR ciklus
Alapforma
FOR változó:= első TO második DO parancs(ok);
Példa
FOR i:= 1 to 10 do writeln('Hello!'); Ez annyit tesz hogy 10x kiírja a képernyőre hogy Hello!
Leírás
A lényege ennek annyi, hogy egy változó értékét növeli vagy csökkenti valahányszor és ugyanennyiszer végrehajtja a DO utáni utasítás(oka)t. A változó értékét fel lehet használni az utasításokban, mint például egy tömb feltöltése.
REPEAT..UNTIL ciklus
Alapforma
REPEAT
utasítás(ok);
...
UNTIL feltétel;
Példa
i:=1;
REPEAT
writeln('Hello!');
i:=i+1;
UNTIL i:= 10;
Leírás
Ez az úgynevezett hátul tesztelős ciklus. A lényege ennek az, hogy amíg az UNTIL utáni feltétel nem teljesül, addig hajta végre a ciklusba írt utasításokat.
Magyarul így szól:
CSINÁLD ÚJRA
ez(eke)t;
AMÍG i egyenlő nem lesz 10-el.
WHILE..DO ciklus
Alapforma
WHILE feltétel DO utasítás(ok).
Példa
i:=1;
WHILE i<>10 DO BEGIN writeln('Hello!'); i:=i+1; END; (azért van begin end, mert ha a DO után több utasítás áll, ami a ciklushoz tartozik, begin end-el kell alkalmazni. Ugyanígy a FOR ciklusnál is.
Leírás
Ez meg az úgynevezett előltesztelő ciklus, tehát előbb megvizsgálja a feltételt, majd végrehajtja az utasításokat. Ez a REPEAT..UNTIL ellentétje. A feltételben is pont a fordítottját kell írni. Magyarul így szól:
AMÍG nem egyenlő i a 10-el CSINÁLD ez(eke)t.
Remélem tudtam segíteni.
Hali
[Szerkesztve]
)
, ugyanis beolvasol 5x adatokat, de mindig ugyan abba a változóba, uh felülírod az előzőket.
Új hozzászólás Aktív témák
- 2019 MacBook Pro 16" i9 Radeon Pro 5500M 4gb 32gb RAM 1TB SSD eladó!
- Újszerű HP 14s-dq5001nh - 14"FHD IPS - i5-1235U - 16GB - 512GB - Win11 - Magyar - Garancia
- PCLab Gamer G-386 Ryzen 5 5600 / 32GB DDR5 / RTX 5060 - profi összeszerelés gamerekre hangolva
- Samsung Galaxy S24 Ultra 512 GB (Ezüst) Prémium ajándékcsomaggal Típusváltás miatt eladó
- Ghost of Yotei + előrendelői kód
- BESZÁMÍTÁS! Asus Z790 i9 14900K 32GB DDR4 1TB SSD RTX 2080Ti 11GB Montech Air 1000 Lite 700W
- Telefon felváráslás!! iPhone 15/iPhone 15 Plus/iPhone 15 Pro/iPhone 15 Pro Max
- BESZÁMÍTÁS! ASROCK B650M R7 7700 32GB DDR5 1TB SSD RX 6900XT 16GB Enermax EQUILENCE 1000W
- Apple Mac mini 14.3 M2 8GB RAM 256GB SSD 1év garancia
- HIBÁTLAN iPhone 13 256GB Pink -1 ÉV GARANCIA - Kártyafüggetlen, MS3732, 91% Akkumulátor
Állásajánlatok
Cég: NetGo.hu Kft.
Város: Gödöllő
Cég: PCMENTOR SZERVIZ KFT.
Város: Budapest