Új hozzászólás Aktív témák
-
Jester01
veterán
memóriacímet tárolnak, ami egy darab szám
Ez persze nem igaz, a pointerek belső szerkezete implementációs kérdés. Például szegmentált memóriamodellben van ugye far pointer is, amiben 2 szám is van, vagy harvard architektúrán a szám mellé még azt is tudni kell adat vagy program memória stb.
Nyilván ha akarom akkor ez 1 szám mivel csak egy halom bit azt meg bármikor felírhatom számként Az is igaz, hogy a hétköznapi rendszerekben valóban elég egy szám.
Ezzel együtt az eredeti kiindulás az volt, hogy az & operátor nem egy számot ad vissza, hanem egy megfelelő típusú pointert. Emiatt aztán (int)&x + 1 és (int)(&x + 1) az nem ugyanaz (kivéve ha véletlenül x mérete 1 byte)
[ Szerkesztve ]
Jester
-
zka67
őstag
válasz Jester01 #5552 üzenetére
Szia,
Ezzel együtt az eredeti kiindulás az volt, hogy az & operátor nem egy számot ad vissza, hanem egy megfelelő típusú pointert. Emiatt aztán (int)&x + 1 és (int)(&x + 1) az nem ugyanaz (kivéve ha véletlenül x mérete 1 byte)
Mint említettem, fizikailag a pointer egy (memória)címet tartalmaz, ami egy egyszerű szám (ez lehet 16, 32 vagy akár 64 bites érték is, rendszertől függően, de ebbe most ne menjünk bele). A pointer típusát a fordító kezeli, magából a pointer értékéből ez nem derül ki, mivel nem tárolja azt.
Az eredeti kérdés az az volt, hogy a pointer elé miért nem kell a & jel, ezt próbáltam meg konyhanyelven elmagyarázni a kérdezőnek, hogy megértse.
int main(int argc, char* argv[])
{
char c;
char *p;
p = &c;
printf("sizeof(c)=%d, sizeof(p)=%d, p=%08X\r\n", sizeof(c), sizeof(p), p);
return 0;
}Ennek az eredménye az alábbi:
sizeof(c)=1, sizeof(p)=4, p=0018FF53azaz a c változó a 0x0018FF53-as memóriacímen található. Nincs a p változóban semmilyen típus, csak a változó címe.
-
-
dobragab
addikt
Igen, ugyanarról beszéltek. Futásidőben már nem tudható a pointer típusa, de fordítási időben baromi fontos. Onnan tudja a fordító, hogy pointer aritmetika / tömbindexelés esetén hány bájt offset-je van a következő elemnek.
int * a = tomb;
int * b = a + 1; // 4 bájttal tolta arrébb
char * c = "text";
char * d = c + 1; // 1 bájttal tolta arrébbFeltéve, hogy az int 4 bájtos.
Tudom, tudom, akasszak a tökömre egy lámpát, hogy sötétben is tudjak kaszálni.
-
bepken
veterán
sziasztok,
még csak ismerkedek a C programozási nyelvvel (bár nem ez az első nekifutásom) - egyszer már elolvastam a Kernighan-Ritchie féle könyvet, most elölről kezdtem és a példákon is végig megyek.
van (még egészen az elején) egy példakód, aminek egy "aprócska" része nem igazán világos számomra: 1.5.4. Szavak számlálása fejezet példakódjáról van szó.
az egészből egész pontosan ezt a kódrészletet nem értem:
if (c == ' ' || c == '\n' || c == '\t')
allapot = KINT;
else if (allapot == KINT) {
allapot = BENN;
++nw;
}egész konkrétan az else if ágat nem értem belőle. az megvan, hogy a két állapot (KINT/BENN) között kell váltogatni, de miért így van megírva az else if feltétele? ha jól értem, csak azért, hogy beugorjon abba az ágba, átváltson BENN értékre és növelje az nw változó értékét...jól értem? csak mert ülök már felette jónéhány perce
egyébként mire leírtam mégis csak koppanni látszik...na de akkor annyit ha segítenétek, hogy miért nem lehet a helyén egy sima else ág? vagy az allapot == KINT feltétel helyén egy akármilyen igaz feltétel?
köszi előre is a segítő szavakat (remélem, nem kérdezek nagy baromságot)
üdv,
bepken╔═══════ "Csak egy visszatérés létezik és az nem a királyé...hanem a JEDIÉ!" ═════╗ ╚════════════════ Xiaomi Mi A1 ═════ Huawei Nova 5T ═════════════╝
-
kispx
addikt
Ha csak else ág lenne, akkor azokat a karaktereket számolná össze, ami nem szóköz, új sor vagy tabulátor.
Így a szavak kezdőkarakterét számolja össze, ami megegyezik a szavak számával (mivel minden szónak csak egy kezdőkaraktere van).Ezért kellett az állapotgép (KINT, BENT), hogy meglehessen különböztetni a kezdőbetűt, a szó belsejében lévő betűtől.
-
bepken
veterán
azt hiszem, így már leesett, miért kaptam ezeket az értékeket (minden fehér karaktertől eltérőt összeszámoltam a bemenetről ) köszi szépen a gyors választ!
még talán annyi, hogy ha az else if (allapot == KINT) helyett miért nem írható pl: else if (1) - ezt a részét még nem értem. mármint ha KINT állapotban vagyunk, akkor beugrik erre az ágra és átváltja az értéket BENT-re, majd a ciklus elején lehet újra KINT-re változik. na de miért épp ez a feltétel?
[ Szerkesztve ]
╔═══════ "Csak egy visszatérés létezik és az nem a királyé...hanem a JEDIÉ!" ═════╗ ╚════════════════ Xiaomi Mi A1 ═════ Huawei Nova 5T ═════════════╝
-
bepken
veterán
sziasztok,
közel vagyok egy feladat megoldásához, de sajnos nem vagyok benne biztos, hogy jó úton indultam el....
vizsgálni kell többek között, hogy az adott sor tartalmaz e nagybetűt és számot. na most ezt eddigi ismereteim szerint legegyszerűbben a <ctype.h> könyvtár függvényeivel tudom megoldani. viszont a feladatban van egy előre megadott main függvény, amiben ez a könyvtár nincs megadva.
gondolom include csak elől szerepelhet, bár compiler nem szólt függvényen belül sem. de esetleg meg lehet ezt oldani az említett fv.könyvtár nélkül is? mármint...gondolom ezt várná a feladat.a másik problémám, amit viszont egyáltalán nem tudtam lekezelni: az a példabemenet 7. sorában lévő üres sor. ezt hogy a fenébe kellene lekezelni, hogy a függvény megfelelően működjön?
ezeket leszámítva az általam írt megoldás minden bemenetre megfelelő értéket adott. egyelőre általánosságban kérdezősködök, de természetesen tudok mutatni kódot is.
köszi előre is,
bepken[ Szerkesztve ]
╔═══════ "Csak egy visszatérés létezik és az nem a királyé...hanem a JEDIÉ!" ═════╗ ╚════════════════ Xiaomi Mi A1 ═════ Huawei Nova 5T ═════════════╝
-
dobragab
addikt
Neked az identifier.c-t kell megírnod, amiben van egy megadott deklarációjú függvény, abba bármit include-olhatsz. A feladat nem várja, hogy a ctype.h-t ne használd, sőt.
Üres sor problémára: az üres sort a gets üres sztringként olvassa be (""), így üres sztringként kapod meg a nevet.
Btw szégyen, hogy versenyen a skeleton-ban gets van.
Tudom, tudom, akasszak a tökömre egy lámpát, hogy sötétben is tudjak kaszálni.
-
bepken
veterán
válasz dobragab #5563 üzenetére
akkor ezek szerint a string.h is használható! ezzel meg is oldódott a problémám, egy strlen segítségével könnyedén meglett az a fránya üres sor is (másképp én nem tudtam megoldani)
el is fogadta a kódot, úgyhogy köszi szépen (hamarosan jövök újabb kérdésekkel )
ez a feladat nem kifejezetten verseny feladat, csak egy beugró. szerencsére/sajnos itt még alap dolgok vannak. minden esetre én egyelőre vizsgán szeretnék átmenni, úgyhogy az egyszerűsítésnek csak örülni tudok
[ Szerkesztve ]
╔═══════ "Csak egy visszatérés létezik és az nem a királyé...hanem a JEDIÉ!" ═════╗ ╚════════════════ Xiaomi Mi A1 ═════ Huawei Nova 5T ═════════════╝
-
aviator
tag
typedef struct koordinata
{
int x;
int y;
int z;
} koordinata;
void beolvas(koordinata* pont)
{
scanf("%d %d %d",&(pont->x),&(pont->y),&(pont->z));
}
int main()
{
int a,i;
printf("Kerem a koordinatak szamat");
scanf("%d",&a);
koordinata* koord = (koordinata*) malloc(sizeof(koordinata)*a);
for(i=0;i<a;i++)
{
beolvas(&koord[i]);
}
for(i=0;i<a;i++)
{
printf("(%d;%d;%d)",koord[i].x,koord[i].y,koord[i].z);
}
free(koord);
return 0;
}Üdv!
A feladat itt az volt, hogy függvénnyel töltsek fel egy koordinátákat tároló struktúrát ahol a struktúrák egy dinamikus tömb elemei. A feladatot sikerült megoldani, a kód így működőképes, egy dolgot viszont nagyon nem értek: A nyíl operátort ha jól tudom akkor használjuk, ha pointeren keresztül akarjuk elérni egy struktúra mezőit. Ha pointer nélkül hivatkozunk akkor a pont operátort használjuk. Ha ez így van, akkor miért van az, hogy a függvény definíciójában a pointer típusú, pont nevű paraméteren keresztül nyíllal hivatkozok a mezőkre, alul a kiíratásnál pedig már ponttal, annak ellenére, hogy a koord változó még mindig koordináta típusú pointer?
[ Szerkesztve ]
-
aviator
tag
válasz aviator #5569 üzenetére
char szoveg[101];
char*szpt;
scanf("%s",szoveg);
szpt=(char*)malloc(sizeof(char)*((strlen(szoveg))+1));
strcpy(szpt,szoveg);
printf("%s",szpt);
free(szpt);Újabb hasonló probléma. A strcpy itt elméletileg egy char típusú tömböt másol egy char* típusú tömbbe, ami nem lenne lehetséges. Sejtem, hogy az előző "indexelés megeszi a pointert" dolognak lesz itt is jelentősége, gondolom itt az indexelés a string-ben áll annak ellenére, hogy nem látszik az indexelő [] operátor. Kiíratáskor pedig látszólag string-ként íródik ki a pointer típus.
Amit nem értek az az, hogy a strcpy két paramétere hogy lesz azonos típusú, melyiknek változik meg a típusa (ha egyáltalán megváltozik) és miért, illetve, hogy a kiíratáskor hogy lesz a pointerből kiíratható string. -
Jester01
veterán
válasz aviator #5570 üzenetére
Ez meg a híres tömb-pointer ekvivalencia. C-ben a tömb automatikusan konvertálódik az első elemére mutató pointerré:
Except when it is the operand of the sizeof operator or the unary & operator, or is a string literal used to initialize an array, an expression that has type "array of type" is converted to an expression with type "pointer to type" that points to the initial element of the array object and is not an lvalue.
[ Szerkesztve ]
Jester
-
jattila48
aktív tag
válasz Jester01 #5573 üzenetére
"A tömb pedig ekvivalens a pointerrel"
Na na! Csak óvatosan! Pointernek adhatsz értéket, tömbnek nem. Ez egy igen lényeges különbség. A tömb, mint cím, fordítás idejű konstans, míg a pointer egy változó, ami futás időben kap értéket. Pointernek veheted a címét (hiszen változó), tömbnek pedig nem (mármint char array[10]; char **p=&array; utasításoknak nincs értelme, míg char *p; char **pp=&p; -nek pedig van). Az, hogy a C-ben és C++ -ban szemantikailag nincs eléggé megkülönböztetve a pointer és a tömb, az a nyelv egyik hiányossága, amellett, hogy nagyfokú rugalmasságot is biztosít.
C++ -ban például teljesen helyénvaló származtatott osztály pointert (D *) publikus ősosztály pointerként (B *) használni, míg D ** pointer B ** pointerként való használata tiltott, nyilvánvaló okok miatt. Ugyanakkor nyugodtan meg lehetne engedni D *[] típusú változó B *[]-ként való használatát, azonban ezt mégsem lehet, mivel nincs eléggé megkülönböztetve a pointer és a tömb.„Kétségtelen, hogy nem tudjuk, mit tegyünk, de felkészültek és elszántak vagyunk.” - Olaf Scholz német kancellár
-
dobragab
addikt
válasz jattila48 #5574 üzenetére
Jól mondod.
Az egyszerűség kedvéért úgy is lehet definiálni, hogy a tömbön mint típuson két művelet értelmezett:
- sizeof
- automatikus konverzió, ami a tömb első elemére mutató pointerré konvertáljaEbből minden más, tömbökre jellemző tulajdonság levezethető:
- indexelni is "csak" a pointert tudjuk, az indexelés meg ugye ekvivalens egy címszámítással és egy dereferálással
- a tomb + 5 kifejezés nem azt jelenti, hogy a tömbhöz adunk ötöt, hanem az elejére mutató pointerhez, azaz a tömb ötödik elemére mutató pointert jelenti
- *tomb egy dereferálás, mégpedig a tömb első elemét jelenti
- a címét nem képezhetjük, hiszen ahhoz először pointerré konvertálódik, az így keletkezett temporális objektumnak nem képezhető a címe
- tömbnek nem adhatunk értéket, hiszen a konverzió eredménye temporális objektum, ami C-ben nem balérték
- függvényparaméterként csak úgy adhatjuk át, hogy előtte pointerré konvertálódik
- ha struktúrába rakod, a neki lefoglalt hely természetesen sizeof(tomb) lesz[ Szerkesztve ]
Tudom, tudom, akasszak a tökömre egy lámpát, hogy sötétben is tudjak kaszálni.
-
Jester01
veterán
válasz dobragab #5575 üzenetére
a címét nem képezhetjük, hiszen ahhoz először pointerré konvertálódik,
Szerinted. A szabvány szerint meg de. Idéztem ott feljebb kicsivel:
Except when it is the operand of the sizeof operator or the unary & operator
Tehát ha & operátort alkalmazol a tömbre akkor nem konvertálódik pointerré.
Jester
-
dobragab
addikt
válasz Jester01 #5576 üzenetére
Benéztem, tényleg van a tömbnek & operátora. Ha & operátort alkalmazol a tömbre, akkor előtte nem konvertálódik pointerré: az maga a konverzió.
int tomb[10];
printf("%p\n%p\n", tomb, &tomb);[ Szerkesztve ]
Tudom, tudom, akasszak a tökömre egy lámpát, hogy sötétben is tudjak kaszálni.
-
dobragab
addikt
válasz EQMontoya #5578 üzenetére
Mindig tanul az ember valamit
Tudomásom szerint sizeof(void*) ugyanazt adja, de tény, hogy ronda hack, szebb az a sizeof(&tomb).
Ebből majd csinálok egy mitírkit C++ topikba, aki olvassa, majd ne lője le pls. Persze azért kicsavarom rendesen.
[ Szerkesztve ]
Tudom, tudom, akasszak a tökömre egy lámpát, hogy sötétben is tudjak kaszálni.
-
EQMontoya
veterán
válasz dobragab #5579 üzenetére
Nem a típustól függ, hanem az elhelyezkedéstől.
nyilván sizeof((void*)tomb) == sizeof(&tomb).Viszont két, azonos típusra mutató ptr nem feltétlen ugynaakkora. Persze x86-on nem lesz különbség, de amúgy, főleg embedded rendszerek esetén lehet. (mondjuk stack, heap és static között)
[ Szerkesztve ]
Same rules apply!
-
dobragab
addikt
válasz EQMontoya #5580 üzenetére
És tényleg. Tegnap nem voltam toppon
Viszont mivel a void* mindenfajta pointerrel (kivéve függvényre mutató pointerekkel) kompatibilis, ezért sizeof(&tomb) <= sizeof(void*). Tény, hogy nem feltétlenül adja ugyanazt elvadult architektúrákon.
Tudom, tudom, akasszak a tökömre egy lámpát, hogy sötétben is tudjak kaszálni.
-
huwil
csendes tag
Hello! Szeretnék egy kis segítséget kérni. Holnap (szerda) délelőttre kellene ezt a két egyszerűnek tűnő programot megcsinálni és kellene hozzá segítség (konkrétan megcsinálni):
Irjon C nyelvu programot, ami
letrehoz ket csovezeteket (ket file deszkriptor part)
elforkol
a szulo elkuldi a sajat pidjet a gyerkmeknek az egyik csovon
a gyermek kiirja a kepernyore es visszkuldi egy az ovet a masik csovon
megszunnek a processzek (a szulo megvarja a gyereket)
és
Irjon C nyelvu programokat, ami
letrehoz egy nevesitett csovezeteket (bejegyzes az fs-en)
megnyitja
beleir valamit
kozben egy masik program kiolvassa a csovezetekbol
ezutan az elso program szinten ir bele valamit
a masik program ujbol kiolvassa
a processzek megszunnek es az elso program eltunteti a nevesitett csovezeteket
Előre is köszönöm, ha valaki tud és segít is benne!
-
aviator
tag
Tisztelt Szakértő Urak!
Újabb kérdésem lenne:
typedef struct koordinata
{
int x;
int y;
int z;
}koordinata;
typedef struct haromszog
{
koordinata* csucsok[3];
}haromszog;Tehát létre lett hozva egy koordináta struktúra három int mezővel, illetve egy háromszög struktúra egy háromelemű pointertömbbel: A háromszög struktúra egy 3D-s háromszöget tárol amelynek három csúcsa van, egy csúcsnak pedig három koordinátája. Azért lett pointer a tömb típusa mert később a koordináták címeire lesz szükség.
A továbbiakban egy egyszerű koordinátabekérést szeretnék csinálni a 0 indexű csúcsra a következő módon:
haromszog triangle; //struktúra típusú változó létrehozása
scanf("%d %d %d", &(triangle.csucsok[0]->x),&(triangle.csucsok[0]->y),&(triangle.csucsok[0]->z))Nem árulok el szerintem nektek újdonságot: ez így nem működik. Lefut, a fordító jónak látja de nem működik. Ti már biztos tudjátok az okát én még nem, viszont a megoldást igen:
haromszog* triangle=(haromszog*)malloc(sizeof(haromszog));
triangle->csucsok[0]=(koordinata*)malloc(sizeof(koordinata));
scanf("%d %d %d", &(triangle->csucsok[0]->x),&(triangle->csucsok[0]->y),&(triangle->csucsok[0]->z))Amit nem értek: miért nem működik lefoglalás nélkül? Miért kell a csúcsoknak is külön helyet foglalni? Azt hiszem sajnos ez már az a szint amikor nagyon összefüggéseiben kéne látnom a dolgokat, úgy tűnik ezzel hadilábon állok.
A válaszokat előre is köszönöm, aki esetleg érez némi motivációt arra, hogy egy kicsit részletesebben elmesélje ezt nekem, felépítve egy gondolatmenetet ami alapján érthetőbbé válik, hogy mi miért van, mi miből következik azzal sokat segítene...akár privátban is, hogy ne terheljük másoknak triviális dolgokkal a fórumot.
[ Szerkesztve ]
-
dabadab
titán
válasz aviator #5584 üzenetére
"Azért lett pointer a tömb típusa mert később a koordináták címeire lesz szükség."
Ez a hiba. Ha szükség van a koordináták címeire, akkor veszed a címüket a & operátorral
Azzal, hogy az a tömb koordinata* típusú, azt mondtad, hogy ez egy pointert tartalmaz egy koordinata structra - és ez ezt is jelenti. Amikor létrehozod a haromszoget, akkor az létrejön, lesz benne három pointer, amik nem mutatnak sehova (pontosabba valami tök véletlenszerű helyre mutatnak), persze, hogy úgy elszáll a program.
Kénytelen leszel feltölteni ezeket a pointereket kézzel, pl. úgy, hogy foglalsz három koordinata structot, aztán azoknak a pointereit berakod (és amikor nem kellenek, akkor majd nyomsz rájuk egy free-t is). Ez remek dolog, ha valamiért te szeretnéd foglalni ezeket vagy más helyen lefoglalt structok pointerét akarnád felhasználni, viszont úgy tűnik, hogy egyáltalán nem ezt akarod, hanem azt, hogy a fordító hozzon létre neked három koordinata structot, meg aztán majd szabadítsa is fel a megfelelő időben.Szóval ez kell neked:
typedef struct haromszog
{
koordinata csucsok[3];
}haromszog;
haromszog triangle;
scanf("%d %d %d", &(triangle->csucsok[0].x),&(triangle->csucsok[0].y),&(triangle->csucsok[0].z));DRM is theft
-
aviator
tag
válasz dabadab #5585 üzenetére
Nem akartam untatni a népet a teljes feladattal, illetve én is csak egy részét próbáltam megcsinálni első körben. Arról van szó, hogy van egy függvény, ami bekér három koordinátát, azaz csúcsonként hármat, tehát egy for ciklussal feltölti a csucsok tömböt 3x3 koordinátával, majd ezután visszaadja a haromszog típusú triangle struktúra címét. (Ezért kell, hogy pointer legyen a tömb típusa.) Ezt a címet veszi át egy másik függvény, ami elvégzi a lefoglalt terület felszabadítását. Eközben a főfüggvényben meg kell még oldani azt, hogy háromszög struktúrából (háromszögekből) is többet lehessen bevinni, méghozzá előre nem meghatározott darabot (dinamikus tömb).
A magyarázatod egyszerűsíthető úgy, hogy azért szállt el a program mert a tömb tele volt null pointerekkel, illetve a hiba a foglalással azért oldódott meg, mert a foglalás után a pointereknek már lett értékük? Tehát inicializálatlan pointerekkel nem dolgozunk?
-
huwil
csendes tag
válasz EQMontoya #5590 üzenetére
Köszi a segítséget, közben nekem is sikerült úgy ahogy összedobnom, csak akadtak problémák, nevezetesen elkezdett sírni a program, hogy pipe meg a fork funkciók nincsenek definiálva...aztán leesett (meg utána olvastam), hogy ez valószínűleg a windows-os compiler miatt van, ami a linuxos dolgokat természetesen nem nagyon tudja lekezelni szóval leszedtem egy elvileg működő compilert (cygwin), azzal már nem sír, konkrétan annyira nem csinál semmit, hogy még hibát se dob ki...mindegy, van egy elvileg működő kódom, a többit meg kimagyarázom, de azért köszi a helpet!
-
dobragab
addikt
Vagy gyártasz egy virtuális Ubuntut.
Windowson ez pont sose fog rendesen menni, még cross compilerrel sem (asszem, nem vagyok benne biztos), mert a fork-nak nincsen windowsos megfelelője. De valaki javítson ki, ha tévedek.
Tudom, tudom, akasszak a tökömre egy lámpát, hogy sötétben is tudjak kaszálni.
-
dabadab
titán
válasz dobragab #5593 üzenetére
A Cygwinben van fork() (elég munkás lehetett megcsinálni, mert a Win32 API-ban csak CreateProcess() van, az meg eléggé máshogy működik).
Ezzel együtt felrakni egy virtuális gépre Linuxot meg azzal játszogatni javasolt, mert elég komoly pedagógia értékkel bír
[ Szerkesztve ]
DRM is theft
-
-
EQMontoya
veterán
-
dobragab
addikt
válasz EQMontoya #5596 üzenetére
Ó én mindent, és meg is van az értelme.
Elsődlegesen Win8.1 + Classic Shell.
Ezen kívül:
arch linux + gnome3
ubuntu 14.04 + cinnamon
linux mint + cinnamon (már nem használom)
ubuntu 16.04 + kde5 (csak kipróbáltam, lassan kuka)
win7
win10 + classic shellMindez egy gépen. Amúgy az egyik cinnamonra kifejezetten büszke vagyok
Tudom, tudom, akasszak a tökömre egy lámpát, hogy sötétben is tudjak kaszálni.
-
feketeg5
csendes tag
Sziasztok!
Ha valaki segít megoldani az alábbi feladatot, hálám örökké üldözni fogja. A szombati vizsgámhoz kellene megírnom sima C-ben, úgymond "egyetemes" programozással, nem összebarkácsolva, inputellenőrzésekkel stb. Nekifeküdtem már sokszor a programozásnak, de egyszerűen nem áll rá az agyam.
A feladat a következő:
400 nál nagyobb egész számokat kellett bekérni és azokat vizsgálni. Tömb méret nem volt megadva. Csak a példában 5 helyiértékes szám volt a legnagyobb azért azt vettem alapul. A számnak páratlan számjegyűnek kellett lennie , és tükrösnek (Pl:12321). A feladat hogy addig kérd be a helyes számot amíg 2 helyes számot nem kapsz. Hiba üzenetetek:
-nem szám a bemenet
-400nál kisebb a bemenet
-Nem páratlan számjegyű.
-Nem tükrös számÉletet mentene a segítség, ha tudom, viszonoznám!
[ Szerkesztve ]
-
dobragab
addikt
válasz feketeg5 #5599 üzenetére
Megírni nem fogom helyetted, de azért ötleteket adok.
Dönthetsz, hogy szövegként dolgozol-e vele, vagy számként. Előbbi esetben a karaktereket egyszerű összehasonlítani és a hosszát meghatározni. Ha számként használod, akkor egy kicsit több matek kell hozzá, de szebb a megoldás.
Tudom, tudom, akasszak a tökömre egy lámpát, hogy sötétben is tudjak kaszálni.
Új hozzászólás Aktív témák
● olvasd el a téma összefoglalót!
● ha kódot szúrsz be, használd a PROGRAMKÓD formázási funkciót!
- Azonnali VGA-s kérdések órája
- Végre megjelenési dátumot kapott az xDefiant
- Kerékpárosok, bringások ide!
- Apple iPhone 15 Pro Max - Attack on Titan
- Bemutatkozott a Moto G32 4G
- Lakáshitel, lakásvásárlás
- SSD kibeszélő
- Dark Souls sorozat
- Honor Magic6 Pro - kör közepén számok
- SkyShowtime
- További aktív témák...
- Apple iPhone 14 128gb Midnight + Garancia
- Apple iPhone 12 Pro Max, Pacific Blue, 128Gb, független 86% akku
- Szuper Akció:Igényeseknek-Exkluziv-12Genes-Core i7-Dell Latitude 5430-Harmad áron-garival!!!
- Western Digital 6TB NasWare 3.0 WD60EFRX-68l0bn1 keveset használt eladó.
- ÚJ Under Armour HOVR Machina 2 futócipő,sportcipő 44-es méretben eladó
Állásajánlatok
Cég: Ozeki Kft.
Város: Debrecen
Cég: Promenade Publishing House Kft.
Város: Budapest