- Kormányok / autós szimulátorok topikja
- TCL LCD és LED TV-k
- Vezeték nélküli fülhallgatók
- Bluetooth hangszórók
- Home server / házi szerver építése
- Veszélyben az adataid? Gond van a WD népszerű HDD-ivel
- AMD K6-III, és minden ami RETRO - Oldschool tuning
- Hogy mi van? A TikTok lett az Xbox ellenfele?
- Milyen házat vegyek?
- 8 kHz-es pollingot ígérő, analóg Yunzii klaviatúra a megfizethető árszinten
Új hozzászólás Aktív témák
-
Wyll
őstag
válasz
sztanozs
#4598
üzenetére
Mire kell az fv() ?? -- Jaa, hogy az az én fv()-m?
Szerintem nem jó ez a megoldás. Mert pl. nem lép ki ha az első lépésben 2-es a visszatérési érték.Nem használják egymás eredményét.
Annyiszor kéri be az értékeket, ahányszor a visszatérési érték függvényében lefutnak a függvények.
Háromfajta visszatérési érték van:
0 -> ok, továbbmehetünk
1 -> visszalépés az előző állapotba
2 -> megszakítjuk a folyamatot -
Asszem valahogy így (remélem jól értettem az ábrát):
while(1) {
a = inputa();
b = inputb();
if (fv(a)) break;
fb = fv(b);
if (fb == 0 || fb == 2) break;
}Vagy az értékeket csak egyszer kéri be? De akkor ha fv(a) == 0 és fv(b) = 1 akkor végtelen ciklus lesz...
Vagy egymás eredményét használják fel?
a = input >> b = fv(a) >> a = fv(b)? -
Wyll
őstag
Volna egy apró feladatom, aki szereti az ilyen kis apró agytornákat - na nem mintha olyan nehéz volna, csak mégis. Arra volnék kíváncsi, ki hogyan oldaná meg az alábbi bekérési folyamatot:
Igazából a két kocka a program egy-egy állapotát jelzi, amikor ugyanazt a függvényt egyik vagy másik (de mindig ugyanazon egyik vagy másik) paraméterrel kell meghívni, a nyilak pedig hogy a visszatérési érték függvényében mit kell csinálni a következő lépésben.
A folyamat a baloldali állapotban kell hogy induljon.
Ha mindkétszer sikerrel lefutott (0, 0) akkor készen vagyunk,
2es eredmény után mindkét esetben gondolkodás nélkül ki kell lépnünk a folyamatból,
1es eredmény után alapvetően "visszalépünk", de ez az első esetben szintén kilépést jelent. -
Wyll
őstag
Sziasztok!
? :
argumentumai lehetnek változók is, ugye? (Expression, azaz kifejezés kell legyen az argumentum, és ahogy az a + b egy kifejezés, úgy gondolom a sima a is egy kifejezés).
Namost, függvényhívásnál paraméterként átadott változót meg lehet-e adni ilyen módon? Tehát pl. működik-e az, hogy
switch ( fuggveny(a, b, i == 1 ? c : d) ) {
/*switch body*/
}Gondolom hogy működik, csak szokatlan.
-
alapz@j
tag
Fél szemmel figyelemmel követem az OpenBSD-s srácok OpenSSL újraíró projektjét (LibreSSL) és annak kommentárjait a Opensslrampage.org -on. Az egyik legutóbbi gyöngyszemük az OpenSSL kódból:
strncpy(dest, src, strlen(src))
Ez azért komoly kérdéseket vet fel a kód minőségét illetően...
-
TheProb
veterán
A rekurzió nem ide kéne, hanem még lentebb írtam, hogy van egy beadandó, amiben c-ben kell kb 1 excel-t megírni... Annak kell 4 fv-t kezelnie (köztük ezt) és egyes cellákban lehetnek rekurzív hívások. pl. az egyik cellában az egyik fv generált 1 számot 100 és 500 között, majd ezt a számot adjuk meg a római számmá alakító fv.-nek
-
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
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. -
TheProb
veterán
hát az n==1-nél csak strcat van.
a memória foglalásnál tudom, hogy az sima char, már kijavítottam, csak úgy néz ki az egyel régebbi verziót sikerült bemásolnom.(#4582): de eddig nem volt baj a tömbök ilyen jellegű megoldásával, futott is rendesen, meg csak az egyes helyiértéknél van gáz. +másnál is láttam már ilyesmi megoldást
-
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
#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. -
TheProb
veterán
Sziasztok!
Segítenétek nekem? Itt ez a kód ami arabból csinál római számokat, alapból úgy írtam meg, hogy sztringként tér vissza és csa 1 int változót kell neki megadni, de a feladat amibe szükségem van rá, úgy köveleti meg ahogy most van. A gondom az, hogy amíg az előbb említett verzióban volt akkor tökéletesen működött, viszont az átírt verzióval valami gond van, mert ha az egyesek helyi értékén 0tól különböző szám van akkor csak memória szemetet ír ki...
Pl. ha 960-at akarok átváltani akkor minden oké, de ha 969-et, 58-at vagy 3-at akkor mindig az előbb említett jelenség jön elő és nem jövök rá mi a gond. -
don_peter
senior tag
válasz
dabadab
#4578
üzenetére
Ez akkor most vissza tér egy char típusú karakterrel ami 1-16-ig van, gombnyomástól függően.
Ez eddig szép és jó. Mellesleg köszönöm, hogy tisztába raktad a dolgot és leegyszerűsítetted, sokat fogok belőle tanulni.
A fő kérdés viszont az, hogy miként kivitelezhető az, hogy mint a telefonnál alfanumerikus módon is írhassak?
Tehát van egy 4x4-es mátrix nyomó gombsorom, az rá van csatlakoztatva a mikrovezérlőmre és szépen, ha megnyomom valamelyik gombot akkor 1-től 16-ig vissza adja nekem a benyomott gomb értékét.
4x4 keypad
Ezt nem tudom tovább gondolni, hogy miként lehetne megoldani, hogy egy-egy gomb többszöri megnyomásánál már alfanumerikus értékként a gombonkénti eltárolt 3 betű egyikét adja vissza.
Arra gondoltam, hogy valami ciklusban ciklust kellene futtatni és mivel egy gombot megnyomok és várakoztatnom kellene legalább 1-2mp-et, és vizsgálnom, hogy van e ugyan azon a gombon közvetlen, további nyomás és az szerint váltani a betűket, hogy hány további nyomás történik.Legalább is erre felé gondolkodom, persze ez lehet nem jó irány.
Gyakorlatilag mint a telefon gombsora úgy működne a dolog annyi kivétellel, hogy nem lenne annyi karakter.
Csak az angol nagy betűs A-Z-ig és 0-9-ig számok kellenek.
Illetve egy BACK és SPACE gomb, hogy vissza törölhető és léptethető legyen a dolog.
Ez természetesen csak a gombsor egy részét foglalná le ami 4sorból és 3oszlopból állna.
A 4. oszlop 4sora külön funkció gombok lennének.
Szóval ezen a dolgon rágom magam már lassan 1 hete, de túlnő rajtam ez a globális gondolkodás.
Tudsz ebben segíteni?
Ha csak elméletben azt is megköszönöm.
Természetesen az eddig megírt és leegyszerűsített kódot kellene kiegészíteni ezzel a nem kis résszel
Előre is köszi a segítséget. (Ha valamit nem világosan írtam, csak kérdezz bele bátran) -
válasz
don_peter
#4577
üzenetére
Ja, igen, get_key() helyett konzekvensen getchar()-t irtam, felig mar autopiloton volt az agyam
""PORT_B4" egyenlő a következővel : PORTBbits.RB4"
Ja, akkor az egy bitfield lesz, azon meg meg sokkal egyszerubb vegigmenni, tomb se kell hozza:
#define SOROK_SZAMA 4
#define NO_KEY 0
#define FIRST_ROW_BIT_POSITION 4
#define FIRST_COL_BIT_POSITION 4
#define NO_OF_COLS 4
int oszlopok[] = { PORT_B4, PORT_B5, PORT_B6, PORT_B7 };
unsigned char get_key()
{
unsigned int i, k=0;
for( i=0; i < SOROK_SZAMA ; i++ )
{
SOROK = (1 >> ( FIRST_ROW_BIT_POSITION + i ) ); //Léptetjük a sorok szintjét
for ( j = FIRST_COL_BIT_POSITION ; j < FIRST_COL_BIT_POSITION + NO_OF_COLS ; j++ )
{
k++;
if( PORTBbits & (1 << j) )
{
while( PORTBbits & (1 << j) ); //Várakozunk a gomb felengedéséig
return k;
}
}
}
return NO_KEY;
}"Ha igen akkor ő nem a bit állással kell vissza jöjjön hanem a beolvasott karakterrel ami 1,2,3...16-ig."
Igen, pont ezert mondtam, hogy ott nem jo az, hogy azt adod vissza, hogy ALACSONY, mert az nem karakter
"Ez egy végtelen ciklus nem?"
De, ez az, errol irtam, hogy ez nem szamit, mert a k-t ezen belul inicializaljuk.
-
don_peter
senior tag
válasz
dabadab
#4574
üzenetére
Az a baj, hogy alig másfél hónapja kezdtem el a C-ét és a C18-at vagy is a PIC programozást egyszerre így sajnos nem tudok még rendesen érthetően megfogalmazni a kérdéseimet.
"SOROK = (1 >> ( FIRST_ROW_BIT_POSITION + i ) );"
Gyakorlatilag, ha két >> jelet teszünk az azt jelenti, hogy a 2 hatványával léptetjük a változó értékét a megadott irányban? (Ha igen akkor már is tanultam ismét valamit, vagy is tanultam már csak nem értettem meg ezek szerint)"int oszlopok[] = { PORT_B4, PORT_B5, PORT_B6, PORT_B7 };"
Hogy ez is tiszta legyen:
"PORT_B4" egyenlő a következővel : PORTBbits.RB4
Gyakorlatilag ez egy (port) regiszter mellyel a chip egy adott porton adott láb állapotát tudjuk lekérdezni, hogy az 1 vagy 0.
Ha 1 akkor annak állapota magas szintű, értelemszerűen a 0 = alacsony szinttel.
A portok nekem egy header állományban külön definiálva vannak, pl. így:
#define PORT_B4 PORTBbits.RB4"#define NO_KEY 0"
Teljesen igazad van.
Jobb rászokni az olvasható kód írásra...Ezt a részt nem igazán értem: "Viszont a getchar() egyaltalan nem egy bit allasat adja vissza, hanem egy karakterkodot, ami logikailag abszolút más dolog."
Vagy itt elírás történt és valójában getchar() az get_key() akart lenni?
Ha igen akkor ő nem a bit állással kell vissza jöjjön hanem a beolvasott karakterrel ami 1,2,3...16-ig."A ciklus végtelen pergésben van"
while(1){
bill_ertek = get_key();
Delay10TCYx(10);
}//while()
Ez egy végtelen ciklus nem?
Ebben minden ciklusnál újratöltődik a bill_ertek változó még ha egyelőre nem is jól van megadva."Ha arra gondoltál, hogy a getchar()-t kívülről végtelen ciklusban hívod, az meg nem számít, mert azzal kezdődik, hogy lenullázod a k-t"
Feltételezem, hogy itt is get_key()-re gondolsz.
Igen igazad van mert ha vége a ciklusnak akkor az újra meghívásnál nullázódik alapból is a k.
Próbálkozom erősen, de kellenek a szakik tanácsai és gondos szemei -
válasz
don_peter
#4570
üzenetére
[ disclaimer: elso komoly programozasi dolgaim C64-en, assemblerben voltak, aztan utana modernebb mikrokontrollerekhez is volt szerencsem, szoval ismerem ezt a vilagot
]"#define FIRST_ROW_BIT_POSITION 4"
Így gyakorlatilag csak egy értéket adunk FIRST_ROW_BIT_POSITION nak és nem tudjuk később léptetni a mikrocsip lábait.De. Azert adunk hozza i-t. Vegyuk eszre, hogy a
SOROK = (1 >> ( FIRST_ROW_BIT_POSITION + i ) );
ugyanaz, mint a
SOROK = ( ( 1 >> FIRST_ROW_BIT_POSITION ) >> i ) );
ami meg jelen esetben nem mas, mint
SOROK = ( 0x08 >> i ) );
(Mondjuk elrontottam, mert FIRST_ROW_BIT_POSITION helyes erteke 3, nem 4)
"int oszlopok[] = { PORT_B4, PORT_B5, PORT_B6, PORT_B7 };"
Ezt ugyan nem próbáltam még ilyen formában, de van egy sejtésem, hogy nem jó mivel értéknét adjuk át a az egyes portok egyes lábait.Nem volt teljesen egyertelmu, hogy ezek micsodak, de ha memory mapped portok, akkor annyi valtozik, hogy nem int, hanem char * lesz az oszlopok[] tipusa.
"#define NO_KEY 0"
Gyakorlatilag ugyan az mint az én
"#define ALACSONY 0" definícióm.Legfeljebb a fordito szempontjabol, de a kodot hasznalo programozok szempontjabol egyaltalan nem.
Ugyanis ott az ALACSONY jol lathatoan a MAGAS parja, amit arra hasznalsz, hogy megvizsgald, hogy valamelyik bit hogyan all.
Viszont a getchar() egyaltalan nem egy bit allasat adja vissza, hanem egy karakterkodot, ami logikailag abszolut mas dolog."A ciklus végtelen pergésben van"
Nincs abban. Az eredeti kododban egyetlen ciklus van, ami pontosan negyszer fut le.
Ha arra gondoltal, hogy a getchar()-t kivulrol vegtelen ciklusban hivod, az meg nem szamit, mert azzal kezdodik, hogy lenullazod a k-t, vagyis nem tud 16 fole noni az erteke (es teljesen feleslegesen nullazod, mert auto valtozokent a stacken van az erteke, a kovetkezo hivasig nem orzodik meg - persze csinalhatnal belole staticet, de annak meg semmi ertelme nem lenne, mert nincs ra szukseged)."Egyszóval, ha sima C programnak tekintjük akkor tökéletes a példád, de sajnos itt figyelembe kell venni, hogy mikrokontrollert programozunk fel illetve a lábak szintjeit ellenőriztük."
Ilyen szempontbol ez tok sima C program, tenyleg nincs benne semmi extra. Persze, embedded cuccoknal lehetnek extra kovetelmenyek (pl. hogy ROM-ot lehessen belole forditani, vagyis pl. a konstans tomboket nem lehetne koddal inicializalni, csak statikus ertekekkel), akkor az hozhatna par dolgot, de igazabol az is sima C. A mikrokontroller-programozas tenyleg nem az a nagy varazslat
-
don_peter
senior tag
válasz
dabadab
#4569
üzenetére
Köszönöm a kiigazítást.
Gondolom én voltam félreérthető az első bejegyzésemben."#define FIRST_ROW_BIT_POSITION 4"
Így gyakorlatilag csak egy értéket adunk FIRST_ROW_BIT_POSITION nak és nem tudjuk később léptetni a mikrocsip lábait.
Tehát ez "SOROK = (1 >> ( FIRST_ROW_BIT_POSITION + i ) ); " helyett az kell amit eredetileg is írtam.
SOROK = (0x08>>i); Ezzel gyakorlatilag a mikrocsip B portjának lábaira adunk magas szintet."int oszlopok[] = { PORT_B4, PORT_B5, PORT_B6, PORT_B7 };"
Ezt ugyan nem próbáltam még ilyen formában, de van egy sejtésem, hogy nem jó mivel értéknét adjuk át a az egyes portok egyes lábait.
Bár elképzelhető, hogy ha minden ciklusba adom át a tömbnek az értékeket akkor elvileg működhet is."#define NO_KEY 0"
Gyakorlatilag ugyan az mint az én
"#define ALACSONY 0" definícióm."A k-t állítgató résznek semmi értelme"
A ciklus végtelen pergésben van és ha nem érkezik gombnyomás akkor a 4 ciklusonként nullázni kell az értékét hiszen 4x4 vagy is 16gomb van.Egyszóval, ha sima C programnak tekintjük akkor tökéletes a példád, de sajnos itt figyelembe kell venni, hogy mikrokontrollert programozunk fel illetve a lábak szintjeit ellenőriztük.
Azt hiszem erre irányuló kérdésem a C topikban nem állja meg a helyét.
Köszönöm ettől függetlenül a segítőkészséget. -
válasz
don_peter
#4568
üzenetére
#define SOROK_SZAMA 4
#define NO_KEY 0
#define FIRST_ROW_BIT_POSITION 4
int oszlopok[] = { PORT_B4, PORT_B5, PORT_B6, PORT_B7 };
unsigned char get_key()
{
unsigned int i, k=0;
for( i=0; i < SOROK_SZAMA ; i++ )
{
SOROK = (1 >> ( FIRST_ROW_BIT_POSITION + i ) ); //Léptetjük a sorok szintjét
for ( j = 0 ; j < sizeof(oszlopok) ; j++ )
{
k++;
if(oszlopok[j] == MAGAS)
{
while( oszlopok[j] == MAGAS ); //Várakozunk a gomb felengedéséig
return k;
}
}
}
return NO_KEY;
}Vagyis az oszlopokat szepen tombbe lehet rakni, es akkor a ciklusbol tenylegesen ciklust lehet csinalni.
A k-t allitgato resznek semmi ertelme nem volt, mert csak arra allitotta, ami amugy is az erteke volt (illetve a vegen nullara, de azt meg nem hasznaltad sehol).
Es ha nem talal semmit, akkor nem ALACSONY-t adunk vissza, hanem valami sajat erteket, mert az logikailag ket kulonbozo dolog - akkor is, ha a konkret ertek pont ugyanaz (most - aztan lehet, hogy kesobb nem lesz az).
Illetve a kodba lehetoseg szerint nem illik mindenfele konstansokat elhinteni, ha valami konstans, akkor legyen az, C-ben tipikusan #DEFINE-nal.
-
don_peter
senior tag
válasz
don_peter
#4567
üzenetére
Oksa közben rájöttem, hogy az oszlop1, oszlop 2...stb-re gondolsz.
És közben arra is rájöttem, hogy mivel az oszlop1, ...oszlop4 változok a mikrovezérlő lábait tartalmazzák így azokat nem tömbösíthetem.
Az if() feltétben a mikrovezérlő lábainak szintjét ellenőrzöm, hogy magas vagy alacsony szinten áll. -
don_peter
senior tag
válasz
Jester01
#4566
üzenetére
Közben rájöttem, hogy van a kódban még hiba így azt javítottam.:
unsigned char get_key(){
unsigned int i, k=0;
for(i=0; i<4; i++){
SOROK = (0x08>>i); //Léptetjük a sorok szintjét
k++;
if(oszlop1 == MAGAS){
while(oszlop1==MAGAS); //Várakozunk a gomb felengedéséig
return k;
}
k++;
if(oszlop2 == MAGAS){
while(oszlop2==MAGAS); //Várakozunk a gomb felengedéséig
return k;
}
k++;
if(oszlop3 == MAGAS){
while(oszlop3==MAGAS); //Várakozunk a gomb felengedéséig
return k;
}
k++;
if(oszlop4 == MAGAS){
while(oszlop4==MAGAS); //Várakozunk a gomb felengedéséig
return k;
}
if(i>0){ //Ha a második lefutásnál sincs találat
k=(i+1)*4;
}else if(i==3){ //Ha az utolsó is lepörgött nullázzuk k-t
k=0;
SOROK = 0x08; //Sorok szintjét vissza állítjuk az elejére.
}else{ //Első lefutás után a k értéke 4 lesz
k=4;
}
}
return ALACSONY;
}Arra célzol, hogy gondolkozzak 2 dimenziós tömbökbe?
-
don_peter
senior tag
Hölgyek, Urak segítséget szeretnék kérni alfanumerikus 4x4-es keypad programjának megírásához.
Angol ABC és 0-9-ig számok lennének kb. mint a telefonnál vagy hasonlóan gondoltam kivitelezni.
Tudtok segíteni elméletben vagy akár gyakorlatban?
Hogyan lehet ezt legegyszerűbben megírni?
P18F4550-es mikrokontroller fogja feldolgozni az adatokat.
Ilyen lenne a keypad:A sima 16 gomb kezelésére írtam már programot, talán ebből ki lehetne indulni csak nem tudom, hogy miként vagy milyen irányban haladjak tovább..
A megírt kódom most így néz ki:#include <delays.h>
#define SOROK LATD //Sorok
#define oszlop1 PORT_B4 //Oszlopok bemenet
#define oszlop2 PORT_B5
#define oszlop3 PORT_B6
#define oszlop4 PORT_B7
#define MAGAS 1
#define ALACSONY 0
/*----- Prototípus --------*/
unsigned char get_key();
unsigned int bill_ertek; //Globális változó
void main(void){
unsigned int i,k=0;
ADCON1 = 7; //Analóg portok digitálisra állítva
TRISB = 0xf0; //B port felső 4 bit (nagyobb helyi értéken 7:4) bemenet
//alsó 4 bit (kisebb helyi értéken 3:0) kimenet
//0b11110000
while(1){
bill_ertek = get_key();
Delay10TCYx(10);
}//while()
}//main()
//Függvények
unsigned char get_key(){
unsigned int i, k=0;
for(i=0; i<4; i++){
SOROK = (0x08>>i); //Léptetjük a sorok szintjét
k++;
if(oszlop1 == MAGAS){
while(oszlop1==MAGAS); //Várakozunk a gomb felengedéséig
return k;
}
k++;
if(oszlop2 == MAGAS){
while(oszlop2==MAGAS); //Várakozunk a gomb felengedéséig
return k;
}
k++;
if(oszlop3 == MAGAS){
while(oszlop3==MAGAS); //Várakozunk a gomb felengedéséig
return k;
}
k++;
if(oszlop4 == MAGAS){
while(oszlop4==MAGAS); //Várakozunk a gomb felengedéséig
return k;
}
if(i>0){ //Ha a második lefutásnál sincs találat
k=(i+1)*4;
}else if(i==3){ //Ha az utolsó is lepörgött nulláztuk k-t
k=0;
}else{ //Első lefutás után a k értéke 4 lesz
k=4;
}
}
return ALACSONY;
}Minden ötletet szívesen fogadok.
-
#4564
Ereshkigal
őstag
alapz@j
#4563
-
alapz@j
tag
válasz
don_peter
#4560
üzenetére
A "Valaminev#60#120#185#225#240#260" -ből egy ciklussal a kettőskereszteket nullára cseréled:
Valaminev\060\0120\0185\0225\0240\0260
így létrejön 7 stringed. A char memtomb[7][46] helyett egy pointer tömböt csinálsz (char *memtomb[7]) és menet közben mindig feljegyzed az aktuális stringedre mutató pointert:
unsigned char meminput[] = "Valaminev#60#120#185#225#240#260";
unsigned char *memtomb[7];
memtomb[0] = meminput;
size_t len = strlen(meminput);
int memptr = 1;
for (int i = 0; i < len; ++i) {
if (meminput[i] == '#') {
meminput[i] = 0;
memtomb[memptr++] = meminput + i + 1;
}
}
for (int i = 0; i < 7; ++i)
printf("%s\n", memtomb[i]); -
don_peter
senior tag
válasz
alapz@j
#4557
üzenetére
Ez ebben a formában még magas nekem, de azért köszi a szándékot.
A mutatókat már ismerem, de csak felületesen.
Átvariáltam a dolgot mivel a fentebbi kódomnál csak a char típus jöhetett szóba és így pazaroltam a bájtokat illetve a megfelelő típusmódosítások is igényeltek további sorokat.
Az új verzában már külön szedtem a char és int típusokat és így már szebben lehet e memóriába beírni és kiolvasni.
Nem kellenek az elválasztó karakterek sem.
Ahogy tanulom és gyakorlom a dolgot úgy értem meg egyre jobban a működéseket.
-
#4559
Ereshkigal
őstag
alapz@j
#4558
-
#4558
alapz@j
tag
Ereshkigal
#4551
alapz@j
tag
válasz
Ereshkigal
#4551
üzenetére
A Random.org atmoszférikus zajból készít véletlenszámokat, amelyek publikus API-n keresztül elérhetőek. Ez a link pl.
http://www.random.org/cgi-bin/randbyte?nbytes=16&format=h
128 bit valódi random számot ad hexában (az url paraméterek magukért beszélnek).
-
alapz@j
tag
-
#4555
Ereshkigal
őstag
Jester01
#4554
-
#4554
Jester01
veterán
Ereshkigal
#4553
Jester01
veterán
válasz
Ereshkigal
#4553
üzenetére
Nem olyan nagyon jó
Mivel az OS valószínűsíthetően tiszta lappal indítja a processzed, ezért ez a memóriaszemét jó eséllyel determinisztikus lesz. Ráadásul fordítási és memóriaellenőrzési (valgrind) figyelmeztetést is okoz. -
#4553
Ereshkigal
őstag
buherton
#4552
-
#4552
buherton
őstag
Ereshkigal
#4551
buherton
őstag
válasz
Ereshkigal
#4551
üzenetére
Memória szemét? Függvényen belül hozz létre egy auto típust, és ennek veheted a címét is.
-
#4551
Ereshkigal
őstag
Véletlenszám generátor inicializálásához szükségem lenne (legalább) 128 bit adathoz (seed). Szívesen fogadnék bármiféle ötletet a szokásos rendszeridő, process id, stb. megoldásokon túl.
-
don_peter
senior tag
Igen van ilyen, csak nem jutottam előrébb vele és ezért kezdtem el gondolkodni a lépéseken.
Itt a függvény:
#include<string.h>
#include<stdio.h>
int main()
{
char input[16] = "abc,d";
char *p;
p = strtok(input, ",");
if(p)
{
printf("%s\n", p);
}
p = strtok(NULL, ",");
if(p)
printf("%s\n", p);
return 0;
}
Szerintem ő jól dolgozik, csak nem jutottam vele dűlőre -
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'. -
don_peter
senior tag
Húúú mennyire igazad van..
A lezárót elfelejtettem.
Most már jó...char memtomb[7][10];
És
memtomb[x][z] = '\0';egyébként ez véleményed szerint hatékony módszer vagy ennél van egyszerűbb és hatékonyabb mód a szétválasztásra és tömbbe másolásra?
Gondolom ha a számokat már int típusra akarom alakítani akkor a típusmódosítással el tudom érni azt.
int elsoszam;
elsoszam = (int)memtomb[1];
Ez így jó lesz? -
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... -
don_peter
senior tag
Közben meg is oldottam a dolgot.
A kérdésem a következő lenne:
Van esetleg egyszerűbb és hatékonyabb megoldás a következő kódomra?
#define MAXTOMBSIZE 32 //headerbe
//main()
unsigned int maxmemtomb;
char meminput[MAXTOMBSIZE] = "Valaminev#60#120#185#225#240#260";
char memtomb[7][46];
int i,z,x;
char ek = '#';
maxmemtomb = MAXTOMBSIZE;
x=0;
z=0;
for(i=0; i<=maxmemtomb-1; i++){
if(meminput[i] == ek){
z=0;
x++;
printf("\n%c", meminput[i+1]);
memtomb[x][z] = meminput[i+1];
z++;
i++;
}else{
printf("%c", meminput[i]);
memtomb[x][z] = meminput[i];
z++;
}
}
printf("\n\nTömbbe rendezve:\n");
for(i=0; i<=6; i++){
printf("%i. adat: %s\n",i, memtomb[i]);
}
Illetve az is érdekel, hogy miért kellett a "char memtomb[7][46];" többdimenziós tömböm második paraméterébe minimum 46-ot tennem, hogy jó eredményt kapjak?
Ezt nem értem még akkor sem, ha így működik...
Elviekben ott a maximum 9 karakter lehet mert a "Valaminev" a leghosszabb string nem? Vagy nem jól értelmezek valamit? -
don_peter
senior tag
Urak, Hölgyek!
A következő kóddal van bajom:
//headerbe
#define MAXTOMBSIZE 32
//main()
unsigned int maxmemtomb;
char meminput[MAXTOMBSIZE] = "Valaminev#60#120#185#225#240#260";
char memtomb[7];
int i;
char ek = '#';
maxmemtomb = MAXTOMBSIZE;
for(i=0; i<=maxmemtomb-1; i++){
if(meminput[i] == ek){
printf("\n%c", meminput[i+1]);
//memtomb[i] = meminput[i+1];
i++;
}else{
printf("%c", meminput[i]);
//memtomb[i] = meminput[i];
}
}
//for(i=0; i<=6; i++){
//printf("\nAdatok: %s\n", memtomb);
// }A program lényege, hogy a "Valaminev#60#120#185#225#240#260" karakterláncot a # karakternél szétválasszam és a szétválasztott elemeket egy tömbbe töltsem.
Addig jó a program, hogy kiírja a képernyőre a szétválasztott elemeket egymás alá, de mikor bele akarom tölteni egy tömbbe a szétválasztott elemeket akkor zagyvaságokat ír bele.
Próbáltam már kismillió formában, de a végén nem lesz jó az eredmény.
Mit cseszek el folyamatosan?
Hogy tudnám ezt megoldani?A program élesben egy 64KB-os memória 32bájt-ját fogja beolvasni ami hasonlóan vagy pont így fogja tárolni az adatot, a szétválasztott adatok külön-külön lesznek hasznosak.
De ha nem jó a megközelítésem szívesen veszem a kiokításokat. -
TheProb
veterán
Sziasztok!
Segítséget szeretnék kérni tőletek egy beadandómhoz. A leírást itt el tudjátok olvasni (belépés vendégként), ugye a lényeg annyi, hogy egy buta excel-t kell megírni c-ben ami kezel 4 megadott fv-t.
Jelenleg ott tartok, hogy szeretném megszámoltatni a programmal, hogy hány sort és oszlopot tartalmat a beimportált fájl, nem nagyon tudok, hogy mi lenne az a legegyszerűbb feltétel/módszer ami megmondja, hogy hány db oszlopom van, mert ugye ha maga a cella is tartalmat ";"-t, akkor már ott trükközni kell...Jelenleg így áll a kód, de nagyon nem jó, sajnos mint írtam nem jöttem rá, hogyan kéne.
A tárgyalt sor a 36.-nál lenne, tudom, hogy így biztosan nem jó a feltétel. -
tototos
addikt
válasz
dabadab
#4541
üzenetére
RTOS fölé szeretnék írni egy burkolót, ami azt csinálja hogy a felhasználó megadja, hogy melyik funkciót szeretné futtatni, milyen periodicitással, és ezt az alatta lévő réteg elintézi. A felhasználónak nem kell a taskjában while loopot írni, meg várakoztatni adott ideig a taszkot, csak megírja mit csináljon a task és az lefut minden egyes periódusban. A létrehozható taszkok száma maximalizálva van, az a taskN. A bővítést szeretném macroval megoldani, hiszen minden task ugyanazt csinálja, csak ugye a hívandó funkció és a periódus változik.
-
-
-
tototos
addikt
Sziasztok!
Egy kis macro segítség kellene. A következő sorokat szeretném kiváltani macroval:
task_Function[0] = task1;
task_Function[1] = task2;
task_Function[2] = task3;
task_Function[3] = task4;
task_Function[4] = task5;
task_Function[5] = task6;
task_Function[6] = task7;
static portTASK_FUNCTION(task1,params){
portTickType xLastWakeTime;
const portTickType xFrequency = RTOS_tasks[0].period_ldu32 / portTICK_RATE_MS;
// Initialize the xLastWakeTime variable with the current time.
xLastWakeTime = xTaskGetTickCount();
while(1)
{
RTOS_tasks[0].taskFunction(params);
// Wait for the next cycle.
vTaskDelayUntil( &xLastWakeTime, xFrequency );
}
}
static portTASK_FUNCTION(task2,params){
portTickType xLastWakeTime;
const portTickType xFrequency = RTOS_tasks[1].period_ldu32 / portTICK_RATE_MS;
// Initialize the xLastWakeTime variable with the current time.
xLastWakeTime = xTaskGetTickCount();
while(1)
{
RTOS_tasks[1].taskFunction(params);
// Wait for the next cycle.
vTaskDelayUntil( &xLastWakeTime, xFrequency );
}
}
static portTASK_FUNCTION(task3,params){
portTickType xLastWakeTime;
const portTickType xFrequency = RTOS_tasks[2].period_ldu32 / portTICK_RATE_MS;
// Initialize the xLastWakeTime variable with the current time.
xLastWakeTime = xTaskGetTickCount();
while(1)
{
RTOS_tasks[2].taskFunction(params);
// Wait for the next cycle.
vTaskDelayUntil( &xLastWakeTime, xFrequency );
}
}
static portTASK_FUNCTION(task4,params){
portTickType xLastWakeTime;
const portTickType xFrequency = RTOS_tasks[3].period_ldu32 / portTICK_RATE_MS;
// Initialize the xLastWakeTime variable with the current time.
xLastWakeTime = xTaskGetTickCount();
while(1)
{
RTOS_tasks[3].taskFunction(params);
// Wait for the next cycle.
vTaskDelayUntil( &xLastWakeTime, xFrequency );
}
}
static portTASK_FUNCTION(task5,params){
portTickType xLastWakeTime;
const portTickType xFrequency = RTOS_tasks[4].period_ldu32 / portTICK_RATE_MS;
// Initialize the xLastWakeTime variable with the current time.
xLastWakeTime = xTaskGetTickCount();
while(1)
{
RTOS_tasks[4].taskFunction(params);
// Wait for the next cycle.
vTaskDelayUntil( &xLastWakeTime, xFrequency );
}
}
static portTASK_FUNCTION(task6,params){
portTickType xLastWakeTime;
const portTickType xFrequency = RTOS_tasks[5].period_ldu32 / portTICK_RATE_MS;
// Initialize the xLastWakeTime variable with the current time.
xLastWakeTime = xTaskGetTickCount();
while(1)
{
RTOS_tasks[5].taskFunction(params);
// Wait for the next cycle.
vTaskDelayUntil( &xLastWakeTime, xFrequency );
}
}
static portTASK_FUNCTION(task7,params){
portTickType xLastWakeTime;
const portTickType xFrequency = RTOS_tasks[6].period_ldu32 / portTICK_RATE_MS;
// Initialize the xLastWakeTime variable with the current time.
xLastWakeTime = xTaskGetTickCount();
while(1)
{
RTOS_tasks[6].taskFunction(params);
// Wait for the next cycle.
vTaskDelayUntil( &xLastWakeTime, xFrequency );
}
}Meg lehet ezt valósítani? Köszi.
-
don_peter
senior tag
válasz
buherton
#4533
üzenetére
Köszi, egyelőre még nem értem teljesen mi hogy működik, de rajta vagyok az ügyön.
Most ezt dobtam össze ami részben működik, de egy idő után valamiért megkeveredik és összeakad a futása.
[link]
A lényege, hogy fut a főprogram, majd bekövetkezik egy magas jelre történő megszakítás (kapcsolóval) és eldúl az interrupt-ban megadott feladat. (visszaszámláló)
Majd a feladat végeztével a program visszatér a főszálba és folytatja a futást.
Ez szépen fut is egy darabig aztán káosz lép fel....(utóbbi változó idő után van amikor egyből) -
#4536
Ereshkigal
őstag
izsom
#4534
Ah, bocs, a végét nem olvastam.
#include <stdio.h>
#include <stdlib.h>
int main()
{
int n=5;
int a[n];
int b[n];
int c[n];
int i, j, db = 0, ossz = 0;
for(i = 0; i < 3; i++ )
for(j = 0; j < n; j++)
switch(i)
{
case 0:
printf("A vektor elemei:");
scanf("%d",&a[j]);
break;
case 1:
printf("B vektor elemei:");
scanf("%d",&b[j]);
break;
case 2:
printf("C vektor elemei:");
scanf("%d",&c[j]);
break;
}
for(i = 0; i < n; i++)
if(a[i] < c[i] && c[i] < b[i])
{
ossz+=c[i];
db++;
}
printf("%d\n%d", db, ossz);
return 0;
} -
#4535
Ereshkigal
őstag
izsom
#4534
-
izsom
újonc
Valaki tuna nekem segíteni ebben a feladatba?
Adottak az n elemű a, b, c vektorok. Meg kell számlálni, hogy a c vektor hány eleménél teljesül az ai < ci < bi (i = 0,1,…,n-1) feltétel. Adja meg még a feltételt kielégítő ci elemek összegét is!eddig sikerült megcsinálni:
#include <stdio.h>
#include <stdlib.h>int main()
{
int a[] = {2, 5, 7, 13};
int b[] = {9, 54, 98, 56};
int c[] = {8, 8, 43, 17};int i;
int db = 0;for(i = 0; i < 4; i++)
if(a < c(i) && c(i)< b(i))
db++;
printf("%i", db);return 0;
}
Csak nekem az kéne hogy úgy töltöm fel a tömbbe az elemeket hogy saját magam írom be. Pl így: A vektor elemei: 1 2 3 4
B vektor elemei: 1 2 3 4 -
buherton
őstag
válasz
don_peter
#4532
üzenetére
Olvasd el az interrupt kezelést még egyszer, hogy tisztában legyél hogyan működik. A következő azaz, hogy a kiválasztott perifériának engedélyezni kell, hogy megszakítson, aztán engedélyezni kell a globális a megszakítást. Ha jól emlékszem, akkor elég buta megszakítás kezelője van, mert egy függényt hívogat mindig, és azon belül kell megnézni, hogy mely periféria flag-e állt be. Vagy lehet keverem egy másikkal? Nem akarok hitvitát indítani, de ez egy ritka rossz megoldása a megszakítás kezelésnek. Eddig 4 architektúrára fejlesztettem és ebből 3-nak azonos az elv, kivéve a PIC-ét, továbbá a FreeRTOS sem képes stabilan futni rajta. Ha javasolhatom, akkor inkább AVR, de még inkább az ARM Cortex-M0-t javaslom. Ez lenne a legjobb választás.
-
JmL
csendes tag
válasz
dabadab
#4530
üzenetére
És most jó !!
Köszönöm szépen a segítséged, nagyon hálás vagyok ! :p
Gondolhattam volna a lezáró 0-ra
Egyébként magamtól tanulom a programozást mert az infótanárom csak pascal-t ismeri, és mivel BME-re készülök, célszerűbbnek gondoltam megtanulni a C-t, oda úgy is az kell a legelején, szóval a tanár ebben nem tud segíteni -
JmL
csendes tag
Sziasztok !
Kezdő vagyok a C nyelvben, emelt szintű érettségihez tanulom. Nincsenek nagy követelmények, megcsináltam már pár feladatsort, mentek is. Az eleje úgy kezdődik mindig, hogy egy txt fájlból kell adatokat beolvasni tömbökbe. Ez eddig ment mindig, most viszont valami nagyon nem stimmel, és egyszerűen nem tudom miért, jól jönne egy kis segítség :/
Szóval van egy fájl, konkrétan ez[link]Mivel az első sor tartalmaz a későbbiekben fontos adatokat, azokat csak sima változóba kell beolvasnom, tehát a tömbökbe való beolvasás a 2. sortól kezdődik. A problémám az, hogy mikor leellenőrzöm, hogy mindent jól olvasott-e be, nem azokat a számokat dobja ki, amiket kéne. Nem is látok benne logikát, hogy miért azokat dobja ki, amiket. Ráadásul valamelyik tömbelem jó, valamelyik nem.
Itt a kódom, ha valamit magyarázzak hozzá, csak szóljatok.
A txt-ben az első sor első száma azt jelenti, hogy hány sor van a tömbben a 2.-tól kezdődöen. 3 tömbbe olvasom az adatokat egy segédtömb segítségével. A segéd azért 3 elemű, mert a txt-ben lévő számok maximum 3 számjegyűek.int eladott_jegyek, vonal_hossz, fizetendo_osszeg, i;
char seged[3];
FILE * eladott = fopen ("eladott1.txt","rt");
fscanf(eladott,"%s",seged);
eladott_jegyek = atoi(seged);
fscanf(eladott,"%s",seged);
vonal_hossz = atoi(seged);
fscanf(eladott,"%s",seged);
fizetendo_osszeg = atoi(seged);
int ules_szam[eladott_jegyek], fel_szall[eladott_jegyek], le_szall[eladott_jegyek];
for (i=0;i<eladott_jegyek;i++) {
fscanf(eladott,"%s",seged);
ules_szam[i] = atoi(seged);
fscanf(eladott,"%s",seged);
fel_szall[i] = atoi(seged);
fscanf(eladott,"%s",seged);
le_szall[i] = atoi(seged);
}
for (i=0;i<eladott_jegyek;i++) {
printf("%d ",ules_szam[i]);
printf("%d ",fel_szall[i]);
printf("%d\n",le_szall[i]);
}Például már eleve az első sorok nem jók, az ules_szam tömb 0. eleme még jó, a fel_szall tömb 0. eleme szintén jó, majd a le_szall 0. eleme teljesen rossz, 12 helyett 1958474236-t olvas be.
Nem értem, hogy miért, légyszi segítsetek :/
Előre is köszönöm annak, aki fáradozik azzal hogy segítsen !! -
alapz@j
tag
Esküszöm nem keresem a c vs. java példákat, de most megint belefutottam egybe: http://raspberrycompote.blogspot.ie/2014/03/programming-language-micro-benchmark.html
A platform RasPi (arm), a feladat prímkeresés. -
don_peter
senior tag
Srácok és lányok
Nem tartozik ide szorosan, de hátha nem köveztek meg egy ilyen kérdésért.
A lényeg, hogy C programozásban gondolkodom vagy is valószínűleg komolyabban is bele fogom ásni magam a dolgokba.
Ezzel kapcsolatos főiskolai szakokat keresgélek, de nem tudom mi lenne nekem a legmegfelelőbb.
Mind ezt természetesen annak tudatában kellene megválasztanom, hogy az a jövőre nézve is ("ha egyáltalán beszélhetünk még jövőről") értékes ismeretekkel gyarapítson, tehát a munka, elhelyezkedésemet szemelőt tartva biztos egzisztenciám legyen.
Tehát, olyan szakot kellene választanom, ami jelenleg és későbbiekben is keresett lesz.
Van esetleg ötletetek, elképzelésetek milyen szakot válasszak?
Esti vagy levelezői lesz a megfelelő, hogy finanszírozni is tudjam a tanulmányaimat.Web programozásban már vannak ismereteim: HTML, CSS, PHP, SQL, JS...stb.
-
"Allat ez a 2048,,, elcsesztem vele 2 orat"
Bocs
"azt mondjuk nem tudom, hogy hogyan lett ez 11ezer pont"
Minden egyesitesert annyi pontot kapsz, amilyen szam van az uj negyzeten, igy aztan egy 2^n kocka eloallitasaert osszesen (n-1)*2^n pontot kapsz, egy 1024-es 9216 pont, a 256 meg 1792, pont meg is van a 11k.
-
Sziasztok, mivel lehetne pontosan időt mérni C-ben linux alatt?
-
#4514
Ereshkigal
őstag
cellpeti
#4511
válasz
cellpeti
#4511
üzenetére
Megelőztek.
While ciklus: karaktereket olvas be, amíg nem ütsz entert úgy, hogy szerepel a @ karakter a begépelt szövegben. Közben a gyak-ban eltárolja, hogy az adott (ASCII kódú) karakterből mennyi darab volt.
For ciklus: végigfut az előzőleg feltöltött gyak-on. Ha az adott elem nem nulla (tehát volt olyan karakter beolvasáskor), akkor kiírja azt, illetve annak darabszámát. -
Karma
félisten
válasz
cellpeti
#4511
üzenetére
Nem jól érted, a beolvasott karaktereket (nagyon helyesen!) nem tárolja a program, csak a darabszámot gyűjti.
Nézd meg a ++gyak[ c ] sort jobban! Vedd figyelembe, hogy a [] operátor erősebb, mint a ++, illetve a tényt, hogy a gyak tömb 256 elemű. No meg nem árt az az ismeret hozzá, hogy a char típus nyolc bites, úgyhogy egy beolvasott karakter 256 különböző értéket vehet fel.
-
cellpeti
nagyúr
#include <stdio.h>
main()
{
int c;
int gyak[ 256 ] = { 0 }; /* az egész tömböt nullázza */
while ( ( c = getchar() ) != '@' )
++gyak[ c ];
for ( c = 0; c < 256; ++c )
if ( gyak[ c ] )
printf( "%c: %d\n", c, gyak[ c ] );
}Írjunk programot, amely a billentyűzetről látható karaktereket olvas mindaddig, amíg a @ karaktert meg nem kapja! A program határozza meg és írja képernyőre a beolvasott különböző karaktereket és azok gyakoriságát!
Ez egy megoldott feladat volt. Kérdésem lenne, hogy jól értem-e amit csinál.
míg a beütött karakter nem egyenlő @-val, addig folyamatosan tölti fel a tömböt, majd a for ciklus számolja a leütött karakterek számát és hogy melyikből mennyi van?(ezt itt nem teljesen vágom, hogyan számolja)
majd az if szerkezet kiírja?
-
válasz
don_peter
#4500
üzenetére
Igazabol oktalisat meg hexat a binarisbol eleg egyszeru atszamolni, mivel (a tizes szamrendszerrel szemben) egy-egy helyiertekre fix mennyisegu bit esik: oktalisnal harom bit ad ki egy oktalis szamjegyet, hexadecimalisnal meg negy.
Szoval ha van egy olyan szamod, hogy 10101101001011, akkor ki se kell szamolnod, hogy az mennyi is valojaban, hanem anelkul at tudod valtani.
Oktalisba harmasaval csoportositva (az elejere raktam plusz nullakat, hogy mindenhol meglegyen a harmas csoport):
010|101|101|001|011 = 25513Hexadecimalisba meg negyesevel:
0010|1011|0100|1011 = 2B4BDecimalisnal persze kenytelen vagy tenylegesen vegigszamolni (2048 jatekosok elonyben
):
10101101001011 = 1+2+8+64+256+512+2048+8192 = 11083 -
TheProb
veterán
Tudtok/létezik olyan online compiler ahol normálisan lehet írni és futtatni is, mert amiket próbáltam eddig azok mindenkféle hibát kiírtak arra a kódra ami pl VS-ben gond nélkül lefutott? Először portable fordítóban akartam volna dolgozni, de erre a gépre nem lehet telepíteni az SDK-t így megette a fene.
-
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. -
-
-
Jester01
veterán
válasz
don_peter
#4498
üzenetére
Bináris->oktális pofon egyszerű, mivel 3 bit 1 oktális számjegyet kódol. Simán a legkisebb helyiérték felől 3 bitenként leírsz egy oktális számjegyet és kész. Feltételezem 3 bitet tudsz konvertálni, de ha nem akkor ugye a helyiértékek 4,2,1.
Bináris->hexa hasonlóan csak ott 4 bitenként haladsz.
A tízes számrendszer már külön állatfaj mivel nem kettő hatvány. Ott az általános átváltási módszert kell használni.
Szerintem nem jó ez a megoldás. Mert pl. nem lép ki ha az első lépésben 2-es a visszatérési érték.
. Illetve néhány oldallal ezelőtt volt az a másik windowsos IDE, az is megérhet egy említést.
), vegulis a * es a [] "valahol" egyenertekuek, lehet hogy csak tolem idegen szokas.
![;]](http://cdn.rios.hu/dl/s/v1.gif)
Ú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!
- SKHYNIX SAMSUNG WD SSD-k M.2 PCIe 256GB gen4
- SAMSUNG és SKHYNIX 8GB DDR4 RAM-ok!
- Thinkpad E15 Gen2 15.6" FHD IPS i7-1165G7 16GB 512GB NVMe ujjlolv gar
- Samsung S25 12/128GB Navy Blue, Snapdragon Elite, makulátlan állapotban garival eladó
- DJI Mavic 3 Pro Fly More Combo (2 akku) RC Pro - drón szett újszerű állapotban
- HIBÁTLAN iPhone 14 128GB Midnight -1 ÉV GARANCIA - Kártyafüggetlen, MS3527, 94% Akkumulátor
- Wacom Cintiq DTK-2260 digitális rajztábla
- ÁRGARANCIA!Épített KomPhone Ryzen 5 7600X 32/64GB RAM RX 9070 16GB GAMER PC termékbeszámítással
- Apple iPhone 14 / 128GB / Kártyafüggetlen / 12Hó Garancia / 83% akku
- Azonnali készpénzes INTEL CPU AMD VGA számítógép felvásárlás személyesen / postával korrekt áron
Állásajánlatok
Cég: PCMENTOR SZERVIZ KFT.
Város: Budapest
Cég: Promenade Publishing House Kft.
Város: Budapest