Új hozzászólás Aktív témák
-
axioma
veterán
Ha jol ertem, akkor a fejedben nem az a tabulalas van meg, amit a programnak adtal. Vagyis a 45. sorban levo "else" kene legyen a tenyleges feldolgozo a'g, csak nem raktad ki a zarojeleket, es az egyedul az ott kezdodo if-re vonatkozik. Ami veget er a 48.-ban, tehat a 49.-ben levo me'g ures sor eseten is vegrehajtando.
Rakd ki az else utan a blokk-kezdest, ami vegzodik a while vege elott, a 60. sornal.
Valoszinuleg az "osszenott" else if okozta, hogy nem latod pontosan a strukturat. Ilyen egybeirt else if -et en csak akkor szoktam csinalni, ha tobb darab, 1 sorba befero rovid vizsgalat es 1 soros rovid blokk tartozik hozza, szinte egy switch tipusu egymas melletti esetfelsorolas lenne, csak mas tipusu a feltetelem. Mondjuk ilyenkor annak megfeleloen is tabulalom, tehat minden else if blokkja az egybeirastol fuggetlenul uj szintre kerul be. Minden mas esetben hasznos, ha minden nagyobb else-hez kirakod a sajat kezdo-zaro parjat. Szigorubb coding standard szerintem alapbol meg is koveteli.[ Szerkesztve ]
-
axioma
veterán
válasz superfinest #4290 üzenetére
Hiaba alap, a rae'pules pont azert van, mert pluszt nyujtanak a tovabbi nyelvek. Csak egy tokegyszeru pelda: dinamikus (futas kozben valtozo hosszu) tomb, lista, vagy barmi megvalositasa. Ha ansi C-ben megirod nullarol, megtanulsz egy csomo alacsonyabb szintu kezelest es kezdokent ve'rt izzadsz hogy jol kovesd le, jol foglalj helyet es szabadits fel stb. mig java-ban meg letrehozol egy (mondjuk) ArrayList-et, azt annyi. Nem beszelve arrol, hogy ha C-ben levo kodot kell egy nem kimondottan szepen kodolo embertol visszafejtene'd, az megint egy nyomozassal feler (persze java-ban is lehet ilyet elkovetni, foleg ha 2-3 betus valtozoneveket es/vagy mas nyelvu roviditeseket hasznal - multkor neztem egy ruszki programozo versenymegoldasat ahol ugye nincs ido csicsazni, eleg erdekes volt visszafejteni a core algot, de C-ben pont a nagyon nagy rugalmassag miatt nagyon nagy randasagot is el lehet kovetni ugy, hogy helyes, csak attekinthetetlen).
[ Szerkesztve ]
-
axioma
veterán
válasz bucsupeti #4299 üzenetére
Ez azert olyan 20 evvel ezelott keringi "Az igazi programozo" c. irasra emlekezteto fordulat volt... szerintem ez egy kicsit generacios kerdes is. A gyerekemnek mar az lesz trivialitas, hogy leir (ha egyaltalan szo szerint iras lesz az me'g) egy kodsort es mar a masik ablakban fut is a modositott program. Az en szuleim korosztalyaban (o"k konkretan nem) levo, korai programozok viszont felvezeto szinten, nand kapukra felbontott logikai kifejezesek nelkul nem tudta elkepzelni, hogy valaki programozni fog tudni. [En valahol a ketto kozott vagyok.] Es ez me'g csak nem is azert van, hogy mi volt az elterjedtseg akkor, es mi most. Vagy hogy milyen a fejlesztokornyezet, es milyen most. Egyszeruen bovult az egesz "programozas" fogalom, es egyben specializalodott is. Egy magasszintu program megirasahoz szerintem nem alapveto tudas a forditas miertjenek melyrehatobb (meddig melyre?) ismerete, csak a szuksegessege es a modja (mondjuk ha ide vesszuk az internetet meg az rtfm-et is, akkor inkabb csak a szuksegesseg ismerete). Viszont mindig lesz olyan, aki meg hw-kozeli dolgokat csinal, es adott esetben aka'r lenezi a magas szinten programozokat, akik egy chip labait se tudjak megkulonboztetni egymastol, vagy nem tudja megmondani, hogy adott asm kod hany usec nagysagrendig fut.
Szerintem minden nagyon mulik a feladatokon, amiket meg kell oldani, nem lehet azt mondani hogy ez vagy az nelkul nem lehet programozni. Legfeljebb a programozas bizonyos alfaja't nem konnyu nelkule muvelni. -
axioma
veterán
Van egy modul C-ben, amit en mint java programozo kellett kulonbozo okokbol (matematikus hatter) megirjak egy beagyazott rendszerhez. Elso (masodik) kor utan kiderult, hogy alapvetoen siker, de sebesseg miatt ki kell hasznalni azt, hogy a celrendszer 32 bites big endian.
A problema ott van, hogy innentol kezdve nem tudok tesztelni plane debugolni a fejl.kornyezetemben (ecceru netbeans), a celhelyen meg "draga" (egyreszt m.tars es gepenek meg celhardvernek ideje, nalam nem rakhato ossze masik; masreszt meg maceras kinyerni adatot, nincs pl. konzol hogy oda menjen a dump.
Probaltam a guglit is kerdezni, egy feleslegesen nagy rendszert talaltam (Qemu), de azt meg nem sikerult a gepemen osszerakni, es ugyis verebre agyuval esete lenne. A kodomban sincs semmi trukk (valtozok, pointerek, bitmuveletek), nem kell periferia, kivulrol partiz byte-os memoriateruletre mutato parameterekkel meghivnak, en ugyanott valaszolok, es annyi. Mivel biztonsagi fejlesztes, az nem megoldas, hogy a kodot megirom little-re, majd "vigyazva" irjuk at a bigendian-ban mukodore.
Van barkinek otlete, hogy hogyan lehetne ezt valahogy pc-n emulacioval vagy mas modon megoldani? (OFF)Arra lehet szamitani, hogy egyszeri max. par oras feladat (zarojel, ++ es hasonlok elnezese peldaul, netto kodirasi pontatlansagok varhatoak). (/OFF) -
axioma
veterán
Koszi a valaszokat. Igen, a program a byte-ok bizergalasan kivul semmi kulonoset nem csinal (egy titkositast kell ratolni ill. leszedni a bytetombre mint uzenetre), amugy luminary.
Jo, akkor Qemu... azert gondoltam hogy tulzas, mert a manualjanak 90%-a a periferiak, a net, a kulonbozo mas eszkozok beallitasa, ami nekem mind nem kell. Elkezdtem a leiras szerint a ceges win7 64 bitesre felepiteni, de vagy rosszat toltottem le, vagy a korabban felpakolt mingw nem jo vagy nemtudom, a zlib helyrerakas es a .configure elnagyolt modositasi leirasa kornyeken adtam fel (a letoltott qemu-ban levo qemu-doc.html volt amit probaltam kovetni, lehet hoyg valami masik leirast kellett volna keresnem).
Vegulis linux is van keznel ha nagyon akarom (otthon legalabbis, bar egy oskovulet gepen es nem is a legfrissebb verzio), lehet hogy akkor majd azzal nekiallok, hatha egyszerubb (meg tudtak csinalni automatizaltabbra), mint windows alatt a sok szuttyoges. -
axioma
veterán
válasz don_peter #4455 üzenetére
Azt nem ertem a feladatban, hogy nem megforditani kell mint egesz szamot szamjegyek sorakent? Ha eleve ugy raktad le, hogy a 0. elem a 0. helyiertek, es utana a hossztol indulsz vissza, akkor siman osszerakod a szamot, nem forditva kapod meg, ez a futasi eredmenyeden is latszik. Raadasul ehhez (megforditott szam) a ciklus ugyanabban az iranyban menne felbontaskor es osszerakaskor, es igy osszevonhato, meg a tombben tarolas is teljesen kihagyhato belole, a hossz sem erdekel bar persze vezetheto, meg nem kene a tartomanyt se bekorlatozni.
Ha direkt az eredetit akartad osszerakni (de azt eleve beolvasod, tudnad a szetszedes elott menteni, ezert gondolnam hogy nem), akkor viszont nem szoltam.[ Szerkesztve ]
-
axioma
veterán
válasz don_peter #4458 üzenetére
Ez mar ugye mas, itt muszaj lesz megszamolni a hosszt, en eredetileg csak erre az osszevonasra gondoltam (poz. egesz szambol a megforditottja poz. egesz gyartasa, intbol int):
int input=...; // segedvaltozo legyen, mert szetbarmoljuk
int forditva=0;
while (input != 0) {
forditva=forditva*10+input%10;
input=input/10;
}Amit szeretnel, szerintem megkerulheto egy sprintf -fel (nyilvan memoriafoglalasra stb. kell akkor meg figyelni).
De ha matekos megoldast akarsz, akkor logikus megkeresni a legnagyobb helyierteket, es itt is lehet (kovethetobb) szamolni a hosszt:hossz=1;
helyiertek=1;
while (helyiertek<input) {
helyiertek*=10;
hossz++;
}
-- de akkor vigyazni kell arra, hogy az input pozitiv egesz (0 sem jo!) legyen (nyilvan itt ez gyors, de nagyon altalaban lehetne logaritmussal is szamolni, hoyg a 10 hanyadik hatvanya ez), es utana akkor erre felepitve mar a ciklusod:int szamjegy;
int osszerakva=0;
while (helyiertek>0) {
szamjegy=(input/helyiertek)%10;
printf("%d,",szamjegy);
osszerakva=osszerakva*10+szamjegy;
// vagy: osszerakva=osszerakva+szamjegy*helyiertek;
helyiertek/=10;
}Igy az inputodat se valtoztatod meg.
Ilyenre gondoltal? Bocs, a koritest (beolvasas, vegso kiiratas) kihagytam, az algoritmust ez a resz is mutatja.
(Amugy en java-s vagyok es nem is sokat szolok itt hozza, meg is lepett hogy pont hozzam intezted a kodirasi kerest.)[ Szerkesztve ]
-
axioma
veterán
válasz don_peter #4460 üzenetére
Csak az elso programreszlet a megforditasos, a masik ketto az mar a mostani problemadhoz kapcsolodo reszlet, a sima elolrol hatra felszeletelgetes. Es ta'rolasra nincs benne tomb.
Mondjuk egy hasonlo feladatot kaptam egyszer egy interju reszekent ugy, hogy csinaljam meg rekurzivan szamolgatas nelkul (balrazart kiiratast ott igazabol), az kodsorban joval kevesebb, de megintcsak nem tanultatok:void egyesevel(int input) {
if (input>=10) {
egyesevel(input/10);
printf(",");
}
printf("%d",input%10);
}Ebben annyi a "beugrato", hogy csak akkor tudod megcsinalni, ha az aktualis korben elintezendo _elott_ hivod meg ugyanezt a fuggvenyt rekurzivan. Legtobbszor inkabb ugy csinaljuk, hogy elintezzuk az aktualisat, es a maradekot a rekurziv hivassal. Hiaba nincs erre semmi ok, ez az automatizmus, a rugalmassagot teszteltek vele.
[ Szerkesztve ]
-
axioma
veterán
válasz don_peter #4467 üzenetére
1. azert van a kettes duplazva, mert elfelejtetted a "nem tizedespont koveti" esetet kulon else agba rakni, igy a tizedes elotti is rafut arra is.
2. az if feltetel tul bonyolult, mert a tizedes nalad fixen 5 db lesz (me'g ha a vege nullakkal is van feltoltve), hiszen 100e-rel szoroztal (eleg lenne oda egy ilyen:for(i = mennyi; i >= 0; i--){
printf("%i", oszto_tomb[i]);
if (i==5) { // a 4-3-2-1-0 a tortresz
printf(".");
}
}
3. szerintem a tizedes nevu valtozoval pont az egeszresz hosszat "szamolod"... nem tul szerencses elnevezes, azt lehetne hinni, hogy a (hasznos) tizedeseket (mert pl. most ha az inputod 2.5, akkor azt fogja kiirni, hogy 2.50000)
4. a negativ szamokra sehol nem gondolsz, me'g egy arva hibauzenetet se dobsz
5. nem ertem a mennyi=i; i++; reszt sem: nem lenne egyszerubb, ha a ciklusban nem bantanad a mennyi-t, hanem a kilepes utan irnad, hogy mennyi=i-1 ? Vagy hatultesztelos ciklus (egy szamjegyet ugyis fogsz irni). -
axioma
veterán
válasz buherton #4479 üzenetére
Barmilyen szep es trukkos, en szinte kizartnak tartom, hogy ha ezt irod, azzal az eselyeidet noveled. Pont nem latszik, mit csinal a programreszlet (nem magadnak meg a fioknak irsz, hanem a cegnek, o meg karban akarja tarttatni a kodot, nelkuled is).
Mindenkepp olyan kodot varnek en (ha ilyen szerepem lenne) a jelentkezotol, amibol latszik, hogy mit csinal (ad absurdum ez is jo lehet, ha halalra van kommentezve, de akkor meg pont az nem marad meg, hogy attol szep, hogy rovid -- mert a shift es also bit szamolasanal se nem gyorsabb, se nem mellekhatas-mentesebb).
Illetve pont attol hogy letisztultan szep, az latszik belole, hogy nem ott otolte ki az illeto, hanem valahol latta es megtanulta... ami megint nem az interjun vart kreativitast tukrozi.
Szigoruan szvsz! -
axioma
veterán
válasz Jester01 #4485 üzenetére
Arrol beszeltem. De mint programozo nagysagrend szinten gondolkozom egy algoritmus gyorsasagarol (kis/nagy ordo'k). Az egyik esetben egy N bites szam eseten varhato ertekben N-szer fut le, a masiknal - ha eleg veletlenszeruek a szamok - N/2-szor (N az most ne az abrazolasi bitszam legyen, hanem a legmagasabb bittel bezarolag a szam merete). En ezt nem tartom igazan sebessegkulonbsegnek, bar teny, hogy lehetnek helyzetek ahol ez szamit - pl. AES titkositast kellett legutobb addig pofozgatni, amig abban a kornyezetben a savszelesseget a titkositas nem korlatozta mar le, itt szamitott a 6-7x-es szorzo, annak aran is, hogy a kod.szabv.-unkkal ellentetesen felhasznaltuk a pointer-aritmetikat.
dabadab: code review-zo szintjen gondoltam, en ilyenre gondoltam: "mivel az egy kivonasa a legalso 1-es bittol kezdve csinal xor muveletet, vissza-&-elve csak pontosan ez a bit valtozik"
Es igazabol ez szamabrazolasi kerdes is, mondjuk ha bcd kijelzesu orarol es megjelenitendo bitekrol beszelunk, akkor ez nem segit.[ Szerkesztve ]
-
axioma
veterán
válasz buherton #4488 üzenetére
Bar a butasag jelzot nem tartom erre szerencsesnek, de maradjunk abban, hogy ezek szerint vannak munkahelyek, ahol ezt a trukkozos stilust az en eddigi tapasztalataim ellenere szeretik.
Azt megkerdezhetem, hogy milyen celu program az, amin a "szepseg" helyett kevesebb programkod = jobb karbantarthatosag elv menten csinaltatok atirast? Meg esetleg hogy hany fo fejleszto meretu az a kod, az is erdekes lehetne. -
axioma
veterán
Tudom hogy mas, nalunk is ilyen fejlesztes van, csak en csak toolt irok hozza, kiveve a lent emlitett aes reszlet. Viszont biztonsagkritikus a termek, igy azert eleg sok minden a nem megengedheto kategoria.
Volt - mas termekvonalon - olyan programozo, aki baromi okos, eszmeletlen tomor kodot irt, ellenben kommentek nelkul, verziokezeles immel-ammal, es az o reszebe tkp. eselytelen volt masnak megtenni egy valtoztatast. Ez addig jo, amig o keznel van, es barmit kulon kovetelesek nelkul megtesz. Aztan borul a bili. [Masik m.helyen volt m.tars, aki azzal dicsekedett, hogy az elozo m.helyen valami premiumot nem akartak kifizetni mikor eljott, erre random helyeken kicserelt egy adatbazisban matato programban +1-eket -1-re es felcserelt hasonlo nevu szamlalokat... dobbenet, mikre nem kell szamitani mint munkaltato.]
Nyilvan eltertunk az alaptargytol, azt a kis reszletet - legfeljebb ne'mi aha-elmeny utan - normalis programozo atlatja. En ettol fuggetlenul rossz uzenetnek tartanam egy felvetelin. Ennyi, es nem tobb. -
axioma
veterán
válasz buherton #4492 üzenetére
A shift baromira nem elrettento, nem vagyok en ennyire a lo tuloldalan! [Bar egy konstans /2-t, sot 2-hatvanyt a "raeros" forditasi idoben illene a forditoprogramnak shiftre modositania, es akkor maradhatna az embernek szolo kod az osztas, de ez megint mas kerdes.]
Kozlekedes az stimmel, csak nalunk vasut a domain. De hat ezek szerint mas mutatokat hasznalnak egyszeruen a cegek a karbantarthatosagra, es ennek megfeleloen mas az eljaras is.
A tomoren programozo kollega valoban a dokumentum irasaban se jeleskedett. Egy adott celra kihegyezett radio jel->uzenet feldolgozasarol volt szo, a feladat viszonylag roviden korulhatarolhato, a ket oldalrol volt doksi, a sajat reszenek viszont nemigen irta le a belsejet, a megkozelitesi modot.
A masik, bosszuallo kollega igen, egy verziokezeles nelkuli helyen dolgozott... (tobb mint 10 eve meselte azert azt is tegyuk hozza), es hanyni tudnek az ilyentol, csak peldanak mondtam hogy mi meg nem tortenhet. -
axioma
veterán
válasz don_peter #4498 üzenetére
Ha nem ragaszkodsz "srac"-hoz
Eloszor is a 0 azert van az elejen, mert az kodolja hogy oktalis. Tehat matekosan 100 011 (2) = 43 (8), ahol a zarojelben levo szamok kis karikazott szamok alul.
Masreszt azt tudod, hogy 10-es szamrendszerbol a 2-esbe hogyan megy? Tehat a 35 (10) = 43 (8) az stimmel, csak a kozvetlen atvaltas nem? Ha igy van, a 2-esbol 16-osba (hexa) az ertheto, csak az oktalis nem?
Ha behatarolod, hogy hol nem ertheto, egyszerubb lesz segiteni. -
-
axioma
veterán
válasz Jester01 #4506 üzenetére
Azt mar 40+ mar ha ebben a korban nem venasszonyoztok me'g le a lany helyett
De itt a lany/no" + programozas volt a kerdes - bar teny, az se pontos datumilag. Mar 7. altalanosban jartam a titbe tanfolyamra, hogy progizni tanuljam a zx spectrumot basicben. Ha meg ugy nezem, az egyetem elejen "csak" mat.kus voltam, 4. evtol vettem fel a progmatot, bar ezt nem annyira tevedes osszemosni, a matkus szak + no" is kello csodalkozast/hitetlenkedest valtott ki...
De kit erdekelnek mar a tobb evtizedes sztoriban az ilyen reszletek.[ Szerkesztve ]
-
axioma
veterán
válasz don_peter #4544 üzenetére
Ha jol ertem, stringek tombjet szeretned a kulonszedett elemekkel, tehat a memtomb az char[][], es a meretvalasztasnal 1-gyel tobb kell mint a leghosszabb elem, bar a Valaminev-nel lazan a 7-t is kifutod... Persze annak az indexet is kovetned kell, hogy mikor melyikbe irsz, es annak is hanyadik elemere (bar eccerubb, ha megjegyzed az utolso elvalasztas helyet, es csak kivonogatsz, de vszinu atlathatatlanabb is egyuttal).
Masreszt meg amikor # jon az inputban, akkor az aktualis memtomb-elemedet le kell zarni egy 0-val.szerk. nem frissitettem, nalam keresztposzt...
Most nezem, az utolso sor azert kelleni fog neked...[ Szerkesztve ]
-
axioma
veterán
válasz don_peter #4548 üzenetére
En alapvetoen java-s vagyok, csak az elvi hibakat szurom - foleg annak aki ennyire rendes, hogy a holgyeket is megemliti . Felteszem van valami split fuggveny stringekre es felteszem hogy az legalabb olyan jol van megirva mint amit te meg tudsz, de nem ismerem a C-s fg-konyvtarakat, hogy konkretabban megadjam. Az azert valoszinu, hogy egy regota ebben elo C-s az forditva csinalna, megkeresne a kovetkezo #-et (vagy nullat, hogy altalanos legyen, neked most csak pont erre a hosszra muxik), es utana az elozotol addig egyben masoltatna'.
-
axioma
veterán
válasz TheProb #4580 üzenetére
Eloszor is a 12. sorban (4*n, char) a parameter es nem char*, bar ez nem okozhatja elvileg a hibat (bar odaillobb lenne egy +1 is az elsohoz, a 888 lezaro nullaja miatt).
Masodszor en nem vagyok ennyire benne a C-s stringfuggvenyekben es most utananezni sincs kedvem, de a feltuno kulonbseg az, hogy az n==1-nel nem strcat-olsz. Azt gyanitanam, hogy a stringvegzodest jelzo nullat az a fuggveny rantja a tobbinel helyre.[ Szerkesztve ]
-
axioma
veterán
Addig szerkesztgettem, mig a jot is kivettem belole (elsore nem tunt fel, hogy nem elseif-esek az n vizsgalatai), szoval van me'g egy problema: a statikus chartombjeidne'l (stringek) a tombmeret megadasa ebben a sorrendben semmikepp nem stimmel. Nem is ertem, miert 2 dimenzios chartomb, mikor 1 dimenzios char* tombkent, az ott megadott stringek fix cimet hasznalod.
-
axioma
veterán
válasz TheProb #4583 üzenetére
Hat akkor az a baj, ami ott else-ben van (en is jol atneztem felette, ugy tunt mintha az futna le - nem veletlen a minden egy utasitasos blokkot is zarojelparba szokas) az rakna' at az outputba... az egyeseknel ottmarad a romai-ban... amelyikben meg nem volt egyes, az rafut erre, ott meg tok foloslegesen ujra atmasolja.
szerk. jo, lehet a tomb jo (es nem csak mukodo ), vegulis a * es a [] "valahol" egyenertekuek, lehet hogy csak tolem idegen szokas.
[ Szerkesztve ]
-
axioma
veterán
válasz TheProb #4585 üzenetére
Lehetne rekurzivan, de ez a feladat sztem pont nem alkalmas arra, hogy lasd, mire valo a rekurzio (az "ugyanaz a feladat" helyett itt pont a rekurzio melysege szerinti if-es szetagazasok vannak). Itt inkabb a helyedben a kulso if-ben (az 'a' erteke pozitiv es 4000 alatti) tennek ciklust, akkor nem szamit a sorrendje az if-eknek. Sot, ha jobban megnezed, akkor az if-ek igazabol nem kene kulon kezeljek azt, hogy nincs mar tobb kiirando, lehet mindig 1-gyel csokkenteni az n-et, mert megteheto hogy a 0 az nem fuz semmit az outputhoz (me'gis lesz 0. elem minden statikus tombben, ami az ures string ""). Vagy nezheted ugy, hogy az n-re nincs is szukseged, csak az 'a'-ra, aminek egy ciklusban mindig csak a legfelso szamjegyet ertekeled ki (es magat az a-t modositod, nem az n-et). Igazabol a szamkent kezeles se feltetlen kene, ha marad stringben, akkor cimezheted az (inp-'0')-val a statikus tombodet... Es raadasul me'g a tombjeidet is szervezhetned tombbe, akkor az i. karakterhez az i. tombbol kell venned ezt az erteket (nyilvan ekkor hatulrol kezdve szamozva, de length-1 -tol lefele szamolva a ciklust). Ebbol mar eleg kompakt kis kod keletkezne.
-
axioma
veterán
válasz don_peter #4639 üzenetére
Par dolgot nem ertek.
1. ha sporolni akarsz, es raadasul egyszerubben olvashato tarteruletet, akkor miert 2-3 (valtozo hossz!) karakter a sorszam, mikor befer egy byte-ba (sot, ha hexa jegykent irod le, akkor ugymond olvashato formaban is marad '1'..'9','A',...)?
2. miert nem a nev hosszan sporolsz (felteszem nem kell annyira kifejezonek lennie, regen 8 (max+3)-ba mi minden belefert )
3. most akkor hogyan 6 byte a ho- es idoprofil (ott karakteresen tarolsz szamot, es egy tol-ig ahol mindket szelso lehet 3 jegyu?), de 2 byte szamabrazolt az also futes? nekem maga az eredeti elkepzeles nem konzisztens -
axioma
veterán
válasz don_peter #4644 üzenetére
Lattam a video elejet korabban, de nem erdekelt vegig Vagy nem ez volt, de a kutyudre emlekszem.
Ja, akkor tenyleg 6 adatod van a kozepen is, ez nem volt vilagos.
Hozzateszem, nem vagyok ilyen hardverkozeli programozo, az elso hsz-om is csak a tarolasrol szolt.
Nem ertem mit akarsz osszevonni, megmondom oszinten... lesz x byte teruleted, arra rateszel egy olyan strukturat, amilyen illik az adatokra. Lesz benne char[] es lesz benne unsigned byte meg unsigned short. Nem ez lenne a trivialis? Vagy valamiert mindenkepp egy valamilyen tomb kene legyen?
En me'g azt nem ertem, hogy ha rogton az elejen hogy lehet 2 VAGY 3 byte/char... feltoltod ugy hogy (karakteresen) #12 akkor honnan fogod tudni, hogy igy kell olvasni, es a 2 nem az utana kovetkezo adathoz tartozik es a #1-rol van szo? Raadasul 4 bitnyi adatrol van szo... fura, vagy tovabbra se ertem, nezd el nekem.
Ha csak nagyon helyszukeben lennel, de a prog. hossza nem szamit, akkor a betuket tudnad me'g tomoriteni (mivel a billrol ha jol latom kb. 40 fele karaktert tudsz bevinni, az 6 bitbe befer; na de ezt oda-vissza konvertalgatni macera (kodterulet, hibalehetoseg...), es mindossze 4 byte roviditest ad 16 byte-nal.[ Szerkesztve ]
-
axioma
veterán
válasz don_peter #4653 üzenetére
En feladtam. Sajnos nem ertem mit szeretnel tudni. Remelem jon valaki, aki erti, es valaszol.
Talan me'g azt tehetnem hozza, hogy a 2 byte adatot tekintsd egy 1 jegyu 256-os szamrendszerbeli szamnak. Az egyik byte az a nullasok, a masik a 256-osok szama. Ha erre gondolsz, de nem hiszem. -
axioma
veterán
válasz don_peter #4660 üzenetére
Hat a hexaban tarolason akadt fent a szemem. Ha jol latom ezt a kovetkeztetest abbol vontad le, hogy az altalad irt (vagy valahonnan kopizott) programban a printf a %x -szel formaz... szet kene kicsit valasztani a fejedben az "ertek" (mit jelent neked), "abrazolas" (milyen modon tarolodik a memoriaban), "megjelenites" (mit latsz a kepernyon amikor lekered, ld. printf) kozott. Es akkor me'g jonnek a cast-ok, mint pl. ez a union... de szamokra is van cast, az abrazolt erteket masik ertelmezessel hasznalni.
[ Szerkesztve ]
-
axioma
veterán
válasz buherton #4746 üzenetére
Akkor nekem anno hulyeseget tanitottak... en ugy tudtam, hogy az i++ azt jelenti, hogy az adott sorban levo minden mas muvelet utan kell az i=i+1-et erteni, a ++i-nel meg ugyanezt az (ezen muvelettol megfosztott) sor ele. Ez siman eldontene a dolgot ebben az esetben is (azt ertem, hogy csak a ketszer i-nek ertekadasnal van gond, altalanos esetben igaz lesz). Igazabol nem is tudom elkepzelni, hogy mi az az indok, amiert a ford.pr-nak jobb ha nem tartja ezt ebben a spec. esetben is be, de biztos oka van.
Mas kerdes, hogy nem tunik amugy se jo gyakorlatnak semmi olyan kodsort leirni, ami nem ranezesre egyertelmu, hogy mit fog csinalni. Raadasul ez csak 2 sort von ossze egybe, nem egy nagy kaland kiirni, biztositani az elkepzeleseknek megfelelo sorrendet. -
axioma
veterán
válasz lockdown90 #4784 üzenetére
Ezt ki a fene talalta ki? Baromsag ilyenekkel szivatni az embereket, sima egy valtozonal tudja az ertek es cim szerinti atadas kozti kulonbseget (na mondjuk azt se egy darab vegeredmeny eltalalasaval lehet ellenorzni), es maris felkeszult az eldontesere, hogy melyiket hasznalja. De ennek itt eppen semmi ertelme. Ilyet se irni, se olvasni nem fog senki valos kornyezetben, es sztem aki erti a ketto kozti kulonbseget, az is igen jo esellyel belehibazik foleg a fejben szamontartasba...
-
axioma
veterán
válasz lockdown90 #4792 üzenetére
A while(int) mukodese a kerdes? Az int i==0 az hamisat ero ertek, az osszes pozitiv egesz meg igaz. Ez eleg? Kicsit alulspecifikaltnak erzem a magyarazasi feladatot...
-
axioma
veterán
válasz lockdown90 #4794 üzenetére
mert a j%3=9%3=0, azaz hamis; csokkenti, es a kov. forduloban jut csak el a print sorig.
-
axioma
veterán
válasz alapz@j #4807 üzenetére
Konyhanyelven:
Hogy csak akkor legyen berakva, ha eddig nem volt. Mert hiaba ugyanaz, ha ketszer megjelenik pl. egy fg-fejlec, az nem derul ki ezen a szinten, hogy nem utkozest (kulonbozo megvalositast) jelent...
Effektive egy sajat "nemtobbszorozo" technika az, hogy minden egyes include-nal az adott file-hoz rendelt nevet define-oljak, illetve ha mashol meg az a define mar letezik, akkor elhiszik, hogy az include is megtortent. Termeszetesen ez csak akkor mukodik, ha szisztematikusan jol csinalod az egesz projekten vegig. -
axioma
veterán
válasz buherton #4816 üzenetére
C-t akarsz tesztelni vagy algoritmust csak C-ben megvalositva?
(Ami kiguglizhato, az nem azert nem jo kerdes szigoruan szvsz, mert azt munka kozben is kiguglizza es hasznalja. Amit viszont o kell megalkosson... azt eleve tudnia kell.) Persze ha kodolas kell es nem az alkoto munka, akkor mind1.
Multkor egy konyvet neztem amit valaki ajanlott (de mikor mar elvi hibat is vetett a "megoldasban", nem csak elirast meg felesleges, de a megoldast nem zavaro koroket, akkor felreraktam), ott volt egy rakat linkelt listas feladat, ami pointeres, meg az adatszerkezetet is kitalalhatja hozza. Ilyen volt pl. hogy "korrupt" linkelt listaban (az utolso elem valami koztes elemre mutat) keresd meg konstans tarhely es ordo(N) muveletigennyel az elso ismetlodo elemet. De ehhez mar a trukkot kell ismerni (ordo(N^2) vagy felesleges bit per elem megengedesevel persze nem is nehez). -
axioma
veterán
válasz buherton #4820 üzenetére
Ja, azt hittem fel akarsz venni munkatarsat, es ahhoz kell a teszt...
Konkretan a Siemensben anno ket honapon belul ketszer jutott el hozzam az a kerdes, hogy milyen rendezest kell alkalmazni (mire keressen ra a neten), ha egy kisebb es ritkan valtozo szamhalmazbol nagyon sokszor kell egy masik, surun valtozo szamhoz kivalasztani azt az elemet, amelyik a legnagyobb kezdoszelete. Ezt csinaljak a telefonkozpontok amikor intelligens szolgaltatasok vannak hozzarendelve (a maradek meg a szolgaltatas parametere). Oszinten kivancsi vagyok, hogy erre mit mond a gugli, mar persze ha nem vagod serobol a megoldast.
Termeszetesen nem tesztelni akarlak, csak egy egyszeru eletszagu peldat mondtam, ahol az algotudassal tobbre mentem (jelzem, tok veletlenul egy versenyekre felkeszito mindenen felul felvett oran hallottam... anelkul nem tuti hogy "kirakom"). Megvalositva egyebkent ket kulonbozo nyelven, tok mas programok reszekent lett.[ Szerkesztve ]
-
axioma
veterán
válasz don_peter #4835 üzenetére
1. ha felulrol akarod, akkor bitek >> (7-i) (vagy persze megforditod a for ciklust, de akkor fiygelj hogy ne unsigned legyen, mert akkor a >0 mindig igaz)
2. a letolassal csak az also biten lesz az, amit akarsz, de felette maradtak tovabbi bitek! Ket lehetoseged van (kb. ugyanaz lesz gepi kodban ha jo az optimalizacio): vagy vizsgalod ennek a 2-es maradekat (%2), vagy szo szerint nezed az utolso bitet (bitwise and -del, azaz &1), es persze igy mar vizsgalhatod az egyenloseget az 1-gyelszerk. upsz de lassu vagyok...
[ Szerkesztve ]
-
axioma
veterán
válasz moseras #4878 üzenetére
En ugy gondoltam, hogy az union az tartalmaz egy uint8_t[8]-t es egy olyan strukturat, amiben benne van a 16 bites BC es DE (ha annyira kell mukodjon, mint te irtal), vagy eleve egy uint16_t[4] es akkor mindet eleri, es annak a BC, DE-re valo define-ja se lenne vallalhatatlan kavaras. Es pl. a bytetombot az eredeti indexelessel hasznalhatja, mig az egyesevel union eseten duplan kell (hanyadik strukt hanyadik - 0 v. 1 - byte-ja).
[ Szerkesztve ]
-
axioma
veterán
válasz tomrRRR #4937 üzenetére
Oh, ez a feladat! Tobb mint nosztalgia... a gimi eleje nekem mar tul regen volt Sot, kesobb meg kellett irni a forditottjat is (a gep kerdezgessen), meg azt is hogy amikor a user kerdez, ne legyen valoban kitalalt szam, hanem ugy valaszoljon, hogy mindig kelljen a 7 kerdes minimum! Hogy izgibb legyen, az osszes tipusnal a hatar random 0-10 kozti szamtol random 90-110 kozti szamig volt (a tol-ig inditaskor ment ki a kepernyore). Termeszetesen az egesz off, mert mindez Basic-ben ment.
-
axioma
veterán
válasz tomrRRR #4944 üzenetére
41 evesen? Tinilanyaim megregulazojanak, legfeljebb... amugy 10+ eve java fejleszto vagyok. Csak tudod a 80-as evekben foleg az elso feleben nem volt annyira trivialis, hogy diakkent egyaltalan valamilyen szamitogephez kerulsz, az meg plane hogy programot irsz (tit tanfolyam a programozasrol volt mar 7.-es koromban, konyv + irasvetito, egy darab commodore talan mukodott ott, de lehet hogy csak a futasi eredmenyt vestek fel. Az akkoriban elofordulo ht, primo, sinclair gepekhez kulon basic nyelvjaras volt... es akkor me'g meglehetosen butan neztek hogy egy lanyt ilyesmi erdekelhet.)
Viszont az algoritmus az algoritmus barmelyik altalanos celu nyelvben, elvileg akkor is ugyanugy kellett megoldani, pl. hogy a "meg lehetseges" szamtartomany kozepet kell mindig betippelni (sot, ha olyat kerdezett a user, ami tartomanyon kivul esett, nem is mondott kisebb-nagyobb eredmenyt, csak hogy "Ez butasag!") -
axioma
veterán
válasz bucsupeti #4947 üzenetére
En nem keves esetben azt latom, hogy a munkatarsat kereso cegek sem feltetlen az algoritmus szerinti (illetve a lenti problema feletti elso bonyolultsagi lepcson mar az adatszerkezet is ide jon) gondolkodast nezik a jeloltben, hanem celnyelvben jartassagi fokot... ugyhogy sajnos azt kell mondjam, hogy a tanulok/hallgatok altalaban egyszeruen csak az igenyekhez alkalmazkodnak. Nyilvan vannak kivetelek igeny es fiatal munkaero oldalon is.
Ú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!