még nem látom az eltéréseket

Szerintem fontos lenne utánanézned.

Nyolc bites mikroprocesszoron a C# egyreszt nem letezik, masreszt technikailag kb. lehetetlen megvalositani, harmadreszt meg ha megis sikerul, akkor se akarna senki se hasznalni. (oke, mondjuk a C++ se hangzik tul hihetoen, sot, igazan a C is eleg hatareset)

"Nekem a C, C++ és a C# egy kalap alatt van."

Pedig azert eleg messze vannak egymastol: a C gyakorlatilag hordozhato Assembler a hatvanas evek vegerol, a C# meg nagyjabol minden modern paradigmat (objektumorientacio, generikus programozas, funkcionalis programozas, mittomen) tamogato, virtualis gepen futo cucc.

DRM is theft

Exception handling nem nagyon van semmilyen embedded es realtime rendszerben.

Same rules apply!

Utánanéztem, hogy eddig melyiket is használtam a C vagy a C++ és ez elsővel szoktam a mikróvezérlőkre(AVR) kódot írni, WinAVR-el.

A C# most hirtelen azért kellett, mert egy USB átalakító chip-hez akartam egy parancssorban lefutható kódot írni, aminek a példa kódja C#-ben volt leírva.

GA

[ Szerkesztve ]

Nem teljesen értem a problémát - az ascii karaktereket tartalmazó stringed az önmagában egy tömb, ami 0xXX értékeket tartalmaz...

Sziasztok!
Egy olyan kérdésem lenne, hogy egy rekurzív függvény hívásnál, ahol a függvény paramétere egy tömb, ott miért módosul az eredeti tömb a rekurzióból visszatérés után? Elvileg úgy lenne logikus, hogy mivel azt a tömböt csak paraméterként átadom a függvénynek rekurzív hívásnál és az ott abban a fv-ben az újonnan létrehozok egy tömböt, akkor csak odafelé adom át az értékeket, visszafele nincs módosítás, és miután lefutott a rekurzív fv., akkor a felső szinten nem változik meg a tömb tartalma. Azért nem értem a dolgot, mert pont e-miatt kell ugye változó helyett pointert használnom, ha meg akarom tartani az értéket a rekurzióból visszatérés után is.
Ez most szerintem kicsit össze-vissza lett ezért írok inkább egy példát, hogy mire gondoltam:
void rekurzivfv(int tomb[][M]) { //definiálom a fv-t és megadom paraméternek a tömböt
...függvényen belüli műveletek amik módosítják a tömb tartalmát....
rekurzivfv(tomb); //meghívom a fv-t, ami megkapja a tömböt
...itt már a tömb elemeinek értéke módosult, ahhoz képest, ami a függvény elején volt, arra
amire a rekurzió alatt változott pedig elvileg nem szabadna, mert a rekurzív fv-nél a fv újra
létrehozza a tömböt és miután a végigfutott, az innen már nem lehetne elérhető, mert
semmilyen formában nem adtam vissza...
}
Az jutott az eszembe még, hogy a teljes tömb átadásakor ott igazából tömb elejére mutató címet adom csak át (ha jól tudom), szóval olyan mintha az egy pointer lenne elvileg. Lehet, hogy az miatt módosul?
Meg lehet valahogy azt oldani, hogy ne módosuljon a rekurzív meghívás alatt az alap függvényben a tömb? Előre is köszönöm a segítséget!

[ Szerkesztve ]

Mert amit átadsz, az nem az egész tömb. Gondolj csak bele, durva is lenne, ha az egész tömböt mindegy egyes hívásnál lemásolnád. Elég költséges lenne a rekurziód.
Amit átadsz, az egy pointer (memóriacím), a tömb kezdetére.

Amit leírtál, az ezzel ekvivalens: void rekurzivfv(int* m)

Same rules apply!

