Új hozzászólás Aktív témák
-
Hunmugli
aktív tag
válasz
bandi0000
#3774
üzenetére
Ezt elvileg tudom mi
Mondom, félrement a // ez mi? --> a mainhez akartam írni
ez egyébként annyit tud, hogy asd értékét beállítja arra, ami a zárójelben van. Ez főleg akkor jó, ha asd egy constans, mert bármilyen más módszerrel hibát dobna (a constans az konstans
)dobragab: köszönöm a részletes magyarázatot
-
Hunmugli
aktív tag
válasz
bandi0000
#3769
üzenetére
Nyugi, az alapokkal [...] tisztában vagyok. Hamarosan Sololearn certifikációt is szerzek
[mellesleg csak ajánlani tudom, remek app, és böngészőben is fut.] Az értékadást nem y-ra értettem, hanem x-re.Szóval hogy adok ennek értéket?:
int x(int(int));
//értékadás
cout << x << endl; //x ne legyen 1dabadab: így már más. És akkor ez mi: értékadás vagy constructor?
#include <iostreams>
using namepsace std;
class valami {
private: int asd; //igen, asd
public:
valami (int a) : asd (a) { } //szoval ez mi?
};
int main () {
valami mas = 2;
}Remélem jól írtam
-
Hunmugli
aktív tag
válasz
bandi0000
#3767
üzenetére
C:
, asszem c++14-gyel. (gnu gcc)Vagy cpp.sh-val - bár megnézve a figyelmeztetést, szerintem pointereket hoz létre. De értéket nem tudok neki adni
Van ez a módszer:
int y(15);Azt akartam kipróbálni, hogy van-e ilyen:
int y(15);
y(2*y);Mert az első esetben a () értékadás, hát a másodikban miért ne működne?
(nem működik, y is not a function)Aztán valahogy az előző kommenben lévő kódot kreáltam
-
-
sko
csendes tag
válasz
bandi0000
#3673
üzenetére
A problémára két egyszerű megoldás létezik.
1. tegyél egy
cin >> ws;-t acin.getline()elé.2. használj a második, azaz a szám beolvasásához is
getline()-t.A lényeg, hogy a getline egy adott delimiterig olvas és azt el kell tüntetni az input buffer-ből, mielőtt a második ciklus eljut a getline()-ig. Azaz egy további "retro" megoldás lehet
3. tegyél egy
getchar()-t acin.getline()elé.A getline delimiterét egyébként megadhatod neki harmadik paraméterként. A default értéke '\n'.
-
dobragab
addikt
válasz
bandi0000
#3668
üzenetére
A szám beolvasása után dobj bele egy ilyet:
cin >> ws;Ilyenkor az történik, hogy a szám beolvasásánál te ezt írod be:
"5\n"
A beolvasás megeszi az 5 karaktert, az utána lévő pufferben benne marad az enter. Majd jön a getline, ami enterig olvas. Azonnal megtalálja a pufferben az entert, tehát visszatér üres sztring beolvasása után, mindezt user interaction nélkül.A
cin >> wsannyit csinál, hogy cin-ről beolvassa és lenyeli az összes whitespace-t, de a többi, értékes karaktert nem. Azért jobb ez, mint a simacin.ignore(), mert ez azt is le tudja kezelni, ha a user ezt írta be:"5 \n"(#3669) PumpkinSeed
A clear nem a puffert üríti, hanem a hibajelző flageket
-
cattus
addikt
válasz
bandi0000
#3665
üzenetére
így ahogy kiírattam cout-tal, kerekített, de viszont ha az atlagba beletöltöttem, az összeget, és azt a couton belül leosztottam i+1-el, akkor viszont jó lett és nem egészet írt ki, én bénáztam?
Gondolom az
atlagváltozódinttípusú, így amikor azatlag=osszeg/i+1;műveletet elvégzed, a gép egész osztást csinál. Hogy ezt a bugot kijavítsd, az osztás egyik oldalán lévő változót kasztolni kell double típusra:atlag=(double)osszeg/(i+1);Érdemes továbbá rendesen bezárójelezni a műveleteket.
-
#3663
PumpkinSeed
addikt
bandi0000
#3662
PumpkinSeed
addikt
válasz
bandi0000
#3662
üzenetére
Egy jó tanács a kezdetekre. Vannak a változóid:
int i2, db, ossz2=0, jegy[20], jelesdb=0;Ha a jövőben programot írsz akkor törekedned kell arra, hogy a változónevek egyértelműen a funkciójuk alapján legyenek elnevezve. Ez az egyik legnehezebb része a programozásnak. Én például van, hogy 10 percet ülök egy változónév felett.Miért kell ez a baszakodás? - Teszed fel magadban a kérdést. A programozásnak nem az a lényege, hogy egy kódot megírsz, elkészítesz, vagy álmatlan éjszakádon kiokomulálsz és az a végtelenségig tökéletesen fog működni. Olykor-olykor megesik az, hogy fél évvel később vissza kell térned, hogy változtass valamit, és nézed a kódot, ami majd 5000 sor, ahol olyan változók vannak mint a
jegy[20]vagy a barátai mellette. Na ebben az ilyen esetekre kell normális változó és később függvény, metódus neveket adni.Általában a for ciklus index változóit ami ebben az esetben "i2" (el nem tudom képzelni miért), i-vel szoktuk jelölni, ha véletlen egymásba ágyazott ciklusaid vannak, ami amúgy kerülendő a komplexitás növekedésének elkerülése végett, akkor használhatsz j-t vagy a következő betűket az angol abc-ből.
Törekedni kell az angol elnevezésre is, de ez opcionális. Illetve a camelCase használata változók, függvények és metódusok közben. A camelCase azt jelenti, hogy az első szó kis kezdőbetűs míg a többi nagy, pl.: mintEzItt. Ezt a metodikát követve, illetve értelmesebb neveket adva a változóidnak:
db -> pieceOfSomething // El nem tudom képzelni minek a darabja
ossz -> countOfSomething // Szintén nem tudom minek az összege
jegy -> marks[20] // Mivel tömb ezért többesszámba kell tenni
jelesdb -> countOfALevel // Ez godolom a meglévő ötös érdemjegyek darabszámát jelzi.Ha valaki jobb neveket tud a kód mivoltának tudatában, akkor javítson ki.
-
dobragab
addikt
válasz
bandi0000
#3659
üzenetére
Naakkor sorolom.
- A bemenet ellenőrzésével erősen ellenjavallott ennyit tökölni. Ha valami nem stimmel, kiírni, hogy szar a bemenet és rage quit. Konzolos program úgyse lesz sose user-friendly, de így elveszik a lényeg a sok marhaság között.
- Ha a
cin.clear()és acin.sync()nélkül nem működik egy algoritmus, akkor szar. Ráadásul nem feltétlenül végtelen ciklus, ha kihagyod, csak bizonyos esetekben. Megint csak az van, hogy ne próbálj user-friendly lenni.-
for (i2=db; i2<db; i2++)
Ez így ebben a formában nem csinál semmit. És nem is tudok rájönni, hogy hány darabot kéne randomgenerálni.-
int i2, db, ossz2=0, jegy[20], jelesdb=0;
Ezért dupla nyers hal jár. Egyrészt egy sor, egy deklaráció! Másrészt minden változót akkor deklarálj, amikor szükséged van rá, sose előbb! Ez C++, és kb. minden C89-től különböző nyelv és Linus-tól különböző programozó megengedi.- Tessék mán
for(int i-t írni, akkor nem kell számozni a ciklusváltozókat (i2). Lásd előző pont.- A végén az átlagszámítós - ötösszámolós ciklus a lényege az egésznek, azt kellett volna faszán elmagyaráznia a tanárnak. És nem a C++-specifikus beolvasós trükközgetésekkel terhelni az agyatokat, az égvilágon semmi értelme. Feltételezem, hogy nem magyarázta el a lehető legérthetőbben, mert akkor külön for ciklust kaptak volna, ahogy illik.
Így röviden ennyi, ami a kódot érinti.
Na és akkor a kérdésed.
A cin belső flagekben tárolja, hogy volt-e valami hiba a beolvasás során, például ha te számot akartál beolvasni, de a júzer azt írta be, hogy
hesstegfoskód, akkor a cin nem dob hibát, hanem megjegyzi, hogy valami büdös volt, és te akkor ellenőrzöd, amikor akarod. Ezt acin.fail()-lel, meg még két hasonló függvénnyel tudod megtenni, mindegyik máskor jelez. Ha a következő beolvasás sikerül, akkor is megmarad a flag, tehát nem írja felül a hibás állapotot. Vagy csak annyit írsz acin.fail()helyett, hogycin.if(cin) // nem kell ide semmi, ilyenkor igaz-hamissá konvertálódik
cout << "Minden rendben volt.";
else
cout << "Szar van a palacsintában.";Ezeket a flageket a
clear()-rel tudod kipucolni, hogy ha az előző beolvasás elfailelt, akkor is lásd, hogy a következő jó-e. -
dobragab
addikt
válasz
bandi0000
#3647
üzenetére
Másik jó megoldás, hogy generálsz egy 90 elemű tömböt. Aztán ötször:
- generálsz egy n-t 0-89-ig,
-tomb[n]-t kiválasztod
- majdtomb[n]-t kiveszed tomb-ből. Ez legegyszerűbbentomb[n]és az utolsó elem cseréjével oldható meg, és ezután már 0-88-ig generálsz n-tKódban még egyszerűbb is.
int megoldasok[5];
int tomb[90];
for(int i = 0; i < 90; ++i)
tomb[i] = i;
for(int i = 0; i < 5; ++i)
{
int n = rand() % (90-i); // jó, éles kódban ne rand-ot használj
megoldasok[i] = tomb[n];
std::swap(tomb[90-1-i], tomb[n]); // vagy sima segédváltozós csere
}Nem próbáltam ki, lehet benne elírás...
-
EQMontoya
veterán
válasz
bandi0000
#3643
üzenetére
Arra miért nem jó egy másik shuffle?
De ha nem akarsz shuffle-t használni:
std_vector<int> nums;
std_vector<int> results;
for(int i=1;i<=90; ++i)
{
nums.push_back(i);
}
for(int i=0;i<5;++i)
{
int rand_index = //generálsz egy randomot 0 és nums.size()-1 között.
result.push_back(nums[rand_index]); //berakod a generált számot a végeredmény containerbe
std::vector<int>::iterator it = ( nums.begin() + rand_index ); //szerzel egy iterátort az indexelt elemre
nums.erase(it); //ezt az elemet törlöd a containerből
}A fenti megoldásnak az az előnye, hogy amit egyszer kisorsoltál, azt ki is veszed, így legközelebb egyel kisebb méretű vektorban sorsolsz, ami így nem is fog tudni ütközni.
-
bandi0000
nagyúr
-
Karma
félisten
válasz
bandi0000
#3635
üzenetére
Ennél csak jobb megoldás van. Egy dolog, hogy nehezen olvasható és követhető a ciklusváltozók belső manipulációja miatt, de még le is fagyhat az algoritmusod (még ha ez egy ötöslottónál nem is valószínű).
Szerintem itt nem baj, ha a valóságra támaszkodsz: vegyél egy vectort, benne a számokkal 1-90 között, használd az std::shuffle függvényt hogy megkeverd őket, és vedd ki az első öt számot.
-
bandi0000
nagyúr
válasz
bandi0000
#3634
üzenetére
ezt végül is megoldottam, csak le kellett tölteni
viszont van egy kis prog feladatom, beadandót kéne csinálni, sima lottó sorsoltás, ugyebár nem ismétlődhet 0-90 ig ezzel nincs is gond, csak van e ennél egyszerűbb vagy szebb megoldás?
dupla for, mindkettő elmegy <6-ig, első for alatt random számot generálok, a 2. for is <6-ig megy, de ott meg megvizsgálom, hogy az eddig kisorsolt számok között van e olyan mint amit most sorsoltam, ha nincs akkor beletöltöm a tömbbe, ha van akkor meg az első for változóját, (i-t) minuszolom egyel, tehát hogy sorolja ki még1-szer azt
-
dobragab
addikt
válasz
bandi0000
#3463
üzenetére
Amit te tanultál, az nem C++, hanem C. C++-ra hirtelen nem is tudok jót mutatni, de C-re igen.
Innen kezdd, és az előadások anyagait nézd elsősorban. Laborok anyagai kisebb-nagyobb gyakorlófeladatok az előadás anyagához, a gyakorlatok anyagában pedig "komolyabb" feladatokat találsz.
Soknak és gyorsnak tűnhet, de neked elég az első 6. előadás anyaga + némi hozzá tartozó gyakorlás.
-
dobragab
addikt
válasz
bandi0000
#3460
üzenetére
A 3-6-os feladatok mindegyike megoldható úgy, hogy nem tárolod el mind a memóriában. Pl:
int utolso_dobas;
while(fscanf(fp, "%d", &utolso_dobas) == 1)
{
// legutóbbi dobás kezelése
}Direkt nem írtam többet, ez pl. 2 sorral kiegészítve megoldja a 3-as feladatot.
És azért C, mert a kolléga eddig C-ben gyakorolt. Ugyanez C++-ban:
int utolso_dobas;
while(std::cin >> utolso_dobas)
{
// legutóbbi dobás kezelése
} -
dabadab
titán
válasz
bandi0000
#3460
üzenetére
Semmi szükség arra, hogy az egészet a memóriában tárold, elég csak az éppen aktuális dobást tárolni meg persze a mindenféle egyéb számlálókat, amiket elő kell állítani. Vagyis soronként beolvasod a file-t, de a beolvasott értéket nem tárolod el semmiféle tömbben meg sehol, csak növeled a számlálókat stb.
-
dabadab
titán
válasz
bandi0000
#3457
üzenetére
"az összes adat memóriában történő egyidejű eltárolása nélkül oldja meg"
vs
"megpróbáltam beledobni egy tömbbe"
Akkor itt "a feladat elolvasása" rész sem sikerült
Egyébként mit kell kiszámolni a bejövő adatokból?
(#3452) jattila48: alapvetően azért kaptad a kritikákat, mert egyrészt C++ topikban egy tanulónak C példakódot adsz (lásd még: "minden nyelven lehet FORTRAN-ban programozni"), másrészt a konkrét kód több dologban is rossz példát mutatott.
-
dobragab
addikt
válasz
bandi0000
#3451
üzenetére
A memóriában minden karakter számként van tárolva, hogy melyik karakterhez milyen érték tartozik, azt itt meg tudod nézni, ez a leggyakrabban használt karakterek kódja. A többi karakternek a számértéke nem egységes, és elég macerás, arról nem kell tudnod.
A '0' karakterhez a decimális 48 tartozik, és azt követően minden számjegyhez eggyel nagyobb. Amikor string-ként olvasol be, akkor valójában sok karaktert kapsz, ezért kell kivonnod belőle '0'-t, hogy a karakter konkrét számértékét kapd.
-
dabadab
titán
válasz
bandi0000
#3447
üzenetére
Ez is C-ben van
Tényleg nem oktatnak C++-t?C++-ban így lehet stringet intté konvertálni:
std::string hex="0abc";
int i=std::stoi (hex,nullptr,16);(Nézd meg az stoi dokumentációját, a második paraméterének a segítségével végig lehet menni az egész IPv6 stringen)
-
jattila48
aktív tag
válasz
bandi0000
#3429
üzenetére
Egy hatékony megoldás:
const char *ipv6_addr="2001:0e00:41a0:006b:00de:03c0:0e00:60bc";
char trimmed_ipv6_addr[40];
int trim=1,j=0;
for(int i=0;i<strlen(ipv6_addr);++i){
char c=ipv6_addr[i];
if(c==':')trim=1;
switch(trim){
case 0:
trimmed_ipv6_addr[j++]=c;
break;
case 1:
trimmed_ipv6_addr[j++]=c;
if(c=='0')trim=2;
else if(c!=':')trim=0;
break;
case 2:
if(c!='0'){
trimmed_ipv6_addr[j++]=c;
trim=0;
}
break;
default:
//ilyen nem lehet
;
}
}
trimmed_ipv6_addr[j]=0;Akár "helyben" is elvégezhető (ha az átalakítandó karaktertömb már eleve a trimmed_ipv6_addr változóban van).
-
-
-
ToMmY_hun
senior tag
válasz
bandi0000
#3399
üzenetére
A BSc elvégzése nagyon ajánlott. Nélküle nem, vagy nagyon kis eséllyel fogsz bejutni komolyabb cégekhez. Persze lehetsz kivételesen nagy tehetség, de egy diploma akkor sem árt.
#3402 - bandi0000 Pedig nagyon is hasznos. Nem az átadott konkrét tudás miatt, hanem a gondolkodásmód miatt, amire késztet/rávezet ha arra alkalmas vagy.
-
dabadab
titán
válasz
bandi0000
#3397
üzenetére
"Én nem látom át a c++-t"
Tizenpár éve programozok benne, de én se merném azt állítani, hogy átlátom
De persze a nyelv nagyját viszonylag gyorsan össze lehet szedni, a mindenféle idióta elfajzott eseteket (itt a topikban is volt mostanában pár "na, mit ír ki ez a pár soros program?" kérdés) meg kb. soha De ahhoz, hogy nekiállj programozni meg megérte mások kódját, egyáltalán nem kell reménytelenül sokat tanulni.Ami a szintaxison túl még nagyon fontos (sőt, igazán ez a fontos), az az, hogy hogyan lehet jól bánni azzal a sok-sok eszközzel, amit a C++ az ember kezébe ad - ezen a téren amit szokás ajánlani, az Scott Meyerstől az Effective C++ - aminek közben lett egy C++11-ről szóló folytatása, az Effective Modern C++ - ez mondjuk nem kifejezetten kezdőknek szóló könyv, mert ahhoz, hogy megértsd a megoldásokat, nem árt ismerni a problémát, amit megoldanak
- márpedig itt sokszor olyan problémákról van szó, amik kis programoknál nem jönnek elő, csak nagy projekteknél. -
dabadab
titán
válasz
bandi0000
#3393
üzenetére
"Ahha, gyakorlatilag a for, if, scanf, scanf, printf, fprintf, while, do while, ezeket ismerem meg pár függvényt a string.h ból"
Jó, akkor ebből felejtsd el a scanf-t, printf-t meg a string.h-t (oké, a printf-fel gyakran össze lehet futni, más nyelveken is, mert a maga módján roppant kényelmes, de C++-ban az is tele van csapdákkal). Azok a C-hez tartoznak és a népszerű tévhittel ellentétben a C-nek meg a C++-nak, mint nyelvnek, nincs sok köze egymáshoz. C-ben meg ma már alig valaki programoz, az sok szempontból az assembler helyét vette át.
Helyette használd a C++-os megoldásokat, amit az előbb írtak: string és streamek, stream operátorokkal."ha meg nem vesznek fel fősulira gyakorlatilag semmit se érnék el vele ha tudnám mert papír nélkül és gyakorlat nélkül úgy se kellenék sehova"
Programozókra iszonyat kereset van, jóval nagyobb, mint a kínálat. Ha nincs diplomád, az gond lehet a bértárgyaláson, de ha tudsz programozni, akkor találsz állást.
-
EQMontoya
veterán
-
EQMontoya
veterán
válasz
bandi0000
#3382
üzenetére
A scanf egy C-s őskövület szar, amivel igazából csak magadat szopatod, mert amilyen csúnya a szintaxisa, olyannyira kényelmetlen is használni.
Neked pedig ennyire van szükséged:
#include <fstream>
std::ifstream infile("thefile.txt");
std::string line;
while (std::getline(infile, line))
{
//itt a line-ban kapod meg a file aktuális sorát
} -
EQMontoya
veterán
válasz
bandi0000
#3380
üzenetére
de 3 héttel érettségi előtt nem nagyon akarok már új dolgot tanulni, de azért köszönöm
Kb. egy óra megtanulni és tök kényelmesen használható.
Ezt a hozzáállást meg felejsd el sürgősen, egyetemi vizsgákra még a vizsga előtti éjszaka is fogsz újat tanulni! Nah, uzsgyi!
Ha nem megy, kérdezz és segítünk. -
bandi0000
nagyúr
válasz
bandi0000
#3374
üzenetére
Még egy kérdés,hogy tiszta legyen érettségire készülök emelt infón, a feladatsorokat csinálom, mind1 is, de beolvasom a txt-t, amibe így vannak az adatok:
Vezetéknév keresztnév párt
na már most, rosszul tudom hogy ha ezt az egészet %s-el akartam volna beolvasni ami később kiderült hogy nem is jó, de a lényeg hogy a %s nem lezáró 0-ig olvas? mert nekem csak úgy olvasta be az egész sport ha úgy adtam meg hogy, %[^\n]\n, így az enterig mindent beolvasott
-
Dave-11
tag
válasz
bandi0000
#2462
üzenetére
Igen, csak így nem haladsz egy sort sem a fájlban, és kapsz egy végtelen ciklust.
Tegyél bele még egy getline(f,temp); sort, ahol f a fájl, a temp meg egy ideiglenes string, azt csak arra használod hogy beolvasd az aktuális sort, és így szépen végighalad a fájlon és megkapod hány sor van benne.
Csak arra vigyázz hogy ha mondjuk üres sorra végződik, akkor azt is beolvasod és úgy veszed mintha ott is lenne adat. Ezért mondjuk tehetsz a while-ba egy if szerkezetet, hogy az n értékét csak akkor növelje, ha mondjuk a beolvasott sor nem egy üres string: temp!="". -
bandi0000
nagyúr
válasz
bandi0000
#2448
üzenetére
Ezért szeretek ide írni, mert egyrészt segítetek sokat amit köszönök, meg így én is tudok gondolkozni, végül így oldottam meg:
for(j=1;j<7;j++)
{for(i=0;i<n;i++)
{
if(napok[j]==t.nap)
napok[j]=0;
}}
for(i=1;i<7;i++)
{
if(napok(i)!=0) printf("Ezen a napon pihent: %d\n",napok(i));
}kinulláztam egy napok tömbbe azokat az értékeket amiket megtalált, és ahol nem volt nulla azt meg kiírattam, a második kérdéses feladatnak meg holnap esek neki
-
kingabo
őstag
válasz
bandi0000
#2441
üzenetére
Végig gondoltad, hogy az általad írt program mit csinál? A napok egy 10 elemű tömb első (0.) elemére mutat, amin indítasz egy ciklust, ami addig fut amig a fenti ptr értéke nem 0. De hol állítod a ptr nullára? Sehol -> végtelen ciklus! Az if-ben lévő feltételt nem értem, de a fenti tömb -1-edik elemére állítod teljesülés esetén a ptr-t. Aztán a -2, -3...
Én megszámolnám egy tömbben, hogy melyik nap hányszor szerepel, aztán már csak 7 elemet kell ellenőrizni, hogy melyik 0.Spoiler!
Én csinálnék egy 7 elemű tömböt, kinulláznám, és a napokban lévő számok -1-el indexelve mindig növelném az ott lévő értéket. (nyilván előtte ellenőrizendő, hogy a tömbbön belüli lesz-e az index...) Aztán a fenti ciklus után egy másik ciklus végig nézi, hogy a fenti tömbben hol maradt 0 érték.A másodikra szerintem is a struct a jó. Nyilván amikor a másik 2 értéket is megadod, akkor kiszámolod a távot és az alapján pedig a költséget.
-
cattus
addikt
válasz
bandi0000
#2441
üzenetére
Mivel csak 7 lehetséges érték van, én megpróbálnám, hogy leellenőrzöm egyesével, hogy benne vanak-e a tömbben egy for ciklussal végigmenve, azon belül pedig egy while-t használva:
for (int i = 1; i <= 7; i++)
{
int j = 1; // ez itt vagy 1 vagy 0, attól függ, hogy kezeled a tömböket
while ((t[j] != i) && (j < "tömbhossz")) // a tömbhossz persze egy változó, előtte meg kéne adni az értékét mondjuk egy while ciklussal, ami addig növeli az értékét, amíg nem ér el az első NULL értékig
{
j++ ;
}
if (j > "tömbhossz") //túlfutott a while ciklus, azaz az i aktuális értéke nem szerepelt a tömbben
{ eltárol();
}
}
} -
Dave-11
tag
válasz
bandi0000
#2431
üzenetére
Hát például itt kihasználhatod azt, hogy egy bizonyos értéknél nem lesznek nagyobbak a számok. Ugye írnod kell egy ciklust, ami végigmegy az összes adaton.
Még a ciklus előtt csinálsz két változót, az egyik a nap számát tárolja, a másik meg a fuvar sorszámát.
Azt a változót, ami a nap számát tárolja, felveszed 8-ra. Ez ugye hülyeség, de ennél már biztos hogy csak kisebbet fog találni az adatok között. A fuvarszámot tárolót szintén felveszed egy nagy számra (ha jól emlékszem ennél a feladatnál meg van adva, hogy egy nap hány fuvart mehet).
És a ciklusba szépen beleírod, hogy ha az aktuális adat napja kisebb vagy egyenlő mint az eddig eltárolt, és a fuvarszám is kisebb vagy egyenlő mint az eltárolt, akkor átállítja azokat ezekre az értékekre. Meg persze ezzel együtt lemented a megtett km-ek számát is, és a végén csak kiíratod ezeket a változókat. -
#2432
h1ght3chzor
őstag
bandi0000
#2431
h1ght3chzor
őstag
válasz
bandi0000
#2431
üzenetére
Az adataidnak alapból rendezve kéne, hogy jöjjenek, legalább hétre lebontva, különben nem tudod megmondani szerintem. A buborékrendezést pedig utána a heteken belül csináld meg, hogy hétfő-kedd stb sorrendben legyenek, ezután végigmész a listán: hétfőtől kezded napok szerint++, és ha van km, akkor kiíratod, és ugrassz a következő hétfőre.
-
Dave-11
tag
válasz
bandi0000
#2426
üzenetére
1. Miért próbálod a rendszámot két részként beolvasni a kötőjel mentén? A feladat megoldása során nincs majd arra szükséged, hogy azokat külön kezeld.
2. Az nem gond, hogy ami a forrásfájlban 09, és azt beolvasva neked csak 9, mert ez így helyes. Két feladat van még ott, ami azzal kapcsolatos, hogy kiírd az időt:
- az egyikben elég ha csak 9-et írsz ki
- a másik pedig külön kéri, hogy a nullákat is tedd oda, de azt megoldod egy egyszerű if szerkezettel majd, például így:
if(ora<10)
{
printf("0%d", ora);
}
else
{
printf("%d",ora);
}
és így tovább a percnél és a másodpercnél isFigyelj oda az ilyenekre, hogy felesleges dolgokból ne csinálj problémát, ezt mint szintén érettségire készülő társad mondom neked
-
bandi0000
nagyúr
válasz
bandi0000
#2425
üzenetére
Bocs a sok hsz-ért de nem tudok szerkeszteni, szóval itt járok:
Egyrészt az a gond, hogy hiába raktam a beolvasáshoz a kötőjelet hogy az első felét és a 2. felét a rendszámnak külön olvassa be, mert most csak 1 char-ba olvasta be és hiába járatom az i-t 0-tól legalább az első 10-15 sor hiányzik azt nem olvasta be valamiért, de gondolom lehet hozzá köze annak, hogy a forrásfájlba úgy van hogy: 09 de kiíratásnál csak 9-et ír
-
cog777
senior tag
válasz
bandi0000
#2423
üzenetére
C-ben azert nehezebb programozni mint C++-ban. Biztos hogy C-ben akarod megcsinalni? Ugyanis C-ben nagyon kell figyelni dolgokra, pl ha elszursz egy pointert akkor megjosolhatatlan lehet a program viselkedese, vagy ha nem inicialialsz 0-val egy teruletet ahol string-et tarolsz akkor a printf tovabbi karaktereket is kiirat mert nem talalja a 0-a veget.
for ciklust 1-es index-el kezdted, igy akartad?
fscanf beolvassa ugyan az ertekeket es a string-et is de mi a garancia hogy a string pont akkora a szovegben mint a memoria teruleted:char re[3][7]? Mivel csak 7 karaktert foglaltal le es nem 8at azert hogy 0-t rakj a vegere ezert a printf tovabb irja a szoveget mint 7 karakter.printf utolso parametere nem &re[ I ]hanem csak re[ i ]
"Elvileg ennek tökéletesen kellene mennie"
Bocsanat, nem kotekedesnek szanom, de szerintem a buffer overflow betoreseket is ezek a kielentesek okozzak
Ugy erdemes programot kesziteni hogy torekszel arra hogy a hiba lehetosegek szamat minimalisra szoritsd.
Hacsak nem kifejezetten C-t akarsz tanulni linux kernel driver iras miatt, akkor inkabb hasznalj C++-t modern technologiakkal:std::array ahol beallitod a meretet a tomb-nek, .at(index) -el elered az elemet (es ha tul index-elsz akkor egybol latod mi a baj), komplett sort olvasnek be a helyedben es std::string-et hasznalnek majd onnan masolnam at az egyes reszeket struct-t ba mivel ezek a sorok egybe tartoznak.
Remelem sikerul atirnod! Sok sikert!
-
bandi0000
nagyúr
válasz
bandi0000
#2416
üzenetére
Igazából a beolvasás/kiíratás se sikerül, 7 karakter hosszú a rendszám max, integerek meg csak 2 számjegyesek, és 3 db-ot próbálok beolvasni de elég fars értékeket dob vissza
A beolvasandó szövegnek meg ilyen a formátuma:
08 46 51 FD-2717
08 47 11 ZI-2088
08 48 52 EL-8894
08 50 34 SZ-3078
08 50 57 XY-8616
08 51 51 FY-2063
08 52 42 AY-2194 -
mgoogyi
senior tag
válasz
bandi0000
#2394
üzenetére
Akkor nem tudod szétválasztani az előadót és a szám címét, a kettőt egy stringként tudod csak kezelni.
egyben kezelés:
char src[512] = "3 4 5 elthon john: daralt macska";
int x,y,z;
char buff[512];
sscanf(src,"%d %d %d %[]", &x,&y,&z,buff);
printf("%d %d %d %s\n",x,y,z,buff);ha esetleg lenne egy fix elválasztó karakter:
char eloado[512];
char szam[512];
sscanf(src,"%d %d %d %[^:] %*c %[]", &x,&y,&z,eloado,szam);
printf("%d %d %d %s %s\n",x,y,z,eloado,szam);%[] : olyan string, amiben bármilyen karakter lehet, pl. szóköz is (%s-sel white spaceig olvas, pl. tab,szóköz,enter megszakítja a stringet)
%[^:] : olyan string, amiben nincs :
%*c : olvass egy karaktert, de nem kell semmilyen változóba berakni a * miatt -
Karma
félisten
válasz
bandi0000
#2382
üzenetére
Bemásolom amit még hat előtt nem tudtam befejezni.
---
Folytatva a gondolatmenetedet a C# topikban: "a franc tudja mi ez de akkor sem működik"
Hát nincs az az isten, aki tudja hogy ez a kódrészlet mi akar lenni.Egyrészt attól, hogy a ciklusváltozót 2-112 (111 ciklus) között futtatod, ugyanúgy a fájl első sorától kezdi beolvasni. Az olvasást különösebben nem érdekli a ciklusváltozód.
Másrészt az is biztos, hogy a sor végén lévő szövegeknek nem jól foglaltál helyet. Most foglaltál 19 karakternyit, miközben neked 112-szer 20 kellett volna (kétdimenziós karaktertömb). Helyette char[112][21] kellene alaphangon. Így már az fscanf alapvetően rendben lenne.
A plusz egy soros problémát meg úgy kellett volna megoldanod, hogy fscanf helyett a fgets() függvénnyel egész sorokat dolgozol fel, aztán sscanf-fel szeded ki belőle az adatot. A legelső sort meg egyszerűen eldobod.
-
skoda12
aktív tag
válasz
bandi0000
#2382
üzenetére
Ezt most nem probaltam ki, forditas nelkul teszem be ide, de kb jol kiveheto a lenyeg. 10 db max 45 karakter hosszu string beolvasasa es kiirasa:
char str[10][46];
int i;
for (i = 0; i < 10; i++) {
scanf("%s", str[i]);
}
for (i = 0; i < 10; i++) {
printf("%s\n", str[i]);
} -
skoda12
aktív tag
válasz
bandi0000
#2380
üzenetére
A beolvasas es kiiras is rossz.
Az fscanf soraban az ecs[i] es mcs[i] egy karakter, nem pedig egy karakter tomb.
Printf soraban fe[i] es fm[i] int ertekek, de a format string szerint ket karaketerlancot var.viszont a charba azt adom meg hogy hány karakteres max szöveg lesz benne ugye?
Kell +1 karakter a vegere a lezaro \0 karakternek.
-
Dave-11
tag
válasz
bandi0000
#2375
üzenetére
Ha csak a fájl második sorától akarod beolvasni, akkor hozz létre valami ideiglenes változót/változókat, olvasd be egy sima fscanf()-fel az első sort, és aztán jöjjön a for cikluson belüli beolvasgatás az összes többi sorra.
Lehet az zavar be, hogy az első sor nem ugyan arra a mintára épül, mint a többi (pl.: kevesebb adat van benne), és ezért elcsúszik a beolvasás, és mondjuk int-ként olvasol be egy stringet vagy hasonló. -
Zsolt1
tag
válasz
bandi0000
#2365
üzenetére
Nem akarok belekontárkodni, de szerintem az a legcélszerűbb, ha a kétdimenziós tömb helyett egy struktúratömbbe olvasod be az adatokat, mivel a feladatsor további kérdéseiben enélkül szerintem elég nehéz lesz majd az adatokat kezelned.
A legtöbb ilyen érettségi feladatsornál egy struktúrát kell létrehozni az adatok kezeléséhez és abba kell beolvasni az adatokat. (Én legalábbis így szoktam megoldani.) -
dabadab
titán
válasz
bandi0000
#2362
üzenetére
Az ilyen iskolai feladatoknal mindig zavar az, hogy rengeteget vacakolnak viszonylag trivialis beolvasassal/kiolvassal (amit aztan soha nem fog hasznalni senki se ugy a valo vilagban) meg rengeteg az elore meghatarozott konstans meg maximum, meg meg biztos vannak dolgok, amik zavarnak, csak nem tudatosultak bennem.
-
dabadab
titán
válasz
bandi0000
#2360
üzenetére
"az adatok beolvasását hogy tudnám megcsinálni hogy később kezelhessem külön őket?"
Hat ugy, hogy kenyelmes legyen
Csinalhatod azt is, hogy egyszeruen ugy tarolod le az adatokat, ahogy vannak, ugy egy kicsit macerasabb oket kezelni, viszont hatekony, vagy csinalhatsz egy 48x500-as tombot is, ahova egyszeruen beirod, hogy melyik kilometernel ki ul az egyes szekeken.Egyebkent a feladatok szerintem borzasztoak.
-
mgoogyi
senior tag
válasz
bandi0000
#1966
üzenetére
Szia,
Nekem az első gondolatom egy map, ahol a kulcs a kártya azonosítója (1,2, stb.), az érték meg az, hogy hány darab van belőle.
A map-be szépen beupdateeled, hogy miből mennyi van, aztán néhány állapotjelző kell csak, pl.
numOfPairs
numOfDrills
numOfPokers
, amiket a map alapján feltöltesszKét párnál a numOfPairs 2 lesz, egy full-nál a numOfPairs és numOfDrills 1-1.
Ezeket viszont muszáj végigcsekkolni esetekre bontva. -
-
-
Jester01
veterán
válasz
bandi0000
#1959
üzenetére
Beolvasol egy teljes sort majd szétdarabolod. Egy egyszerű lehetséges megoldás (de nem túl hibatűrő):
#include <iostream>
#include <sstream>
#include <vector>
using namespace std;
int main(int, char**)
{
cout << "Enter numbers separated by spaces: ";
string line;
getline(cin, line);
istringstream s(line);
vector<int> numbers;
int x;
while(s >> x) numbers.push_back(x);
cout << "You entered " << numbers.size() << " numbers" << endl;
return 0;
} -
#1434
WonderCSabo
félisten
bandi0000
#1433
WonderCSabo
félisten
válasz
bandi0000
#1433
üzenetére
Elrontottad a fordító beállításait. Először is ne a Debug-ot, hanem a Release módot használd első menetben. Másrészt pedig állítsd vissza alapértelmezettre a fordítási beállításokat: Settings -> Compiler and debugger -> Reset to Defaults.
Egyébként ugye a fordítóval integrált verziót töltötted le?
)
(nem működik, y is not a function)
bár a második tűnik logikusabnak
Új hozzászólás Aktív témák
Hirdetés
● ha kódot szúrsz be, használd a PROGRAMKÓD formázási funkciót!
- BESZÁMÍTÁS! MSI B450M R5 3600 16GB DDR4 512GB SSD RTX 2060 Super 8GB THERMALTAKE Core V21 500W
- BESZÁMÍTÁS! Gigabyte B650M R7 7700 32GB DDR5 1TB SSD RTX 5070 12GB BE QUIET! Pure Base 500DX 650W
- Nintendo Switch OLED 20.1.1 okosított Dual-Boot Cfw + 256GB MicroSD + Atmosphere 1.9.1, 3 hó garival
- BESZÁMÍTÁS! Gigabyte A620M R5 7600 32GB DDR4 512GB SSD RTX 5060 Ti 16GB Zalman i3 NEO Enermax 650W
- BESZÁMÍTÁS! ASUS Z390 i5 9500 16GB DDR4 512GB SSD RTX 2060 Super 8GB Rampage SHIVA Thermaltake 500W
- Telefon felvásárlás!! iPhone 14/iPhone 14 Plus/iPhone 14 Pro/iPhone 14 Pro Max
- AKCIÓ! ASUS PRIME Z390-P i5 8600K 16GB DDR4 512GB SSD RX 6600 8GB GDDR6 DEEPCOOL Matrexx55 630W
- AKCIÓ! Gigabyte B650M R7 7700X 32GB DDR5 1TB SSD RTX 3080Ti 12GB Cooler Master H500P WHITE 750W
- A Panasonic Toughbook CF-54 i5-5300u i5-6300u TN, IPS touch Budapest, MPL Foxpost
- Országosan a legjobb BANKMENTES részletfizetési konstrukció! Lenovo ThinkPad L16 Gen 1 Prémium
Állásajánlatok
Cég: Liszt Ferenc Zeneművészeti Egyetem
Város: Budapest
Cég: CAMERA-PRO Hungary Kft
Város: Budapest