Új hozzászólás Aktív témák
-
Roxkex
senior tag
válasz
zsambek
#7032
üzenetére
Sikerült megoldani :3
Az volt a baja , hogy volt egy Style típusu static változóm amit használtam más helyen is nem csak a uniton keresztül .. Ezt kitöröltem és máshogy oldottam meg és most már jó .. Érdekes..Viszont , most vettem észre ,hogy az ODBC Excel driveres dolog nem igazán akar működni ... (eddig tökéletes volt!) - Azt mondja ,hogy nincs meg az adatforrás neve (pedig az elérést jól adom meg neki) és / vagy nincs alapértelmezett driver beállítva .. (amit nem értek !?) - Egy régebbi verziójában a programnak tökéletesen megy :\
-
Karma
félisten
válasz
zsambek
#5550
üzenetére
A Dictionaryk [] operátora mindkét irányba működik. Ha az értékadás jobb oldalán van, akkor kiveszi az adott kulcshoz tartozó értéket; ha meg a bal oldalán, akkor az adott kulcs alá berakja az eredményt. Ez így megválaszolja a kérdést?
A másodiknál sem teljesen értem a kérdést. Pont az a lényege, hogy kulcs-érték párokat tárol, és gyorsan meg lehet találni, hogy melyik kulcshoz milyen érték tartozik.
-
Karma
félisten
válasz
zsambek
#5540
üzenetére
Miért olyan különleges a 100-as szám?
Egyébként meg pont ilyet kellett már csinálnod, és akkor is azt mondtam, hogy a Dictionary a barátod. Most még egyszerűbb is a helyzet, mert elég egy Dictionary<string, int>, azaz a formázott eredményhez rendeled hozzá, hogy hányszor fordult elő.
Ennek felépítéséhez egy for ciklusra van szükséged, ami:
1) az eredményt a megfelelő formátumra alakítja, például 2 és 4 számokból "4-2" string;
2) megnézi, hogy ilyen string szerepel-e már a dictionary kulcsai között:
a) ha nem, akkor elhelyez egy 1-est ez a kulcs alá
b) ha igen, akkor kiveszi az értéket, és eggyel megnövelve rakja vissza
3) egy foreach ciklussal végigszaladsz a dictionary.Keys-en, és kiírod fájlba ahogy kell. -
Karma
félisten
válasz
zsambek
#5521
üzenetére
Az ötödik feladatban azt csinálhattad volna, hogy az érvényes címleteket csökkenő sorrendben elrakod egy konstans tömbbe (vagy listába, mindegy most), és egy while ciklussal végzed el az osztás-kivonásokat addig, amíg a maradványösszeg 0 nem lesz.
Az utolsó feladatban a tabulátorral elválasztáshoz annyit kell tenned, hogy a {0} után a sok szóköz helyett azt kell beírnod, hogy \t.
A kiírás meg azért nem működik, mert a feltételeid teljesen el vannak szúrva. Próbáld meg visszaolvasni, amit írtál az ifekbe - sok köze most nincs ahhoz, hogy "a hetes rekeszben a csokoládé száma nagyobb vagy egyenlő mint a vásárlás", illetve "a bedobott pénz nagyobb vagy egyenlő, mint a vásárlás összege". Emellett a rekesz aktuális darabszámát a ciklus során karban kéne tartanod.
Sajnos voltam olyan balga, hogy a tabletem töltőjét bennhagytam a munkahelyemen, így kóddal nem sokat tudok segíteni. De az biztos, hogy az előző bekezdést követve például "vasarlasok[i ].rekesz == 6"-ot akartál írni a hetes rekesz darabszáma helyett.
-
-
kingabo
őstag
válasz
zsambek
#5514
üzenetére
"...ha 10 lenne, akkor 5 / 10, akkor 5-t kapok? Ha pedig 10.0, akkor 0,5-t kapok..."
Erre azt tudom javasolni, hogy használd a vs debuggerét! Saját tapasztalatból tudom, hogy sokat tud segíteni nemcsak a hibák feltárásában, de akár a fenti kérdések megválaszolásában. Sőt, sokszor a miértekre is könnyen rá tudsz jönni.
Az Immediate Window-t is ajánlom, ahol futási időben tudsz utasításokat kiadni és megkapod az eredményt egyből. Sajnos Linq-el nem működik (vs2010-ig biztosan) -
Karma
félisten
válasz
zsambek
#5516
üzenetére
A kódodat most nem tudom megnézni, de a számításod biztosan nem kóser - ott az a "kivonom az 5600/3600-at" félremegy. Ha kivonogatsz, akkor 5600/3600*3600-at vonj ki, ez ugyanolyan, mint az én cseleztem a tízzel.
De használhatod helyette a % operátort is, tisztább lesz a vége.
SPOILER
int sec = 5600;
int hours = sec / 3600;
sec = sec % 3600;
int min = sec / 60;
sec = sec % 60;Előáll: hours, min, sec
-
Karma
félisten
válasz
zsambek
#5514
üzenetére
1) double-ről intre alakításnál alapvetően ugyanaz a cast és a Convert. Stringnél például már más a helyzet, a sima cast érvénytelen lenne.
2)-3) Összekevertél két dolgot, de akkor inkább végigmegyek a műveleteken.A maradékos osztás (jele: / ), egész számok között működik. Tehát ha egy osztás mindkét oldalán egész számok vannak, az eredmény is egy egész szám lesz.
Például:
25 / 5 = 5, 20 / 5 = 4, viszont 19 / 3 = 6 (elveszett az 1 maradék!), és így logikusan 5 / 10 = 0.Ha az osztás bármelyik fele valós szám, akkor valós osztásra vált a nyelv.
25 / 5.0 = 5.0, 20.0 / 5 = 4.0, 19.0 / 3 = 6.333333, 5 / 10.0 = 0.5A maradékképzés operátor (%) egészek között működik, és a második osztályos osztásból a maradékot adja vissza.
25 % 5 = 0, 20 % 5 = 0, 19 % 3 = 1, 5 % 10 = 5Ennek az egésznek semmi köze a Math.Ceilinghez.
Az egy felső egészrész függvény, és pont úgy viselkedik, mint ahogy eredetileg leírtam. Sajnos a fórumon nem tudok ilyen félszögletes zárójeleket írni.4) Az egész számokat jól vezetted végig, ez a lényeg.
50.5-öt akkor kapsz, ha az osztó vagy az osztandó valós. Ezt elérheted a 10.0-val is, meg akkor is, ha egy double változóba teszed az osztandót előtte. És akkor nyilván nem működik a kitalált gondolatmenetem, hiszen amint visszaszorzód tízzel, megint 505 az érték
Az integer természetesen nem tud tizedesjegyeket kezelni, hiszen definíció szerint egész szám
-
Karma
félisten
válasz
zsambek
#5511
üzenetére
Üdv újra. Már készültem rákérdezni, hogy mi újság a gyakorlással.
1) Túlkomplikáltad ezt az árszámítást matek és C# oldalon is. C# oldalon azért, mert a Convert.ToDouble hívás felesleges, matek oldalon meg azért, mert ha jó képletet választasz a kerekítés előtti árhoz, nem kell ifelned meg kézzel +71-et hozzáadni.
Van a Math.Ceiling függvény, ami visszaadja a double számhoz legközelebbi, annál nem kisebb egészt. Azaz például 4 -> 4, 4.1 -> 5, 4.9 -> 5, stb.
Ezt kihasználva az árszámítás (57-68. sorod) ennyire alakul át:
jegyek[j].fizetnivalo = (int)(Math.Ceiling((jegyek[j].le - jegyek[j].fel) / 10.0) * 71);A 10.0 nagyon fontos, mert enélkül maradékos osztást csinál a fordító!
A magyar ötforintos kerekítésre sajnos nem alkalmas a Math.Round. De még egy teljesen naív switches megoldás is teljesen kielégítő:
int diff = 0;
switch (fizetendo % 10) {
case 0:
case 1:
case 2:
diff = 0;
break;
case 3:
case 4:
case 5:
case 6:
case 7:
diff = 5;
break;
case 8:
case 9:
diff = 10;
break;
}
fizetendo = fizetendo / 10 * 10 + diff;A /10*10 maradékos osztással levágja az utolsó számjegyet, a diff meg az a szám, amit a kerekítés miatt hozzá kellett csapni.
2) Ez a megközelítés nem biztos, hogy jó eredményre vezet, ha az első megállónál senki se szállt fel, vagy mindenki leszállt már az utolsó előtt. Biztonságosabb, ha a vizsgáló ciklusodat úgy futtatod, hogy a másodiktól az utolsó előtti megállóig fusson (így a szélsőkkel nem foglalkozol).
3) Úgy látom két hiba biztosan van a hetedik feladatodban: egyrészt 48 ülés helyett 49-cel operálsz (a félreindexelés halálfejes hiba); másrészt a 183. sorban lévő belső ciklus teljesen felesleges. Nem is használod a ciklusváltozóját.
De egyébként az elvben nem látok hibát.
A futás közbeni állapotot úgy tudod követni, hogy egy breakpointot raksz a programodba a forráskód bal szélén lévő sávra kattintva. Ekkor ott egy piros kör jelenik meg, és a futás leszünetelődik amikor odaér.
Ekkor a Locals fülön, alapból bal lenn látod a változóid aktuális értékét. -
Karma
félisten
válasz
zsambek
#5509
üzenetére
Ne add fel! Ott vagy a megoldás kapujában, csak kimerített, hogy túl sok újdonság szakadt rád az elmúlt pár órában. És légy még egy kicsit türelemmel, mert imperatívan ez nem megy egy lépésben.
A legfontosabb alapszabály, amit most be kell tartanod: ne nyúlj a dictionaryhez módosítási szándékkal. A második: ne nyúlj a dictionaryhez módosítási szándékkal. Kőtáblába vésted!
Azt az előző túra során felépítetted, tedd el biztos helyre, és használd úgy, mint egy papíralapú szótárat szokás: keresgélj benne a címszavak alapján.
Van egy rendezett kulcslistád. Tudod róla, hogy hossz szerint növekvő sorrendben vannak a kulcsok benne. Akkor hol van a leghosszabb kulcs?
Természetesen a lista végén
Szedd elő az utolsó elemet és jegyezd fel a hosszát.Utána foreach ciklussal menj végig a kulcsokon, és ha az aktuális kulcs ugyanolyan hosszú, mint az előbb megjegyzett szám, akkor vedd elő a szótárból az ehhez a kulcshoz tartozó szavak listáját, és írd ki a szavakat.
Próbáld meg leírni C#-ban ezeket a mondatokat.
--- ez itt a vágás helye ---
Ha elakadnál, megírom én is:
int maxLength = orderedKeys[orderedKeys.Count - 1];
foreach (string key in orderedKeys)
{
if (key.Length == maxLength)
{
List<string> words = dict[key];
foreach (string word in words)
{
Console.WriteLine(word);
}
}
}A hetedik feladat ezután pofonegyszerű, hiszen ugyanez a foreach (in orderedKeys) ciklus kell, és nem kell bele if, csak egy string.Join(). Ja meg fájlba kell írni képernyő helyett.
Apropó, ha esetleg valami nem fordulna, akkor bocs. Ezt mind fejből írtam, mint az előzőeket is. -
Karma
félisten
válasz
zsambek
#5507
üzenetére
Az első blokk teljesen jó. Azért kell egyébként a ContainsKey, mert a kulcsok között akarsz keresni. A Dictionarynek van Contains és ContainsValue metódusa is, az előbbi konkrét kulcs-érték párost próbál nézni, az utóbbi pedig az értékek között.
Tömböt már tudsz rendezni az egyparaméteres Array.Sorttal, így igazából mindent tudsz
Listákat rendezni nagyon hasonlóan lehet, csak nem kell hozzá külső segítség: van nekik saját Sort metódusuk.A Sort metódusoknak van olyan formája, ahol te mondod meg, hogy hogyan kell rendezni. Ezt megmutatom példával.
Illetve hiányzik az a lépés, hogy hogyan csinálsz szabadon módosítható listát a Keysből. Ez is elég beszédes.
Jöjjön a kód:List<string> orderedKeys = new List<string>(dict.Keys); // új lista létrehozása a Keys alapján
// És itt jön a lényeg: a rendező függvény.
// Kap két elemet, és egy számot ad vissza, ami a két elem egymáshoz való viszonyát mutatja.
orderedKeys.Sort((szo1, szo2) => {
if (szo1.Length < szo2.Length) return -1; // Negatív szám: az első elem előrébb kerül
if (szo2.Length < szo2.Length) return 1; // Pozitív szám: a második elem kerül előrébb
return szo1.CompareTo(szo2); // ugyanolyan hosszúak? döntsön az ABC-sorrend.
}); -
Karma
félisten
válasz
zsambek
#5503
üzenetére
No én is utolértem magam közben, válaszolok erre is...
Egyetértek, a feladatsor határozottan nehezebb mint a korábbi. Bár az oktatás is követné ezt színvonalban. Érződik, hogy próbálják a Pascalt leépíteni (ez önmagában nem baj), csak ennek eszközéül azt választották, hogy az ezt választó diákokat jól megszivatják...
Említettem kicsit korábban, hogy a hetedik és a hatodik feladat ugyanaz, és jobban jársz, ha ebben a sorrendben próbálod őket megoldani. A hetedik tényleg "baromi" nehéz, sokkal nagyobb ráfordítást igényel, mint a korábbi évek zárófeladatai.
Mondjuk annyi különbség van, hogy itt nem kell neked azon gondolkodnod, hogy "mit is kéne kihoznom a meglévő adatokból hogy válaszolhassak a kérdésre?", mert kerek perec leírták, hogy mi a cél: olyan szerkezetet kell felépítened, mint amit a "rendezett" oszlopban látsz. A kérdés csak a "hogyan?".
Ez most az a szituáció, hogy egy vagy két darab sima, egydimenziós lista nem elég. Ez egy "fésűs lista" is lehetne (ahogy a közoktatás csúfolja), de szerintem célravezetőbb, ha kapásból Dictionaryt építesz belőle.
Méghozzá egy Dictionary<string, List<string>>-et, amivel a kulcs az ABC-rendezett szó, és a hozzá tartozó listában vannak a konkrét szavak a szótárból.
A stratégia a következő:
0) Csinálsz egy ilyen Dictionary objektumot (továbbiakban: dict)
1) Ciklusban, egyszer végigmész a szótáron. Minden elemére:
1/a) veszed a szó ABC-rendezett alakját (továbbiakban: key)
1/b) a dict.ContainsKey(key) metódussal megnézed, hogy az adott kulccsal találkoztál-e már
- ha igen, akkor dict[key]-jel megszerzed a hozzá tartozó listát, és annak az Add metódusával eldugod a szót
- ha viszont nem, akkor létrehozol egy új List<string>-et, belerakod a szót, és a listát elteszed a dict-ben a key-hez. Pl.: dict[key] = list;
2) Ha a végére értél, nincs más dolgod, mint rendezni a dict.Keys-t a kulcs hossza alapján, és e szerint kiírni.A hatodik feladat pedig annyi, hogy veszed a maximális hosszú kulcsokat, és sorban kiírod a képernyőre a hozzá tartozó szavakat. Ha a dict megvan, ez pofonegyszerű
Érzem, hogy a 2) lépés elég nagy logikai ugrás, de azért remélem a gondolatmenet átjön. Ha nem, akkor szólj feltétlen.
És egyébként LINQ-kel az egész egy sor.
-
Karma
félisten
válasz
zsambek
#5501
üzenetére
Sajnos ez csak részpontszámos megoldás, ugyanis ha a leghosszabb szavak a listában:
kecskebeka
bekakecske
kabekecske...
biatorbagy
agybaboritAkkor csak a kecskebéka anagrammáit írod ki, a feladat pedig azt akarná, hogy mind az öt szó legyen ott, egymásután a kecskések, és utána párban a biatorbágyosok.
-
Alexios
veterán
válasz
zsambek
#5503
üzenetére
Bár annyira nem néztem most át a kódod, és nem tudom mennyire ismered a debug-olási lehetőségeket, de azért jóljöhet, ha breakpointokat helyezel el ott ahol nem azt csinálja a programod amit szeretnél, nagyobb eséllyel fogsz rájönni arra, hogy mi a baj magadtól, hiszen látod a változók aktuális értékeit pl.
Bár hirtelen elnézve szerintem az a kód ebben a formában jó.
Viszont ilyet:
Convert.ToString(szo1)
tökfölösleges csinálni, hiszen a szo1 eleve egy string, a foreachnél látszik a deklaráció -
Karma
félisten
válasz
zsambek
#5499
üzenetére
A var annyit csinál, hogy nem kell kiírnod a pontos típust, ha az egyértelmű a fordítónak; neked meg kevesebbet kell gépelni.
A new char[szo.Length] teljes mértékben felesleges, hiszen a következő sorban a ToCharArray létrehozza magának a tömböt. Más szóval célszerű elhagyni (de az is lehet, hogy a fordító magától kiveszi, hiszen értelmetlen.)
Ergo a következő sorok egyenértékűek:
1)
char[] temp;
temp = szo.ToCharArray();2)
char[] temp = szo.ToCharArray();3)
var temp = szo.ToCharArray();Viszont a var kulcsszót nem használhatnád az első esetben. Nem írhatsz olyat, hogy var temp; mert ekkor nem tudja a fordító hogy mi lesz ott.
A stringek nem módosíthatóak, nem tudod őket helyben rendezni úgy, mint az Array.Sort a tömböket. Ezért is csináltunk belőle tömböt, rendeztük a tömböt, majd hoztunk létre egy új stringet a rendezett tartalommal.
-
Karma
félisten
válasz
zsambek
#5497
üzenetére
Az "otos"-t elfelejtetted rendezni
Egyébként spórolhatsz az ismételgetéssel, ha csinálsz egy metódust a rendezett alak kigenerálásához (lásd harmadik feladat). Itt egy példa, ahogy összevontam, lényegesen egyszerűbb, és még SequenceEquals se kell hozzá. De legalább már azt is láttad és megértetted
-
Karma
félisten
válasz
zsambek
#5495
üzenetére
A string és a karaktertömb két teljesen külön dolog. A karaktertömb csak egy buta tároló, ami a saját hosszán és elemein kívül semmit se kezel, míg a string tud rengeteg spéci műveletet, ami szövegekkel kapcsolatos. Az egyik közülük két szöveg összehasonlítása karakterenként (ez hívódik meg a == operátoron keresztül), de a Replace, Trim, PadLeft metódusai mind hasznosak például.
Amivel megtéveszthettelek (végülis én ajánlgattam korábban) az az, hogy a [ ] operátorral eléred a karaktereket egyesével. De ez is csak egy a string hasznos funkciói közül, attól még egy másik állatfaj.
Széljegyzet: string[] ketszo = new string[2]; A kiemelt rész felesleges, mert az értéket az első adandó alkalommal eldobod.
Széljegyzet 2: szerintem == 2 helyett >= 2-t akartál írni.
-
Karma
félisten
válasz
zsambek
#5493
üzenetére
Az a gond itt, hogy a tömböket nem lehet se == operátorral, se Equals hívással összehasonlítani, mert az nem tartalom alapján veti őket össze, hanem csak annyit néz, hanem kvázi hogy a memóriacímük egyezik-e. Mivel két külön tömbről van szó, valószínűleg sose fog egyezni.
Ehelyett: otos == temp2 írd ezt: otos.SequenceEqual(temp2). (Kell hozzá using System.Linq; a programod elején).
(#5492) Dj Sügi: Windows Formsban nem vagyok annyira járatos, de az biztos, hogy az ilyen kérdések feltétele helyett előszedném a TextBox doksiját, és megnézném, mit tud. Meg a Google-t, például google://textbox windows forms disable selection, a második találat elég bíztató.
-
Karma
félisten
válasz
zsambek
#5489
üzenetére
A megoldásodat nem néztem még, csak a feladatot, de azért spoilereznék egy kicsit. A harmadik feladat szándékosan az, ami: ezzel akarnak rávezetni arra, hogy két szó akkor (és csak akkor) anagrammája egymásnak, ha az ABC sorrendbe rendezett alakjai megegyeznek egymással!
Így mindjárt sokkal egyszerűbb lesz az ötös (végigszaladsz a szavakon, és minden olyat kiírsz, amiknek megegyezik az átrendezett alakja), a hetedik és a hatodik feladat meg ugyanaz pepitában. Ajánlom is ebben a sorrendben megoldani őket.
LINQ-kel megint egy-egy sor, mint általában, de egyébként se bonyolult. Egy jó rendezési feltétel kell hozzá: az elsődleges szempont a szó hossza, egyenlő hossz esetén pedig az abc-rendezett alakokat kell egymáshoz hasonlítani.
-
Karma
félisten
válasz
zsambek
#5417
üzenetére
A negyedik feladat idegesítőbb kicsit, mert ilyen szerencsétlenül sikerült ábrázolniuk a napokat
. Figyelmen kívül hagyva a szökőnapokat (végülis ők is írják a példában, hogy ápr. 30-at 31+28+31+30-cal számolták ki) azért nem lehetetlen kiszámolni a napokat.Egy lehetséges megoldás:
- Kell egy 12 elemű int tömb (itt most én is azt használnék
), amibe az egyes hónapokra bontva gyűjtöd a foglalt napokat.
- Kell egy 12 elemű konstans tömb, amiben benne vannak a hónapok hosszai (31, 28, 31, stb...).
- Ciklusban végigmész a foglalásokon. A konstans tömbből tudod, hogy egy adott hónap hol kezdődik és hol ér véget (az i-edik hónap az előző hónaphosszok összegénél kezdődik), és ezt kivonod a foglalás kezdő és végpontjából. Megoldani teljesen nem akarom, úgyhogy a pontos számítást rád hagynám.
- Kiírod az eredménytömböt. -
Karma
félisten
válasz
zsambek
#5417
üzenetére
Az ötödik feladattal annyira nem vagy messze. Ha tudod, hogy hány foglalás érinti az adott szakaszt (ezt számolos ki a ciklusoddal), és hogy hány szoba van (lásd feladat: 27), akkor csak egy kivonásra vagy a megoldástól.
Mondjuk a feltétel nem helyes, mert csak azt észleled, ha a vizsgált foglalás eleje és vége is belül esik a kérdéses időszakon. Azt is számolni kell, ha valaki az időszakon belül érkezik, de csak később megy el; meg azt is, ha korábban jött és közben megy el.
Ha kicsit belegondolsz, intervallumok metszetéről van szó. Ha van metszet, akkor ++.
-
vlevi
nagyúr
válasz
zsambek
#5391
üzenetére
amit én írok 4-5-6 sorban, azt te egy sorban elintézed!
Nagyon sok esetben errol is szol a c# nyelv. Mivel uj progamnyelv, a megalkotasakor figyelembe tudtak venni az elmult 50 valahany ev programozoi tapasztatait. Ezzel nem fenyezni akarom a c#-ot, de ami treny, az teny. Pl Amig nem ismertem, en sem ertettem a leirasokmalapjan, mire jo a linq, de azota megertettem a lenyeget, es ennek tukreben mar nagyon hasznos dolognak tartom. Tenyleg rengetegszer elfordul, hogy adathalmazokbol a korabbi nyelvekben csak egymasbaagyazott forciklusok tomkelegevel lehetett kibogaraszni az informaciot, itt viszont nehany sorral megvan. Raadasul a nyelv gondoskodik a legoptimalisabb feldolgozasrol, amirol a programozo szinte mindig el fog feledkezni.
Nem mellesleg en is csak lesem karma hozzaszolasit, mert a c#-hoz en is csak nagyon keveset konyitok. Erdeklodo amator szintjen vagyok. Nezegetem, neha egyket aprosagot kiprobalok benne, de mivel a melohelyemen nem hasznaljuk, igy nehez benne melyebben elmelyulni. Az alapfogalmak egyreszerol hallottam, de eleg keveset tudok ertelmes egessze osszerakni.
-
vimes
senior tag
válasz
zsambek
#5363
üzenetére
Nekem kiírta a *.txt fájlba:
1. nap 1. út: 700 Ft
1. nap 2. út: 700 Ft
1. nap 3. út: 500 Ft
1. nap 4. út: 900 Ft
1. nap 5. út: 700 Ft
1. nap 6. út: 500 Ft
1. nap 7. út: 1400 Ft
1. nap 8. út: 900 Ft
1. nap 9. út: 900 Ft
1. nap 10. út: 700 Ft
1. nap 11. út: 900 Ft
3. nap 1. út: 900 Ft
3. nap 2. út: 900 Ft
3. nap 3. út: 900 Ft
3. nap 4. út: 500 Ft
3. nap 5. út: 700 Ft
3. nap 6. út: 900 Ft
3. nap 7. út: 700 Ft
3. nap 8. út: 700 Ft
3. nap 9. út: 900 Ft
3. nap 10. út: 500 Ft
3. nap 11. út: 700 Ft
3. nap 12. út: 500 Ft
3. nap 13. út: 700 Ft
3. nap 14. út: 700 Ft
3. nap 15. út: 500 Ft
4. nap 1. út: 1400 Ft
4. nap 2. út: 500 Ft
4. nap 3. út: 700 Ft
4. nap 4. út: 2000 Ft
4. nap 5. út: 900 Ft
4. nap 6. út: 1400 Ft
5. nap 1. út: 500 Ft
5. nap 2. út: 700 Ft
5. nap 3. út: 500 Ft
5. nap 4. út: 900 Ft
5. nap 5. út: 500 Ft
5. nap 6. út: 700 Ft
5. nap 7. út: 500 Ft
5. nap 8. út: 900 Ft
5. nap 9. út: 500 Ft
5. nap 10. út: 500 Ft
5. nap 11. út: 700 Ft
5. nap 12. út: 500 Ft
5. nap 13. út: 500 Ft
5. nap 14. út: 700
egészen eddig. Csak azt nem értem, hogy miért csak eddig írja ki. Nem elgépelés, az utolsó végéről lemaradt az "Ft", nem tudom miért nem írta ki, ha a többi sornál meg igen. -
Karma
félisten
válasz
zsambek
#5340
üzenetére
Nem. Ehhez a feladathoz nincs szükség switchre, nem tudom trisztan94 mire gondolhatott vele.
Sokkal inkább van szükség egy klasszikus ellentmondás keresésre.
Például így:
#region MEGY 6. Feladat
string[] beolvrendszam = new string[7];
Console.WriteLine("6. Feladat: Kérem, vigye be a rendszámot:");
string beolvsima = Console.ReadLine();
foreach (var ell in ellenorzesek)
{
bool egyezik = true;
for (int i = 0; i < 7 && egyezik; i++)
{
if (beolvsima[i] != ell.rendszam[i] && beolvsima[i] != '?')
{
egyezik = false;
}
}
if (egyezik)
{
Console.WriteLine("6. Feladat: {0}", ell.rendszam);
}
}
#endregionMiközben írtad a sok egymásba ágyazott if-et, érezned kellett volna ahogy szárad le a kezed. Ha nem, legközelebb képzeld azt.
Egyébként a j változódat igazán átnevezhetnéd valami értelmesebbre. Direkt ki is hagytam a képből.
Másrészt vedd észre, hogy aposztrófok közé tettem a kérdőjelet: így nem kell substringgel és stringtömbbel szórakozni, a string ugyanis felfogható karakterek tömbjének is.
-
Karma
félisten
válasz
zsambek
#5337
üzenetére
Jézus ereje, miért csináltál hételemű string tömböt a rendszámból? Jó az egy darab stringnek is, illetve ez a sok rendszam.Substring(X, 1) is teljesen felesleges, mert ugyanezt tisztábban megkapod ha azt írod, hogy rendszam[X].
A switch ezen a helyen semmire se jó, de ezt az if-piramist azért ki lehet lapítani egy for ciklusba, ami az i-edik karaktereket összehasonlítja, és addig megy, amíg nem talál eltérést. Ha végigért, akkor meg kiír.
Van egy félsoros megoldás is regexekkel, de azt nem mondom el, mert egy erősen túlmutató területre vezet.
-
#5338
trisztan94
őstag
zsambek
#5336
trisztan94
őstag
válasz
zsambek
#5336
üzenetére
Switch?
Erre pedig:
if (beolvrendszam[0] == ellenorzesek[i].rendszam.Substring(0, 1) || beolvrendszam[0] == "?")
{
if (beolvrendszam[1] == ellenorzesek[i].rendszam.Substring(1, 1) || beolvrendszam[1] == "?")
{
if (beolvrendszam[2] == ellenorzesek[i].rendszam.Substring(2, 1) || beolvrendszam[2] == "?")
{
if (beolvrendszam[3] == ellenorzesek[i].rendszam.Substring(3, 1) || beolvrendszam[3] == "?")
{
if (beolvrendszam[4] == ellenorzesek[i].rendszam.Substring(4, 1) || beolvrendszam[4] == "?")
{
if (beolvrendszam[5] == ellenorzesek[i].rendszam.Substring(5, 1) || beolvrendszam[5] == "?")
{
if (beolvrendszam[6] == ellenorzesek[i].rendszam.Substring(6, 1) || beolvrendszam[6] == "?")
{
Console.WriteLine("6. Feladat: {0}", ellenorzesek[i].rendszam);
}
}
}
}
}
}
}Lehet lehagytam pár csukó kapcsos zárójelet..
Nem lenne elég egyetlen egy ilyen?
if (beolvrendszam[i] == ellenorzesek[i].rendszam.Substring(i, 1) || beolvrendszam[i] == "?")
-
Karma
félisten
válasz
zsambek
#4641
üzenetére
Igen, a " " a string, a ' ' meg egyetlen karakter konstans jele.
Csinálhattad volna úgy is, hogy char változóba rakod az indulást. Viszont akkor meg arra kell figyelned, hogy a split metódus stringeket ad vissza, neked meg csak az első karaktere kell.
Int esetén nem kell (nem is szabad!) semmilyen idézőjel a szám köré.
-
Karma
félisten
válasz
zsambek
#4638
üzenetére
Ömm, ez a részlet annyit csinál, hogy beolvas egy számot konzolról, és kiírja az annyiadik elemet. Mindezt a beolvasás sorrendjében, nullától számolva. Keresés nem nagyon van benne.
Mondjuk ha a honnan még mindig egy string[], azaz úgy van ahogy tegnap másoltad, akkor a kód le se fordul, mert stringet akarsz charhoz hasonlítani. Aposztróf ( ' ) helyett használj idézőjelet ( " ) a string konstansokhoz.
-
Karma
félisten
válasz
zsambek
#4626
üzenetére
Na, csak írtam valamit így feladat nélkül.
A hibakezelést én se erőltettem túlEz pl. egy olyan változat, amit érettségin is simán elhisznek az embernek. A korábbi mondandóm lényege a TimesheetRow osztály, amit fenn definiáltam, benne propertykkel az egyes mezőkhöz.
A Main metódust nagyon nem akarom túlragozni, mert szerintem a C# elég jól olvasható akkor is, ha angol mondatokként tekintesz rá. Tömören csinálok egy üres listát (amibe TimesheetRow elemeket lehet rakni), majd feltöltöm elemekkel ahogy kipotyognak a sorok.
A humor kedvéért ebből a listából kiválasztom az öt leghosszabb távolsággal rendelkezőt (csökkenő sorrendben), majd kiíratom őket kézzel.
Mindenképpen próbáld meg a logikát mögötte megérteni, ne a sorokat bemagolni, mert csak úgy van értelme az egész történetnek. Kérdezz bátran.
Meg megírtam korutinnal is, mert jobban szeretem.
-
Karma
félisten
válasz
zsambek
#4621
üzenetére
Az előbb említett szerzőt én is javaslom
Egyébként a kódod legnagyobb problémája az, hogy nem C#, csak szintaktikailag.
Logikailag inkább C-re vagy Pascalra emlékeztet, gyanítom ugyanaz az eset, mint amikor az orosztanárokból faragtak angoltanárokat nagyon gyorsan...Pár apróság, ami már most is megkönnyítheti az életedet:
1) A különálló tömbök helyett definiálj egy új osztályt, ami összefogja az adattagokat. Így egy sor egy objektum lesz, amit könnyen tudsz egy Listben tárolni és kezelni.
2) Fájlt, vagy bármilyen más lezárható erőforrást nem szabad így a levegőben lógva kezelni. Ha például a fájlban az egyik int hibás, a keletkező Exceptiontől úgy pukkan ki a kódod, hogy a fájl meg nyitva marad. Ez jobb helyeken halálfejes hiba - azaz azonnal bukod a vizsgát és próbálhatod újra legközelebb.
Ehelyett használd a using szerkezetet, ami garantálja, hogy a blokk végén a fájl (vagy bármilyen más, IDisposable erőforrás) lezáródik, ha hiba van, ha rendben futott minden. Itt láthatsz is egy példát, hogy hogy kellett volna kinéznie. Szokj rá.
3) Az int.Parse(string val) robban, ha nem számot talál. Ehelyett szerencsésebb az int.TryParse(string val, out int result) metódust használni, ami simán egy hamis bool értéket ad vissza a kivétel helyett.
Listákat rendezni nagyon hasonlóan lehet, csak nem kell hozzá külső segítség: van nekik saját Sort metódusuk.
. Figyelmen kívül hagyva a szökőnapokat (végülis ők is írják a példában, hogy ápr. 30-at 31+28+31+30-cal számolták ki) azért nem lehetetlen kiszámolni a napokat.
Ú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!
- OTP Bank topic
- Tőzsde és gazdaság
- iPhone topik
- PlayStation 5
- Motorolaj, hajtóműolaj, hűtőfolyadék, adalékok és szűrők topikja
- Steam topic
- Rábólintott az EU, eltakarítja az illegális termékeket az AliExpress
- Háztartási gépek
- Samsung Galaxy A54 - türelemjáték
- Lexus, Toyota topik
- További aktív témák...
- Apple iPhone 12 Pro 128GB, Kártyafüggetlen, 1 Év Garanciával
- Cooler Master CK550 RGB mechanikus (barna switch/magyar kiosztás)
- Újszerű Meta Quest 3 (128gb), 1 év garanciával +kiegészítőkkel
- Asus Prime B560M-K + i5 11500 + be quiet! + 32 Gb Patriot Viper 3.200 Mhz Beszámitok!
- Eladó Konfig Ryzen 7 7700 32GB DDR5 1TB SSD RX6800XT 16GB!
- Fém, összecsukható és kihúzható fotó állvány eladó
- ÁRGARANCIA!Épített KomPhone i5 14600KF 32/64GB DDR5 RTX 4070Ti Super GAMER PC termékbeszámítással
- LG 65C4 - 65" OLED evo - 4K 144Hz - 0.1ms - NVIDIA G-Sync - FreeSync - HDMI 2.1 - 1000 Nits
- 1-12 részletre.Új noblechairs EPIC műbőr FEKETE - FEKETE. 2 év garancia!
- AKCIÓ! Gigabyte H610M i5 13600K 16GB DDR4 512GB SSD RTX 3060Ti 8GB Zalman S2 TG Seasonic 650W
Állásajánlatok
Cég: CAMERA-PRO Hungary Kft
Város: Budapest
Cég: PC Trade Systems Kft.
Város: Szeged