Igen a végén írtam ezt én is, hogy ez az egyik tippem, hogy miért módosul, de akkor van valami egyszerűbb módszer, amivel ki lehet azt küszöbölni, hogy megváltozzon (esetleg másféle átadás, stb...)? Szerintem az lenne a megoldás, ha az egész tömböt eltárolnám egy másolatban, csak ugye nagyon sokszor kéne a rekurzió miatt másolgatni a tömböt ide-oda és nem hiszem hogy túl optimális lenne. (szerk.: na most jól leírtam még egyszer, ami a válaszban volt) Gondolkodtam azon is, hogy csak azokat az elemeket másolgatom, amik a rekurzió alatt megváltoznak, de az valamiért nem működött.

(#5312) EQMontoya
Labirintusban útkeresés backtrack algoritmussal. Azért módosítom, mert ahogy halad befele, úgy mindig beleírom a már bejárt utat és a rekurzióból visszafele meg további lehetséges utakat keresek, mert az összes lehetségeset meg kell találnia. És itt kéne, hogy a backtrack miatti visszaugrásnál eltünjön a módosítás és visszakapjam a rekurzió előtti tömböt. Az nem okoz gondot, hogy ott nincs megjelölve, hogy jártam (sőt a másik irányból érkező utak miatt pont ezért kéne ez), mert az if szerkezet miatt ugyan azt az útvonalat többet már nem vizsgálja meg.

[ Szerkesztve ]

Nem egészen értem magát az alap problémát: ha módosítod, miért meglepő a változása? Ha nem akarod, hogy változzon, miért módosítod? Milyen problémát szeretnél megoldani ezzel a kóddal?

Same rules apply!

És amiért megmarad ez a módosítás, a maradék utakat már nem tudom megkeresni, mert a tömbben ugye az már jelölve van, hogy ott már ment az útvonal, pedig nem, mert az csak egy másik volt.

A backtrack pont azért backtrack, mert vissza tud lépni. Gondolom, a tömbnek csak 1-2 elemén végzel változtatást egy lépésben, azt mentsd el szépen minden iterációban és ha visszalépés van, revertáld.

Same rules apply!

Igen ezt már próbáltam, hogy minden lépésnél ugye 1 elemet módosítok (jelölöm a bejárt utat) és azt elmentem egy tmp-be még a fv hívása előtt és a fv hívás után visszaírom azt az egyet, viszont nálam valamiért nem volt jó így, mert ez után a visszaírás helyett csak feltöltötte 2-esekkel (azzal jelölöm a bejárt utat) az egész labirintust.
Azért még próbálkozok Köszönöm az eddigi segítséget!

[ Szerkesztve ]

Egy kicsit nem ertem, hogy mi a tomb, ha rekurzivan hivsz, nem a vermed?
Ha a rekurziv hivas _nelkuli_ (ciklussal) backtrackre gondolsz, na azt en is parszor leirtam mar, es tombbel meg tomb-mutatokkal, szinten rejtveny-megoldasokhoz. Bar mindig ido kellett a beloveshez, mert a megfordulasi pontokra elegge figyelni kell...
Tulajdonkeppen a tombot veremnek hasznalod. Az egyetlen dolog, amit adminisztralni kell, hogy amikor egy elemnel vagy, akkor tudd, hogy most eppen merrefele haladsz. Me'g elotte vagy a feldolgozasnak az ott lehetseges ertekeknel, vagy ket tovabblepesi lehetoseg kozott, vagy tullepted mindet.
Egyszeruseg kedveert legyenek a lehetseges tovabblepesi pontok az iranyok, valami egymast koveto egeszek jelolessel. Ekkor amikor a verembe letolok egy elemet, a mutatot feljebb viszem a kovetkezore, ott inicializalom a lehetseges elemek ala eggyel. Amikor meg visszaterek, akkor a mutato dekrementalasaval egyidoben az ott kapott erteket bamban novelem eggyel, es ugy megyek neki a kovetkezo ciklusnak (ami hozhatja azt, hogy tulmentunk, megint visszalepes van, egy ciklus nem feltetlen egy vizsgalat).

Viszont ha jo neked ez rekurzivban is, akkor meg en azt csinalnam, hogy nem a tombot tolom le, hanem csak az utolso lepest. A tobbi minek neked? Tudod, hogy honnan jossz, for ciklusban meghivod az osszes lehetseges tobbi iranyra, es kesz. A tabla allapota meg lehet az egesz rekruzion kivuli statikus (termeszetesen ugy ertve, hogy visszalepesnel a bejarasi jelolest is visszaveszed).

???
Backtrack: a (jellemzoen fabejaros, de mindenkepp az eseteket reszleges megoldasokon keresztul bejaros) algoritmus bizonyos feltetelek mellett (alapesetben: a reszleges megoldas mar teljes megoldas(jelolt), ami viszont nem jo, vagy a reszmegoldasrol mar ott eldol, hogy jo megoldasnak nem lehet resze) az elozo [szintu] reszmegoldas kovetkezo lehetseges kiterjeszteset veszed. Vagyis felhasznalod a kereses korabbi eredmenyeit.
Ezt meg lehet csinalni rekurzivan (itt a backtrack az, amikor a fuggvenybol visszatersz, de az elozo peldanyban benne vagy egy mondjuk for ciklusban, ami veszi a kovetkezo elemet), meg meg lehet csinalni kezzel is, amikor a backtrack a "verem" pop-ja (vagy tombnel mint lent az index dekrementalas). Soxor az utobbi gyorsabban fut, de nehezebb jol megirni...

[ Szerkesztve ]

Kedves fórumlakók
Ma úgy látszik ilyen napom van, nem pörög az agyam, vagy csak igen lassan.
Következő problémába botlottam:
Van egy másodperc számlálom, ami char típusú és 0-tól 9-ig számol.
0,1,2,3,4,5,6,7,8 és 9, tehát rendesen előre számol.
Az lenne a gondom, hogy ezt nem tudom megfordítani.
Tehát megfordítva így nézne ki: 0,8,4,C,2,A,6,E,1,9 (hexában)
Tehát amikor 1-et mutat a másodperc a 0x08-at kellene kiküldenie, ha viszont 5 mutat, akkor a 0x0A-t.
Hogy tudom ezt megoldani?
Így néz ki ez kódban:
fuggveny(mp_1);
Itt az mp_1-ben a másodpercek pörögnek 0-9-ig, ezeket kellene még függvény előtt megfordítani a függvény zárójelei közt.
Előre is köszi a segítséget.

[ Szerkesztve ]

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

(x >> 3) | ((x >> 1) & 2) | ((x << 1) & 4) | ((x << 3) & 8)

-vagy-

static const char table[] = { 0, 8, 4, 12, 2, 10, 6, 14, 1, 9 };
x = table[x];

[ Szerkesztve ]

Jester

Köszönöm, mind két megoldást tudom használni, de elsőre maradok az elsőnél.
Jól működik, majd mutatom mihez kellett

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Egyébként a második a gyorsabb.

Same rules apply!

Igen tudom, használtam már ezt a táblás módszert.
Van erőforrás bőven szóval az első most jobb nekem..

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Ahogy ígértem, ehhez a kis projektemhez kellett a segítség.
DPTP System - SMD RGB Bináris óra
Mindig ügyeskedek valamit

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Igen.
Nem értem, mi az hogy vadászni kellett neked a 24-60-60-ra?
A bináris órának az a lényege, hogy binárisan mutassa az időt, nem értem ezt a dolgot most.
Amúgy se-percig nem tartana normál decimális órát készíteni.
Egy LCD kijelzőre vagy 7szegmenses kijelzőre, vagy akár egy matrix LED kijelzőre..

[ Szerkesztve ]

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

A te változatod is a tízes számrendszerbeli számjegyeket alakítja binárissá, vagyis BCD. A 35 másodpercet 3 és 5 formában mutatod, 2x4 biten (0011 1001). Neki meg gondolom egy 6 bites tiszta bináris kellett, ami a 35-öt 35-nek mutatja (100011)

Jester

Ja értem, akkor 3 oszlopból mutatható lenne az óra, perc. és másodperc.
A baj azzal csak az, hogy igen nehéz lenne megállapítani, hogy mennyi rajta az idő.
A 4bit-es sokkal könnyebb.
Persze megoldható lenne a dolog, ha erre volna igény, nem jelent gondot.

ui: szarakodott a szerver, kb egy 20 perccel előbb akartam reagálni...

[ Szerkesztve ]

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Hali!

Olyan kérdésem lenne, hogy meg lehet oldani valahogy, hogy egy 2013-as visual studioban készített ".C" project úgy fusson le a 2013-as VS-ben mint ahogy a 2010-es Visual Studio ellenőrizné, hogy hibás-e ?
azért kellene, mert egy projectünket egyetemen 2010esben javítják, de nekünk pedig 2013 van, és ne kelljen olyan embert is belevonni a programozásba akinek 10ese van. Valami fordító visszabutításra gondolok, vagy valami menüpont átállítására hogy más fordító legyen, vagy hasonló. De nem találok semmi hasznosat...

[ Szerkesztve ]

dolgozzatok 10-esben ha már abban várják a megoldást....

"Nem gond ha nem vágod a párologtatók bináris nyelvét..."

Jáú.
Szabványos kódot kell írni, az ugyanúgy fog benne fordulni.
Btw a C compileréhez a VS-nek szerintem évek óta nem nyúltak hozzá, csak a C++-hoz. Szóval ez legyen a legkisebb baj.

Same rules apply!

nem fut le, mert 280 hibát dob a 12-es és 350 warningot, felét tudom hogy amiatt, hogy a 12esben is még elöl kell deklarálni változókat, de jobb lenne látni a dolgokat azért.
Szívesen foglalatoskodom hogy WP 8.1re is tanulom az alkalmazásfejlesztést, aztán így muszáj hogy minimum 2013as legyen. emellé meg még a 2010es C++ t nem igazán szeretném feltenni hogy összekutyulódjon

Miert kutyulodna ossze?

while (!sleep) sheep++;

"Szabványos kódot kell írni"

Na jo, de melyik szabvanyhoz? A VS2010 C89, a VS2013 meg mar a C99 bizonyos reszeit is tamogatja (nyilvan nem az egeszet, hiszen meg csak masfel evtizedes szabvanyrol beszelunk, minek az a nagy rohanas )

DRM is theft

Egyetemi beadandot c89ben, kezdjuk az alapoonal. Valszeg abban is varjak.

Same rules apply!

hali
Remélem nem zavartok el, lenne egy kis gondom, érettségi előtt állok ,és a karakteres kezelés nem a szívem csücske, lenne egy olyan problémám hogy, röviden bekérek egy szavat a szo[20] tömbbe, és a szó betűit kell abc sorrendbe rendezni, ezt így csináltam:
tehát char szo[20], tmb(ez lenne egy csere változó amibe eltárolok 1 betűt ideiglenesen)

for(i=strlen(szo)-1;i>0;i--)
{
for(j=0;j<i;j++)
{
if(szo[j+1]<szo[j])
{
tmb=szo[j+1];
szo[j+1]=szo[j];
szo[j]=tmb;
}
}
}
for(i=0;i<strlen(szo);i++ printf("%s\n",szo[i]);

igazából semmit nem csinál, a szót bekéri valszeg meghalhat már a for-ál is, bár eddig kiírta a szöveget változatlanul de most már azt se csinálja

Xbox One: bandymnc

Nem akarok kódot írni, mert akkor nem tanulsz belőle, de szívesen adok néhány tippet.

1, A tömböt, amibe beolvasod a karaktereket, később is módosíthatod. Nincs szükséged második tömbre.
2, Használj valami rendezést. Az egész feladat arra megy ki, hogy a kapott karaktereket valamilyen formában rendezd, és ezt add visza. Néhány példa: buborékrendezés, minimum kiválasztáos rendezés.

Buborékot nem illik használni, de az a legegyszerűbb, ha nem láttál még ilyesmit. Erre a feladatra a minimum kiválasztás szerintem teljesen oké, próbáld meg azt. Ha nem megy, írd le, meddig jutottál.

Same rules apply!

Köszi teljesen egyértelmű és azt is csináltam, számokkal tudok buborékrendrzni de betűvel nem próbáltam soha, a bemásolt kód elvilrg az is, tehát ha ugye egyik betű nagyobb mint másik akkor cserélgesse, csak nem akar működni, ha benne hagyom a for ba a -1et akkor kidob exe hibával ha nincs benne akkor sztem átlép a foron, vagy kitörli a szöveget

Másik tömböt nem csináltam csak egy tmb karakteres változot vettem fel amibe ideiglenesen tárolom az egyes betűket

[ Szerkesztve ]

Xbox One: bandymnc

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
int i, min, j; //int
char string[20]; //string
char tmp; //temp char
scanf("%s",string); //scan

//minimum selection sort

for(i = 0; i < strlen(string) -1 ; i++){
min = i;
for(j = i+1; j < strlen(string); j++){
if(string[j] < string[min])
min = j;
}
tmp = string[min];
string[min] = string[i];
string[i] = tmp;
}
printf("%s",string);
return 0;
}

[ Szerkesztve ]

köszönöm, ez működik, csak azt szeretném tudni hogy az enyém miért nem, amit én írtam azt pont így használom számok esetén is és ott tökéletesen működik

Ahogy elnéztem a tied is hasonló bár nem teljesen

Xbox One: bandymnc

C-ben a karakterek 1 byteon ábrázolt szamok. Szoval ez nem lehet az oka. Írása ki egy 'a' betűt intkent, es latni fogod.

Same rules apply!

ha jól értettem amit mondtál akkor meg van a hiba és köszönöm, jobb lett volna ha elölről kezdem és nem folytatgatom mert mindig belekavarodtam

Xbox One: bandymnc

Szia!

Azert a biztonsag kedveert ird meg most sajat magad egy masik fajta rendezessel.
Illetve nekem be szokott valni az, hogyha elakadok, vagy nem ugy mukodik, akkor rakok a kodomba printf("%c",string)-t, ami kiirja, hogy epp mivel is dolgozik.

/*
printf("4.Feladat\n");
printf("Kerek egy szoveget:"); gets(szo); // i=4 1<0


for(i=strlen(szo)-1;i>0;i--)
{
for(j=0;j<i;j++)
{
if(szo[j+1]<szo[j])
{
tmb=szo[j+1];
szo[j+1]=szo[j];
szo[j]=tmb;
}
}
}
for(i=0;i<strlen(szo);i++)
printf("%c",szo[i]);*/

hibátlanul rendez, igazából a kiíratást csesztem el, %s-el akartam kiíratni a karaktereket nem %c-vel

de van még egy technikai kérdésem, van egy olyan feladat is hogy bekért szóból állapítsam meg hány különböző karakter van, elvileg angol ABC betűire kéne csak gondolnom, arra gondoltam, hogy felveszek egy 26 elemű tömböt for ezt mindig vizsgálja, hogy a szó mondjuk első betűje benne van e, ha nincs akkor beleírja és így tovább, csak ha ezt a tömböt felveszem, tmb[26], és nem rakok bele semmit akkor mi van? akkor is helyesen tudná vizsgálni? vagy fel kéne tölteni valami karakterrel ami biztos nincs benne?

Xbox One: bandymnc