Új hozzászólás Aktív témák
-
don_peter
senior tag
Pfff ez az egész kusza kicsit.
Találtam közben ezt, de valamiért túl sok nekem egyszerre. [link]
Tömör és nem értem mit hogyan...
Amit értek:
Mi 10-es számrendszerben számolunk mindent, vagy is ez az alap számunkra.
Ez eddig stimmel?A 2-es számrendszerbe átszámolni valamit, mondjuk 8bit-et a példa kedvéért:
2 a 7.-en, 2 a 6.-on, 2 az 5.-en ... 2 a 0.-on.
Ez bináris példában: 0000 1100 = 8 + 4 == 12
Ez eddig stimmel?Ha stimmel akkor eddig értem a dolgot.
De a többi egyelőre homály.
Szeretném én úgy megérteni, hogy ne keljen táblázatból lesnem az értékeket.ui: a srácok jelző lehet idősebb is mint pl én és lehet ezért is nem fog már rendesen az agyam
Azt most már tudom, hogy melyik milyen számrendszerben van.
Bináris (2-es)
Oktális (8-as)
Decimális (10-es)
Hexadecimális (16-os)10bit 2-es hatványát kell venni nem? Mármint 10-esből 2-esbe átszámolásnál.
Persze csak, ha binárisban van a szám.
Lehet, hogy ez sem tusom..
Rendet kellene tennem az agyban ezekkel kapcsolatban mert enélkül nem léphetek tovább. -
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. -
don_peter
senior tag
Srácok kérnék egy kis segítséget, hogy megértsek valamit.
Tanulom ezt a C nyelvet és elakadtam a bináris és oktális átszámolásnál.
Nem értem ezeket:Bináris = oktális
... 000 011 = 03
... 000 110 = 06
... 001 100 = 014A bináris ábrázolások 32bit-en kell elképzelni és nem értem miként jönnek ki az oktális eredmények.
Valaki elmagyarázná?
A könyv nem ad számomra elégséges magyarázatot az átszámolására.
Előre is köszi. -
buherton
őstag
Eddig öt cégnél dolgoztam (négy autóipari, egy orvostechinkai) és különesebben nem kötötték meg sehol sem a fejlesztő kezét, hogy mennyire használhatja a nyelvi elemeket és szerintem ez így van jól. Persze legyen mellé rendes dokumentáció.
Sejtem, hogy melyik cégnél vagy, annak a kamionos részlegére majdnem bejutottam.
-
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. -
dabadab
titán
válasz
buherton
#4492
üzenetére
"Következő példád az emberi gyarlóságra vezethető vissza."
Meg arra, hogy nem volt rendes verziokezeles meg kodreview meg unit test. Eddigi palyafutasom alatt nagyobbreszt ugy dolgoztam, hogy csak ugy lehetett valamit becheckelni, hogy azt valaki review-zta, ott meg kibukott volna az ilyen idetlenkedes. Vagy ha ott nem, akkor unit testen.
-
buherton
őstag
Ha szép kódot akarsz írni, akkor ott a C++. A C-t nem azért használják ma (kivétel természetesen a karbantartás), mert szép nyelv, hanem mert hatékony, de ha te ennek ellenére is szép kódot akarsz írni benne, akkor pont a lényeg fog elveszni. Például melyiket használnád egy szám kettővel való osztására?
value = (value >> 1);
value = value / 2;Az előbbi nem egyértelmű, hogy mi is a célja, de egy olyan architektúrán ahol nincs hardveres osztás ott csak ezt fogod használni, mert az előbbi 1 utasítás az utóbbi 10+ és még ciklus is van benne.
A kód autóiparban készült és egy másik mikrokontrollert figyel, hogy jól működik-e, és ha nem, akkor közbe avatkozik. Ha ezt nem tenné, akkor életre veszélyes helyzetek is könnyen elő állhatnak.
(#4491) axioma: eszmeletlen tomor kodot irt, ellenben kommentek nelkul, verziokezeles immel-ammal, es az o reszebe tkp. eselytelen volt masnak megtenni egy valtoztatast.
Meg is magyaráztad egy mondaton belül, hogy miért volt rossz ahogy fejlesztett. Dokumentáció volt hozzá? Design vagy hasonló doksi? Következő példád az emberi gyarlóságra vezethető vissza.
-
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
#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. -
buherton
őstag
Bocsánat, de butaságot írsz. Erre való a komment, illetve a függvény, hogy a nehezebben érthető program részletet könnyebben át lehessen nézni. A szépen megírt kód nem hatékony, lassú, és több helyet foglal. Nagyon jó példa erre, hogy most ahol dolgozom ott súlyos összegeket adtak ki azért, hogy optimalizálják méretre a kódot, mert egyszerűen nem tudnak tovább haladni a fejlesztéssel. Tele volt nagyon szép, és könnyen olvasható kóddal, ami fölöslegesen foglalta a drága helyet. 20%-t hoztunk csak azon, hogy a szép kódokat és teljesen felesleges kód részleteket kigyomláltuk.
mert a shift es also bit szamolasanal se nem gyorsabb, se nem mellekhatas-mentesebb
Ha te mondod, de azért inkább maradok az általam kinézettnél.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.
Jah, hanem azt, hogy az illető szokott ilyen oldalakat is nézni, és foglalkoztatja annyira, hogy emlékszik rá. Ez tényleg üldözendő dolog.
Különben, ha nem tetszik, akkor itt van ez: int __builtin_popcount (unsigned int x), ennél világosabb nem lehet. Annyi probléma van vele, hogy nem fordító portábilis.
-
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. -
dabadab
titán
"Pont nem latszik, mit csinal a programreszlet"
// count how many bits are set in num
Egyebkent pl. a quicksort meg egy csomo minden mas algoritmus sem arrol hires, hogy elso ranezesre latszik, hogy mit csinal.
"mert a shift es also bit szamolasanal se nem gyorsabb, se nem mellekhatas-mentesebb"
Fogadunk?
-
-
Karma
félisten
válasz
don_peter
#4483
üzenetére
Igen, pontosan erről írtam, hogy nem kéne így csinálni, ha nem muszáj. Márpedig desktop környezetben (szemben egy beágyazott rendszerrel) nem valószínű hogy ez fennállna.
A probléma a globális változókkal az, hogy a függvény újrafelhasználhatóságát és olvashatóságát is egyaránt rontja. Az előbbit azért, mert egy közös memóriaterületet piszkál amihez más függvény is hozzáfér és így elronthatják egymás dolgait. A másikat meg azért, mert a függvényen kívülre kerül az az adat, amivel dolgozik.
És végül azért is célszerű már most leszokni a globális változókról, hogy ne alakuljon ki rossz kódolási stílus mielőtt más nyelvekre mész tovább.
-
don_peter
senior tag
Tömb kezeléssel kapcsolatos:
Közben sikerült eljutnom odáig, hogy elolvassam a linkelt írásodat.
Most úgy oldottam meg segítséggel a dolgot, hogy egy függvénynek átadom a kellő paramétereket (float) és a feldolgozás (string-é alakítás) végén feltölt egy tomb-öt (amit a program elején "volatile unsigned char szamok[10]" változóként deklarálok) az eredménnyel.
Aztán ahol kell ott pedig kiíratom string-ként printf() %s megadásával.Az írásodban viszont arra hívod fel a figyelmet, hogy ne használjuk ezen megoldást.
Vagy nem jó értelmeztem? (globális változók)
Jó az elmélet vagy a globális változó miatt ez gondot okozhat nekem? -
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! -
buherton
őstag
Csak egy kis érdekesség. Állásinterjún szokták az embert b.szogatni rövd C-s kódokkal. Ha valaki azt kapná, hogy írjon egy olyan programot, ami megszámolja, hogy számban hány bit van, akkor vessétek elébe ezt:
unsigned int count;
unsigned int num;
num = 1234;
for(count = 0; num; count++)
{
num &= - 1;
}Nem tudom hol láttam, de fellelhető a neten.
-
-
buherton
őstag
válasz
dabadab
#4476
üzenetére
Most jött elő egy olyan probléma, amikor egy azon kód fut egy 8 bites architektúrán és PC-n is. Volt egy enum tömb, amit memset-el állítottak be valamilyen értékre. Viszont az enum egyik esetben 1 bájt a másik esetben 4 bájt, így ha nem nullát állítottak be, akkor jött a nem várt működés, mert a memset bájtokat állít és nem tömb elemet.
-
alapz@j
tag
A korábbi c vs. java témához engedjetek meg egy linket még: https://stackoverflow.com/questions/11227809/why-is-processing-a-sorted-array-faster-than-an-unsorted-array/11227902#11227902
Különös figyelemmel erre e részre: Intel Compiler 11 does something miraculous. It interchanges the two loops, thereby hoisting the unpredictable branch to the outer loop. So not only is it immune the mispredictions, it is also twice as fast as whatever VC++ and GCC can generate! In other words, ICC took advantage of the test-loop to defeat the benchmark... Szóval a konkrét gépi kódtól függetlenül is lehet jelentős sebességnövekedést elérni az adatok ügyes szervezésével.
Érdemes még a további kommenteket is elolvasni, pl. hogy a ternary operator-t mennyivel jobban fordítja a gcc, mint a sima if-then feltételes elágazást.
-
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). -
don_peter
senior tag
Kíváncsi vagyok a véleményetekre:
void float_to_str(float szam){
printf("Kezdő szám: %f\n", szam);
unsigned int i = 0, x = 0, tizedes = 0;
static char szamok[8];
long int intszam = 0;
if (szam-(int)szam > 0){ //egész vagy sem
//ha lebegőpontos
while(szam-(int)szam != 0){//amég nem egész
szam = szam * 10;
i++;
tizedes = i;
}
intszam = szam;
printf(" Felszorzott szám: %li\n Hányszor futott le: %i\n Tizedes: %i\n", intszam, i, tizedes);
i = 0;
while(intszam > 0){//addig osztunk amég nagyobb intszam mint nulla
szamok[i] = intszam % 10;
intszam = intszam / 10;
i++;
}
printf(" Szétszedve: ");
x = i; // x változóba töltjuk az i változót, hogy késöbb is felhasználható legyen az i értéke
while(i){
printf("%i,", szamok[i---1]);
}
printf("\n");
printf("Eredmény: ");
while(x){
if(x == tizedes)
printf(".");
printf("%i", szamok[x---1]);
}
printf("\n");
}else{
printf("Ez egy kerek szám, nincs művelet.\n");
}
}
Mai függvényen belül indítjuk:
float_to_str(12.34567);Eredménye:
Kezdő szám: 12.345670
Felszorzott szám: 12345669
Hányszor futott le: 6
Tizedes: 6
Szétszedve: 1,2,3,4,5,6,6,9,
Eredmény: 12.345669Véleményetek szerint jó és hatásos a megoldásom?
Az eredményből látszik mikor mit tesz a program.
Az elmélet az, hogy, ha beadok egy lebegőpontos számot akkor azt valamilyen megoldással string-é alakítsam, és átalakítás után újból kiírassam.
Hogy teljes legyen a kép ez azért szükséges a számomra mert a végeredményt nem kezelhetem "float" lebegőpontos számként mert az eszköz amin kiíratom az eredményt nem hajlandó a float típusokat megjeleníteni.
Nézzétek ezt a kódot úgy, hogy alig 3napja kezdtem el tanulni a C-t szóval nem ismerem behatóan a nyelvet. -
Karma
félisten
válasz
don_peter
#4467
üzenetére
Lebegőpontos számot hány tizedesjegyig szeretnél számolgatni? A definíció szerinti pontatlanságon túl ez is egy fontos szempont.
Továbbra is fenntartom az állításomat, hogy ez nem egy számítási, hanem egy karakterkezelési feladat. A tizes számrendszer emberi fogyasztásra alkalmas csak egyébként is. Jó szórakozást hozzá, én kiszálltam.
-
don_peter
senior tag
Ezen elven kezdtem el agyalni:
void float_to_str(float szam){
int number, mennyi = 0, i = 0, tizedes = 0, oszto_tomb[8];
if(szam < 10)
tizedes = 1;
else if(szam < 100)
tizedes = 2;
else if(szam < 1000)
tizedes = 3;
else if(szam < 10000)
tizedes = 4;
else
printf("Ez a szám már túl nagy.");
number = szam * 100000;
while(number != 0) {
oszto_tomb[i] = number % 10;
printf("%i, ", oszto_tomb[i]);
number = number / 10;
mennyi = i;
i++;
}
printf("\n");
for(i = mennyi; i >= 0; i--){
if(i == (mennyi+1)-tizedes)
printf("%i.", oszto_tomb[i]);
printf("%i", oszto_tomb[i]);
}
printf("\nHány karakter: %i\n", mennyi+1);
}
//kiíratása a main függvényen belül
float_to_str(12.34567);Ez nádjából jól működik amíg 10-nél nem kisebb a lebegőpontos szám amit beadok neki.
Így néz ki egy kimenet:
7, 6, 5, 4, 3, 2, 1,
12.234567
Hány karakter: 7
12.234567 (mondjuk valamiért itt 2db 2-es látszik pedig csak 1 van a sorozatban)
A lényeg látszik belőle, hogy mit is szeretnék.
Ez hogy lehet hatékonyabban megoldani? -
don_peter
senior tag
Értem és igazad is van, és ahogy te is írtad szigorúan számról van szó.
Most például azon agyalok, hogy mi van abban az esetben, ha mondjuk lebegőpontos számot akarok az előzőkben leírtak szerint szétszedni majd újból összerakni, hogy azt miként kell elvégezni.
Mondjuk van egy float szam = 13.45445667; számom akkor ezt, hogy bontom le egyesével és akár egy tömbbe is aztán meg újból összerakni.
Ennél már lehetne alkalmazni a string-es megoldást, sőt az lenne a legjobb.
Tehát egy lebegőpontos számot string-é alakítani..
Ez is megoldható egyébként?ui: ezt a számot mondjuk egy program eredménye képen kapnám, tehát nincs beviteli rész.
-
Karma
félisten
válasz
don_peter
#4463
üzenetére
Például úgy, hogy nem számként olvasod be a scanf-fel, hanem szövegként (pl. az fgets függvénnyel).
A feladathoz szokás adattípusokat választani, nem pedig hangulatból.
Azt mondjuk nem tudom, hogy ha valóban és szigorúan egy szám a bemeneti adat, akkor osztogatni éri meg jobban, vagy egyszer átkonvertálni stringbe és azon futtatni a ciklust. A paraszti eszem szerint a string, mert sokkal olvashatóbb, hogy mit csinálsz.
-
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.
-
don_peter
senior tag
sprintf-nél még nem járok.
Még csak a változó típusokat, függvényeket, ciklusokat és a tömböket olvastam végig.
Van még bőven mit olvasnom
550oldalas a könyv és még csak a 160. oldalnál járok, de szeretem a leírtakat gyakorlatban is kipróbálni és szeretném azok működését magam is megírni és megérteni.
Az nem kivitelezhető egyerűen, hogy megfordítás nélkül szétválasszuk a bevitt értéket? (egész számot)
Pl: 123456 = 1,2,3,4,5,6
Mindenképp a helyes út a vissza osztás és a maradék eltárolása és ezen folyamat újra és újra forgatása míg nem teljesen meg nem kapjuk egyesével a számokat? -
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.) -
don_peter
senior tag
Az eredeti példa programban így szedi szét a program.
Ez egy gyakorló feladat volt és azt gondoltam kicsit tovább és ilyen szárnycsapkodásként tanulok belőle.
Kérhetek egy olyan kódrészt tőled amely a következőket demonstrálja?
123456 (ezt a számot szedjük szét és egyesével vesszővel elválasztva írassuk ki)
Eközben számoljuk meg mennyi külön álló karaktert (vagy ha jobban tetszik számot) tartalmaz és ezt is irassük ki.
És a végén ismét rakjuk össze a számot 1egy egésszé.Ez így nézne ki lefutáskor:
123456
1, 2, 3, 4, 5, 6
Hány szám: 6
Újra össze rakva: 123456Köszi előre is a példa kódot.
-
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. -
-
don_peter
senior tag
válasz
Jester01
#4452
üzenetére
Thanks a segítséget:
for(i = mennyi; i >= 0; i--){
if(i == 0)
ossz += right_digit[i];
else
ossz = (ossz + right_digit[i]) * 10;
}ui: Köszi de őszintén szólva Karma bejegyzése inkább félrevezetett mint rá
Ezt ne vedd sértésnek Karma
Jester01-nek megy a pont
Köszi, most sokat tanultam... -
don_peter
senior tag
válasz
Jester01
#4448
üzenetére
Ehhez is ismerni kell a bevitt érték nagyságát nem?
"(((a*10)+b)*10+c)*10+d" mert ez összesen csak 4 változó értékét tudja felszorozni és összeadni.
Én most így oldottam meg:int number, right_digit[5], i = 0, mennyi = 0, ossz = 0;
printf("Adj meg egy számsort (1-100e közt): ");
scanf("%i", &number);
printf("Visszafelé: ");
while(number != 0) {
right_digit[i] = number % 10;
printf("%i, ",right_digit[i]);
number = number / 10;
mennyi = i;
i++;
}
printf("\n");
for(i = mennyi; i >= 0; i--){
if(i == 4)
ossz += right_digit[i] * 10000;
else if(i == 3)
ossz += right_digit[i] * 1000;
else if(i == 2)
ossz += right_digit[i] * 100;
else if(i == 1)
ossz += right_digit[i] * 10;
else if(i == 0)
ossz += right_digit[i];
else
printf("Maximum 99999-et lehet megadni!\n");
}
printf("Hány karakter: %i",mennyi+1);
printf("\nÖssz érték: %i\n", ossz);Kimenete:
Adj meg egy számsort (1-100e közt): 344
Visszafelé: 4, 4, 3,
Hány karakter: 3
Össz érték: 344 -
don_peter
senior tag
válasz
Jester01
#4446
üzenetére
A legegyszerűbb dolgok a leg-kézenfekvőbbek.
Bonyolultabban akartam megoldani és ez volt a hiba.
Itt meg már egy saját kis függvény meg eldönti, a számok számából, hogy mennyivel kell elkezdeni szorozni és utána már mehet vissza felé szépen a dolog.
Picit még parázok ettől a nyelvtől.Az strlen -re akkor gondolom érdemes egy saját rutint írni bár gondolom majd az is lassú lesz.
A string-ek esetében még mondjuk jó is, de ha számokat akarok megszámolni már parásabb a helyzet.
Vagy erre meg jó ez a megfordító dolog, csak a végeredmény majd a szétválasztott számok száma lesz és meg is van számolva -
Jester01
veterán
válasz
don_peter
#4445
üzenetére
C-ben is van strlen de csak akkor működik ha van egy lezáró 0 byte a karakterek után. Továbbá ez minden alkalommal végignézi a stringet, szóval nem valami gyors. Javasolt kézzel nyilvántartani a tömbbe rakott karakterek számát, ahogy te is tetted.
A másik probléma az gondolom a kávé hiányra vezethető vissza, mert óvodás matematika
Ugye ha van egy abcd szám annak az értéke a*1000+b*100+c*10+d. Ennyi segítség már elég hozzá? -
don_peter
senior tag
válasz
don_peter
#4444
üzenetére
Ezzel a tömbös megoldással megoldottam, de itt még nem kellene járnom szóval egyszerűbb megoldás létezhet a dologra?
És itt még felmerül a kérdés, hogy tudom megnézni egy adott változóban mennyi karakter vagy számjegy van.
Szóval a = 123;
Akkor ennek a karakter hossza 3db.
Ezt PHP-ben strlen() függvénnyel szépen le lehet kérni.
Itt is van ilyesmi?
Mert a tömbömnek meg kellene adni mekkora legyen és így automatizált lehetne a dolog.
Bár lehet rosszúl gondolkodom, de PHP-nél ez kézenfekvő volt.int number, right_digit[5], i = 0, mennyi = 0;
printf("Adj meg egy számsort: ");
scanf("%i", &number);
while(number != 0) {
right_digit[i] = number % 10;
printf("%i, ",right_digit[i]);
number = number / 10;
mennyi = i;
i++;
}
printf("\n");
for(i=mennyi; i>=0; i--){
printf("%i",right_digit[i]);
}
printf("\n");Illetve a 2. pontban lévő kérdésemet még mindig nem tudtam megoldani.
pl.: 1 2 3 4 = 1234 -
don_peter
senior tag
válasz
alapz@j
#4443
üzenetére
Srácok ez ugyan nem életbe vágó, de nekem még is érdekes lehet.
Van egy kódom ez ügye azt csinálja, hogy amit beviszel pozitív egész számokat azokat megfórdítva írja egymás mellé.
Ime:int number, right_digit;
printf("Adj meg egy számsort: ");
scanf("%i", &number);
while(number != 0) {
right_digit = number % 10;
printf("%i, ",right_digit);
number = number / 10;
}
printf("\n");2 dolog érdekel: (most kezdtem el a dolgot szóval nem vagyok még jártas a témában)
1. hogyan tudom azt megcsinálni a legegyszerűbben, hogy a számokat ugyan abban a sorrendben írja ki egyesével ahogyan azt én megadom.2. ezt teljesen külön: hogyan tudnám a szétszedett láncot újra egyesíteni úgy hogy azt egy egésznek vegye a rendszer? (pl.: 1 2 3 = 123)
Köszi előre is a segítséget. -
alapz@j
tag
válasz
buherton
#4441
üzenetére
> Hogy a fenébe van ideje futás közben újra fordítani?
Nem tudom, de azt csinálja és láthatóan jó eredménnyel. Egyébként abban is sok igazság van, amit te írtál. Hiába dolgoz fel egy százmilliós tömböt gyorsabban a Java-ban írt program, mint a C-ben írt, a felhasználók jelentős részének - teljesen természetes módon - az marad majd meg a Java programból, hogy lassan indul el, nem reszponzív a gui, idegenek a swing komponensek, stb.
> Honnan tudja futás közben, hogy hogyan lehet optimalizáltabb?
Erre van utalás a linkelt cikkben, igaz, nem a Java, hanem a CPU-k kapcsán. El tudom képzelni, hogy a VM a byte kód elemzésekor csinál valamilyen branch prediction-t vagy mondjuk előre lefordít mindkét lehetőségre egy natív kódrészeletet, amivel kiküszöböli a lokális ugrásokat.
-
dabadab
titán
válasz
buherton
#4441
üzenetére
"C a beágyazott rendszerek egyeduralkodó nyelve."
Mondjuk en foleg nagyobbfajta rendszereket bizergaltam (nem kis dobozba, hanem nagyobbfajta szekrenyekbe voltak beagyazva
), de ott a regebbi cuccokon CHILL, ujabbakon meg C++, sot, Java volt."Honnan tudja futás közben, hogy hogyan lehet optimalizáltabb?"
Az ilyen dinamikus cuccok futas kozben is profilozzak a kodok es folyamatosan a bejovo adatokhoz tudjak optimalizalni, a Transmeta CPU-ja is ezt csinalta (mondjuk hogy most a konkret esetben tenyleg ujraforditja-e es ha igen, akkor mire, azt passzolom).
-
buherton
őstag
PC-n máshogy jön ki a dolog, de azért ne általánosítsunk. Qt-ban olyan kódot írhatsz ami GUI-t kezel és ugyanaz a függvény hívás három oprendszeren is működik. Csak külön le kell fordítani mind a háromra. Viszont beágyazott rendszerben nagyon kényelmes tud lenni, hogy PC-n kezdem el a fejlesztést, ahol ugye egyszerűbb debuggolni a C kódot és a memóriá elírásokat is nagyság rendekkel könnyebb megtalálni. Közre játszik ugye az is, hogy az elírásról az IC nem dob fel neked egy ablakot, hogy hoppá
. Amikor az ember túl van a nehezén csak áthúzza a másik projektbe és mehet a fejlesztés tovább a hardveren mindenféle változtatás nélkül. Ez a platform függetlenség. Persze ehhez mindkét helyen meg kell lennie a megfelelő interfész függvényeknek.Vuze-val kapcsolatban rosszul emlékeztem akkor, de ettől függetlenül panaszkodnak rá, hogy jobban eszi a gépet, mint a többi torrent kliens.
(#4421) alapz@j: Szó mi szó nem szaggat nálam se, de a ventit nagyon pörgeti az fix.
(#4420) dabadab: C a beágyazott rendszerek egyeduralkodó nyelve. Ha újabb kocsid van, akkor nagyjából 10 millió sornyi C kód vigyáz rád, illetve szórakoztat téged
. Én személy szerint nem tanultam mást csak C-t. Ön szorgalomból tanultam meg a PERL-t, C++-t, egy kicsit a bash-t.(#4437) alapz@j: Hogy a fenébe van ideje futás közben újra fordítani? Pontosítok. Honnan tudja futás közben, hogy hogyan lehet optimalizáltabb? Hogy tud még ennél is optimalizáltabb kódot fordítani?
-
-
Jester01
veterán
Hmm, a JIT kód nem tűnik túl okosnak, nem tudom mitől gyors:
0x00007fe2237a679a: movsd 0x10(%rbx,%rbp,8),%xmm0 ;*daload
; - Test::summUp@12 (line 11)
0x00007fe2237a67a0: movsd 0x8(%rsp),%xmm1
0x00007fe2237a67a6: addsd %xmm0,%xmm1
0x00007fe2237a67aa: inc %ebp
0x00007fe2237a67ac: ucomisd 0x20c(%rip),%xmm0 # 0x00007fe2237a69c0
; {section_word}
0x00007fe2237a67b4: movsd 0x8(%rsp),%xmm0
0x00007fe2237a67ba: ja 0x00007fe2237a67c0
0x00007fe2237a67bc: movapd %xmm0,%xmm1 ;*iinc
; - Test::summUp@26 (line 10)
0x00007fe2237a67c0: cmp %r11d,%ebp
0x00007fe2237a67c3: jge 0x00007fe2237a67cd
0x00007fe2237a67c5: movsd %xmm1,0x8(%rsp)
0x00007fe2237a67cb: jmp 0x00007fe2237a679a -
Jester01
veterán
válasz
dabadab
#4424
üzenetére
Ez tényleg elég meglepő, de én is tudtam reprodukálni.
Elsőre rávágtam, hogy a java biztos elágazás-mentes kódot generál, de ha kicsit átírtam, hogy a gcc-nek is feltűnjön ez a lehetőség attól ugyan gyorsabb lett de még nem java szintű. Sőt, még durvább optimalizációval egy iterációban 8 elemet ad össze és még így is lassabb.A random tömböt egyébként kicseréltem, hogy mind a két implementáció azonos számokkal dolgozzon (és mindig ugyanazokkal).
-
don_peter
senior tag
Srácok OSX alatt szeretnék C-ben programozni illetve tanulni a nyelvet.
Tudnátok ajánlani fejlesztői környezetet amit könnyű használni és fordít is?
Drag en Drop fejlesztők nem érdekelnek.
Xcode és a Code Wariors-t nézegetem, de nem tudom melyik verziót érdemes beszereznem belőlük.
Kérném segítségeteket, hogy jól válasszak.
Stephen G. Kochan könyvéből szeretnék lépésről lépésre tanulni és a feladatokat elvégezni.
Köszi előre is. -
dabadab
titán
válasz
alapz@j
#4423
üzenetére
Amit nem ertek, az az, hogy hogy a csudaba lesz a java gyorsabb. Megneztem magamnal is, a konkret loop, amit mer, arra ezt a kodot generalja a gcc:
.L14:
movsd 0(%rbp,%rdx), %xmm1
ucomisd %xmm2, %xmm1
jbe .L11
addsd %xmm1, %xmm0
.L11:
addq $8, %rdx
cmpq $800000000, %rdx
jne .L14Hogy ennel mi lehet gyorsabb, arrol fogalmam sincs, marpedig a java (legalabbis a rendezetlen tombnel) tenyleg gyorsabb egy jo 7-8%-kal.
-
alapz@j
tag
A java vs. c témakörhöz egy kis nem-annyira-offtopic szösszenet:
http://tifyty.wordpress.com/2012/07/15/es-a-jit-optimalizal-de-meg-mennyire/ -
alapz@j
tag
válasz
buherton
#4416
üzenetére
A Minecraft teljesen alap Java-OpenGL bridge-t használ, azaz a megjelenítést a hardver végzi, ha simán portolnák C/C++-ra, nem gyorsulna érdemben - az értékelhető gyorsuláshoz az egész engine-t újra kellene írni. Hozzáteszem, igen régi gép kell már ahhoz, hogy a Minecraft gondban legyen, utoljára talán a csajom core2duo+intel hd kombós gépén láttam szaggatni...
-
dabadab
titán
válasz
TheProb
#4419
üzenetére
A C az gyakorlatilag platformfuggetlen assembler, ami tamogat strukturalt programozast is, manapsag mar leginkabb csak par specialis helyen hasznaljak.
A C++ ennek eggyel jobban elvont valtozata, ami tamogatja a nyolcvanas meg kilencvenes evek, sot, a 2011-es C++11 szabvany (amit olyan nagyon sok helyen meg nem hasznalnak) egyre inkabb a XXI. sz. elejenek mindenfele dolgait (objektumorientalt programozas, template-ek, ill. parhuzamos programozas, stb), de meg mindig nativ kodot futtat. Nekem ugy tunik, hogy manapsag ez a fo nyelv, ha nagy projekteket csinalnak.
A C# meg tulajdonkeppen a Java Microsoft-fele valtozata, meg egy fokkal elvontabb, virtualis gepek programozasara szantak es persze a Microsoft-vilagon kivul nem nagyon mukodik.
-
-
Karma
félisten
válasz
buherton
#4416
üzenetére
A legtöbb nyelv platformfüggetlen. A tényleges munkavégzéshez bevonzott frameworkök meg nem (merthát lehet több féléven át helloworldözni STL-el, de a valóságban azért hálózat, adatbázis, IPC, meg ki tudja mi jön szembe). És máris nem olyan fontos szempont.
Meg ugye a Linux desktop kit érdekel
</troll>A Vuze mindig Java-alapú volt szerintem, még Azureus korában is. Az OpenOffice meg főleg natív, Java kiegészítésekkel.
-
buherton
őstag
válasz
alapz@j
#4412
üzenetére
Nem szabvány szerinti függvény.Nálunk a C99 használatos.(#4413) alapz@j: A .NET alatt szinte mindeki a C#-ra gondol függetlenül attól, hogy nem csak abban lehet programozni.
(#4414) alapz@j: A C++ ahogy mondtad platform független, az hogy te mennyi függőséget viszel bele az már a te dolgod. Nem mellesleg a platform függetlenség alatt nem csak az OS-ek közötti átjárásra gondoltam hanem architektúra és rendszer váltásra is.
A Java pedig sajnos erőforrás igényes. Nézz meg egy Vuze-t (amióta átírták Java-ra azóta megy a panaszkodás, hogy nagy megterheli a gépet) vagy ott a Minecraft. Amilyen egyszerű a grafikája olyannyira erőforrás zabáló. A LibreOffice-ban sem véletlenül írják át folyamatosan a Java kódot C++-ra.
-
alapz@j
tag
válasz
buherton
#4409
üzenetére
Ööö, ööö. A Java nem feltétlenül lassú és nem is foglal feltétlenül sok memóriát. 2000-ben ez így volt, ma már nincs - és az Oracle-höz sem vagy kötve mert van még egy tucatnyi másik implementáció. Az oracle-ös HotSpot csak a reference. A C++ platformfüggetlensége pedig megint csak kérdőjeles, mert a cout << "Hello World" tuti működik minden rendszeren, de ha elkezded benne meghívni az OS API függvényeit (mert egy natív GUI-t építesz), akkor máris ugrott a függetlenség.
-
buherton
őstag
válasz
TheProb
#4408
üzenetére
Amit írtál az mind OOP nyelv. Ha android, akkor Java. Ha windows phone, akkor .net, ha iPhone akkor objective C. A Java mellett szól, hogy mindenen fut, amin van Java virtuális gép, de lassú és sok memóriát igényel, és az Oracle-höz vagy kötve. A C++-ban teljes szabadság uralkodik, mert sem céghez, sem oprendszerhez, sem platformhoz nem vagy kötve, és annyira nem vészes. A .net alatt teljes zártság és kötöttség van. Viszont ha windowson kívül másra nem akarsz fejleszteni, akkor talán még ez a legjobb választás.
-
TheProb
veterán
válasz
buherton
#4407
üzenetére
értem, ez kis könnyedséget adott most, remélem a java akkor jobban fog tetszeni.
Egyébként ti milyen nyelveket ajánlanátok? Mit érdemes tanulni? Tudom, hogy ez megint csak 1 nagyon szubjektív dolog, de pl. mi a véleményetek a c++ (bár úgy tudom ez nagyon expert programozóknak ajánlott csak), vagy a .net-ről?
Azt tudom, hogy a java-t azért mondják relatív könnyűnek, mert OOP nyelv, de pl a .Net-ről nemtok semmit, meg a c++-ról is csak annyit, mint amit előbb leírtam (ergó semmit) -
buherton
őstag
Mondjuk valahol igaz. Azért én is törekedni szoktam, hogy a warningok ki legyenek szedve a kódból.
De pl. a void main(void) warninggal nem szoktam foglalkozni, vagy a castos figyelmeztetésekkel.(#4404) TheProb: Ha Androiddal fogsz foglakozni, akkor itt elég csak a túlélésért küzdeni. A C és Java ég és föld. Amit most csinálsz példát az Java-ban majd sokkal, de sokkal egyszerűbb és kényelmesebb lesz.
(#4406) TheProb: Függ attól, hogy mire programozol és hogy mit. Általában elmondható, hogy a Java egyszerűbb, és kényelmesebb. Rengeteg minden készen kapsz, amit a C alatt neked kell lekódolni.
-
-
TheProb
veterán
válasz
buherton
#4402
üzenetére
Valami rémlik ezzel a lépkedős debuggal kapcsolatban, órán is csináltuk már párszor. fel lehet venni debug közben egyes változókat is külön, hogy ellenőrizzük mi van benne, stb.
Az a gond a másik fejlesztő környezettel, hogy vizsgán is VS-t kell használni, valamint ezzel is javítanak. VS nem GCC-t használ hanem valami jóval "kötekedősebb" compilert... Én eddig CodeBlocks-ban tanultam/programoztam, ami nekem sokkal jobban tetszett, de hát muszáj VS-t használni...
Egyébként, majd androiddal szeretnék foglalkozni, bár egyik ismerősöm aki várja a C-t, java-t, stb. azt mondta, hogy nem egy túlzottan átlátható nyelv... és ha nekem már/még a C-vel is gondjaim vannak akkor nemtom, hogy fog menni... Persze remélem megfogom majd rendesen érteni az egész program írási "létformát", sajnos 1 félév után még szinte teljesen tudtatlan vagyok (mint ahogy az látszik is
)(#4403) Karma: Megfogom majd nézni akkor azt a ..._s verziót
-
Karma
félisten
válasz
TheProb
#4401
üzenetére
Az strcat_s azért jó, mert odafigyel arra, hogy a célterületből véletlenül se szaladjon ki. Ha egy négy hosszú blokkba beleírnád azt, hogy "MCCXXXIV", akkor az strcat kifut és felrobban, a safe változat beírja hogy "MCC" és csöndben megy tovább.
A debuggert használod most is, csak tud sok hasznos dolgot még
Például a programsoraid mellett bal oldalt kattintasz, breakpointot raksz be, aminél a program megáll és lépésenként követheted a menetét.buherton: Tényleg előfordulhatnak felesleges warningok, de ez egyáltalán nem az! Konkrétan elkerülhető lett volna a crash. Az strcat_s tényleg nem szabványos, de az strncat igen, ami szintén egy biztonságos alternatíva más platformon.
Meg úgy egyébként a warningok azért vannak, mert valamit rosszul csinál az ember. Tanulásnál különösen fontos megérteni hogy mit...
-
buherton
őstag
válasz
TheProb
#4401
üzenetére
Fel kell venni azt a bizonyos szemüveget, amivel a fontos és jelentéktelen warningokat ki lehet válogatni. Szerintem a strcat_s egy beépített függvény a VS-nek, így inkább javaslat lesz, mint valós warning. A standradban egészen biztosan nincs ilyen. Nem kell azzal foglalkozni. Függően attól, hogy merre szeretnél tovább tanulni én javasolnám a mingw (GCC) + eclipse kombót. A VS nagyon lekorlátoz. Gyakorlatilag csak PC-re és csak Windowsra tudsz fejleszteni. GCC + Eclipse-szel gyakorlatilag minden platformra tudsz fejleszteni.
IDE - Integrated Development Environment, a debuggerrel pedig lépkedni tudsz a kódban futás közben. Meg tudod nézni, hogy az adott változónak mi az értéke. Meg is lehet változtatni. Break pointokkal meg lehet állítani a program futását. Nagyon hasznos ha algoritmusbeli hibát szeretnél kidebbugolni.
-
Ugye ha van egy abcd szám annak az értéke a*1000+b*100+c*10+d. Ennyi segítség már elég hozzá?
Ú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!
- Dell Latitude 5450 Intel Core Ultra 5 135U 4nm 32GB DDR5 érintőképernyős laptop Dell gari 2027.09.hó
- PlayStation 4/5 kontroller analóg cseréje HALL TMR érzékelősre, 1 év garancia!!! Nincs többé drift!!
- PlayStation 5/4 kontroller analóg cseréje HALL TMR érzékelősre, 1 év garancia!!! Nincs többé drift!!
- XBOX ONE/Series kontroller analóg cseréje HALL TMR érzékelősre, 1 év garancia!!! Nincs többé drift!!
- XBOX Series S 512GB, 6 hó garanciával Bp-i üzletből eladó!
- Szinte új, minőségi, állítható ritkítóolló
- Apple iPhone 14 128GB, Kártyafüggetlen, 1 Év Garanciával
- Apple iPhone 16 128GB Kártyafüggetlen 1Év Garanciával
- ÁRGARANCIA! Épített KomPhone i5 12400F 16/32/64GB RAM RTX 3060 12GB GAMER PC termékbeszámítással
- BESZÁMÍTÁS! Gigabyte B760M i5 14600KF 64GB DDR4 512GB SSD RTX 3080 10GB Corsair 4000D Airflow 1000W
Állásajánlatok
Cég: Promenade Publishing House Kft.
Város: Budapest
Cég: PCMENTOR SZERVIZ KFT.
Város: Budapest