Tudna segíteni valaki ennek a C++ feladat végének a megoldásában?

Szia!

A feladatod roppant egyszerű. Mielőtt bármit csinálnál, a feladatot vázlatszerűen, értelmesen és röviden, tényszerűen fel kell írnod, és meg kell értened. Ha ezt nem teszed meg, nem érted meg és nem tudod azt, hogy milyen problémát kell megoldanod, akkor egyáltalán hogy írhatnál kódot?

Tudd elmodnani a saját szavaiddal, hogy mit akarsz csinálni. Ha el tudod mondani egymás után háromszor anélkül, hogy saját magadat összezavarnád, akkor érted a problémát, és van egy megoldásod rá. Legyenek modelljeid, megfelelő methodokkal, valósuljon meg az OOP minden szabálya, írj egy szép kódot.

Ha valamit nem értesz, az azért lehet, mert kapkodsz. Lépjél vissza hármat, tegyél le mindent, olvass, értelmezz, rakd össze a fejedben újra az egészet, és észre fogod venni, hogy a kódod felét ki fogod dobni. Ennyit kell tenned.

Változóval nem kellene megadni a tömb hosszát C-ben vagy C++-ban.

A pontok összesítésén módosíts kicsit. A belső ciklust feltételéhez hozzá lehetne adni azt is, hogy csak addig menjen, amíg a "kiesett" értéke hamis.

Egyrészt "if(kutyak[i][j] > minpontszam[j] )" ez így nem jó, akkor is hozzá kell adni szerintem, ha a minimum pontot elérte, tehát nem ">", hanem ">=". Másrészt erre a feltételre semmi szükség, akkor is hozzáadhatod a pontokhoz, ha nem érte el a minimumot, mivel a végén úgyis csak akkor lesz eltárolva, ha a "kiesett" false.

Ha az összesítés végén a "kiesett == false", akkor el kell tárolni.

Az is egy megoldás, ahogy csináltad, hogy az azonosítójával megegyező indexre írod be a pontot, viszont így előfordulhat a végén az, hogy a tömbben pl. lesz 1 pontszám, utána 1000 üres hely, aztán még 1 pontszám, majd 1000 üres hely, stb. Szóval ez így nem túl jó.

Ehelyett lehetne azt csinálni, hogy 2 tömböt használsz az eredmények tárolására. Az egyikbe írod az azonosítót, a másikba a pontszámot. Kell egy "i" változó, ami kezdetben 0, és azt adja meg, hogy eddig hányan nem estek ki. Ha az összesítés végén "kiesett == false", akkor az egyik tömb i-edik helyére beírod az azonosítót, a másik tömb i-edik helyére a pontszámot, majd i-t megnöveled eggyel.

Ezzel elérted, hogy egy egybefüggő területen egymás után legyenek a pontok.

Ezután csökkenő sorrendbe kell rendezni az azonosítókat a pontszámok alapján. Az előbb leírt tárolás alapján az egyik tömbben az azonosítók, a másikban a pontok vannak. Mindegyik azonosító esetén megszámolod, hogy hány kisebb pontszámú van nála, és ez alapján meg lehet határozni a helyezést, majd beírni az azonosítót a megfelelő helyre az eredmény tömbbe.

A végén meg csak ki kell írni az eredmény tömb elemeit.

(A rendezéshez még egy kis segítség:

Egyesével végig kell menni az azonosítók tömbön. Tegyük fel, hogy az azonositok[j]-nél tartasz. Ekkor azt kell megszámolni, hogy a pontok tömbben hány darab pontok[j]-nél kisebb pontszámú van. Viszont ez nem ilyen egyszerű, ha azonos pontszámok is lehetnek, és itt szerintem előfordulhat ilyen (egyszerű végiggondolni, hogy mi lenne a probléma ilyenkor).

Szóval ahelyett, hogy azt számolnád, hogy a pontok[j]-nél hány kisebb van, azt kellene nézni, hogy hány kisebb vagy egyenlő van, és ezt is csak pontok[j+1]-től kezdve. (ezt is végig lehet gondolni, vagy egy konkrét példát megnézni))

Ez egy megoldás a feladatra. Nyilván lehetne ezt hatékonyabban csinálni, de ha az a cél, hogy tömbökkel oldd meg, programozási tételeket használva, akkor szerintem ez egy jó megoldás lehet.

Egyébként meg célszerű lenne nem mindent a main-be írni. Lehet függvényeket csinálni, ami paraméterként átvehetik a tömböket (mint első elemre mutató pointer), és átláthatóbb lesz az egész.

3 hiába próbálsz tanácsot adni egy meglévő, rosszul felépített kódra, ha idáig el se jutott volna, ha normálisan végiggondolja a feladatot miután elkezdi lekódolni.

A feladat ennél soha nem lesz bonyolultabb, semmilyen formában, maximum absztraktabb objektumokkal fogsz dolgozni a sokadik öröklési szinteken. Egymásba ágyazott forciklusok (még ha nem is látod), elágazások. Minden más csak maszlag, de a lényeg mindig ugyan az. Ha végig van gondolva, akkor nem lehet elrontani. Ezért kell debuggolni, és LÉPÉSENKÉNT végigmenni a kódon. Soronként.