- sziku69: Szólánc.
- Luck Dragon: Asszociációs játék. :)
- sziku69: Fűzzük össze a szavakat :)
- Magga: PLEX: multimédia az egész lakásban
- Brogyi: CTEK akkumulátor töltő és másolatai
- Pajac: tpm.msc
- M0ng00se: Hardvert áruhitelre?
- Steven: Sokat utazó kávéfüggők ide!
- f(x)=exp(x): A laposföld elmebaj: Vissza a jövőbe!
- Sub-ZeRo: Euro Truck Simulator 2 & American Truck Simulator 1 (esetleg 2 majd, ha lesz) :)
Új hozzászólás Aktív témák
-
Cicero
őstag
int main(){
FILE *f;
char *c;
int i=0;
c=(char*)malloc(50*sizeof(char));
f=fopen("szamok.txt", "r");
if(f==NULL){
printf("a megnyitas sikertelen");
}
*c=fgetc(f);
while(*(c+(sizeof(char)*i))!=EOF){
i++;
*(c+sizeof(char)*i)=fgetc(f);
}
for(i=0;i<36;i++){
printf("%c", *(c+(sizeof(char)*i)));
}
}Írtam egy ilyen beolvasós programot (akinek van rövidebb verziója, szívesen megnézném!). Ha pl hálózaton keresztül küldenek nekem egy fájlt amiből olvasnom kell, nem tudom előre a méretét, és nem is tudom megszámolni a benne lévő karaktereket. Hogy tudnám úgy lefoglalni a *c tömböt hogy mindig nyújtson a méretén ha új karaktert olvas be?
-
-
Cicero
őstag
int kerekito(double szam){
double tmp2, szam2;
int tmp;
szam2=szam;
tmp=szam2;
tmp2=szam2-tmp;
if(tmp2>0.5){
tmp2++;
}
return (int)tmp2;
}
int main(){
double szamm;
int szamm2;
puts("mit kerekitsek b+? ");
scanf("%e", &szamm);
szamm2=kerekito(szamm);
printf("kerekitve: %d", szamm2);
}Valami memóriaszemétnek tűnő rondaságot ír ki a kerekített szám helyett. Hol a hiba?
-
#2386
Szőkecica
csendes tag
Sk8erPeter
#2384
Szőkecica
csendes tag
válasz
Sk8erPeter
#2384
üzenetére
Oxika
-
#2385
kingabo
őstag
Sk8erPeter
#2384
kingabo
őstag
válasz
Sk8erPeter
#2384
üzenetére
Egyet értek!
-
#2384
Sk8erPeter
nagyúr
Szőkecica
#2382
Sk8erPeter
nagyúr
válasz
Szőkecica
#2382
üzenetére
Könyörgöm, használjátok már a "Programkód" gombot kód bemásolásakor, arra való, hogy ne egy okádék legyen a hozzászólásban, hanem valami átláthatónak tűnő kód...
Kódodat kijelölöd, majd megnyomod a Programkód gombot, voilá, máris átláthatóbb.
Ha nagyon nem megy, ott van a Pastebin is.Nem csak rád vonatkozik, de nagyon zavaró, hogy ennyien másoltok be ide formázás nélküli kódokat, utólag a topic és a konkrét kódok olvashatatlanok lesznek.
Legalábbis én ilyenkor úgy vagyok vele, hogy meg sem próbálom megérteni a kódot (akár segítségkérés, akár válasz), van jobb dolgom is.
Ne vegye senki bántásnak, inkább jótanács+kérés. -
#2383
Pcmagicnet
csendes tag
Szőkecica
#2382
Pcmagicnet
csendes tag
válasz
Szőkecica
#2382
üzenetére
Köszi. siker. Köszönöm mindenkinek a segítséget és bocsi hogy ilyen későn válaszolok de nem voltam itthon egy darabig.
Még egy olyan kérdésem lenne hogy tud-e valaki ajánlani C tanulásához valami jó tutorialt, vagy doksit, vagy jegyzeteket vagy bármit, amiből teljesen az elejétől meg tudnám tanulni a C-t. Ami tényleg értelmesen, részletesen elmagyaráz meg leír mindent.
BRIAN W. KERNIGHAN – DENNIS M. RITCHIE könyve megvan, amiből el is kezdtem már tanulni, de már az elején ad olyan feladatokat, amit előtte nem magyaráz el, és azt sem értem hogy mit kellene vagy hogy csinálni.
Ezért szeretnék egy olyan könyvet vagy az is jó ha valamilyen egyetemi jegyzete megvan valakinek amiből tanult, ami értelmesen elmagyaráz meg illusztrál átláthatóan mindent.
Így is a függvényhívások értékátadására magamtól kellett rájönnöm, de még mindig nem tudok normális függvényeket írni. Pl: a visszatérési érték típus konverziója nem sikerült, és nem értem hogy miért. A tömbök kezelését sem írja le rendesen a könyv. Az a baj hogy nem illusztrálják így nehéz vizuálisan elképzelni, hogy hogyis tárolódnak az adatok a tömbben.
Meg sok minden van még amit nem értek és, nagyon szeretném megtanulni. Eddig amit tanultam html, css, javascript, php, mysql. Szeretnék egy komoly nyelvet megtanulni (főleg a PIC programozáshoz) ezért választottam a C-t. Aztán majd később C++.
Ha tudtok segítsetek.Előre is köszönöm mindenkinek
-
#2382
Szőkecica
csendes tag
Pcmagicnet
#2379
Szőkecica
csendes tag
válasz
Pcmagicnet
#2379
üzenetére
Szia!
Kicsit át alakítottam a kódodat, de ez így műxik. Bár én is most kezdtem tanulni nemrég a C-t ;-)#include <stdio.h>
#include <stdlib.h>
#include <string.h>#define SZOHOSSZ 5
#define HOSSZU 100
#define MAX_SZO 200/* Program ami minden 5 karakternél hosszabb szót átmásol egy másik tömbbe */
int main(int argc, char** argv) {
char s[MAX_SZO][HOSSZU], hosszuszo[MAX_SZO][HOSSZU];
FILE* f = stdin;
int i, counter, counterHosszu, len;counter = 0;
counterHosszu = 0;while (!feof(f) && counter < MAX_SZO) {
fscanf(f, "%s", s[counter]);
len = strlen(s[counter]);
if (len > SZOHOSSZ) {
strcpy(hosszuszo[counterHosszu], s[counter]);
counterHosszu++;
}
counter++;
}printf("Hosszu szavak: \n");
for (i = 0; i < counterHosszu; ++i) {
printf("%s ", hosszuszo);
}
printf("\n");
return 0;
} -
Gyuri16
senior tag
válasz
Korcsii
#2380
üzenetére
egesz sor beolvasasara ott van a getline fuggveny, nem jo scanf-fel bohockodni
ez megbirkozik a bemenettel akkor is ha nem tudod elore mekkora lesz.
a str fuggvenyekbol pedig jobb azokat hasznalni ahol a nagysagot is meglehet adni, strcat helyett strncat plszerintem a legjobb megoldas altalanos beolvasasra az, hogy getline-al beolvasol egy egesz sort es aztan szetszeded komponensekre az adott feladat szerint
-
#2380
Korcsii
őstag
Pcmagicnet
#2379
Korcsii
őstag
válasz
Pcmagicnet
#2379
üzenetére
a \0 egy speciális karakter (NULL karakternek is hívják), szerepe, hogy jelezze a string végét (miért jó, azt csak akkor érted meg igazán, amikor nem engedik meg a string.h használatát
)szóval egy char tömbben (stringben) csak egyszer szerepelhet, bár tárolhatsz mögötte bármit, meg is jegyzi, de nem fogja kiírni, mert a kiírás is \0-ig történik...
strcat-tal lehet őket összefűzni, vagy ha egy mondatot akarsz egyben beleolvasni, akkor a szóközt is beleveszed, etc...
scanf("[^\n]",string);
pl én ezt szerettem anno, mindent beolvas addig, amíg sortörést nem talál... DE ez csak akkor alkalmazható, ha el is fér a string tömbben, azaz ha a feladat leírja, hogy márpedig csak ekkora meg ekkora lehet...a másik változatot:
int i = 0;
while((c = getchar()) != '\n') string[i++] = c;
string[i] = '\0';a probléma ugyanaz, ha nem fér el a megadott helyen (regényt adsz neki), akkor elszáll a program, de ha meg van adva a méret, használható...
ez utóbbiból azonban ki lehet indulni, ha dinamikusan akarjuk a memóriát lefoglalni: legjobb megoldás talán az, hogy foglalunk x méretűt, ha elérjük az x-et, foglalunk még egyszer akkorát, aztán a legvégén, amikor már az egész string megvan, megnézzük a méretét (vagy vesszük az i értékét), foglalunk egy akkorát, és belemásoljuk - így pont akkora helyet foglalunk neki, amekkora...
-
#2379
Pcmagicnet
csendes tag
kingabo
#2378
Pcmagicnet
csendes tag
válasz
kingabo
#2378
üzenetére
Köszi, próbálkozom. A tömbök kezelését még nem nagyon értem. Ha átmásolom az egyik tombből a másikba az 5 karakternél hosszabb szavakat, akkor az hogyan helyezkedik el a tömbben? Hogy tudom számolni vagy növelni a szavak számát? Úgy tanultam, hogy 1 tömbelem 1 karaktert tartalmaz.
pl: a tömbök indexei:
tomb[0] = 'h';
tomb[1] = 'e';
tomb[2] = 'l';
tomb[3] = 'l';
tomb[4] = 'o';
tomb[5] = '\0'; szóköz vagy sortérésnél beírja a 0 -a karaktert?....és hogy folytatódik tovább?
így?
tomb[6] = 'm';
tomb[7] = 'i';
tomb[8] = 'z';
tomb[9] = 'u';
tomb[10] = '\0';..és ezt hogy lehet kiíratni? Vagy nem jól gondolom az egészet?
-
#2378
kingabo
őstag
Pcmagicnet
#2377
kingabo
őstag
válasz
Pcmagicnet
#2377
üzenetére
Pár hsz-el feljebb van minta a file-ból való olvasásra.
A for ciklust akkor szokás használni, ha tudod, hogy hányszor kell lefutnia, mert pl a file első sorában megadod a sorok számát, egyébbként a while. A probléma is ehhez köthető. A ciklus magod össz vissz ennyit tartalmaz: hossz[i] = c; /* rövidített ciklus */, ezért is célszerű (pláne kezdőknek) a ciklus magot új sorba írni. A másik probléma az, hogy nem vizsgálod meg sehol sem a szavak hosszát, hanem egyből bele is teszed a tömbbe.
A ? operátornak nem ez a "megszokott" használati esete, ez átláthatóbb lenne sokkal if-ként.
valtozo = (feltetel) ? ertek_ha_igaz : ertek_ha_hamis
Én így csinálnám: ha a beolvasott szó hossza megfelelő, akkor átmásolnám tömbbe és növelném a tömbbeli szavak számát. mielött neki esnél egy problémának találj ki rá egy programozási nyelvtől független algoritmust, próbáld ki papíron, hogy jó-e. Így kivédhető lett volna az, hogy meg se vizsgáltad a beolvasott szó hosszát. -
#2377
Pcmagicnet
csendes tag
Pcmagicnet
csendes tag
Sziasztok!
Helló Kingabo!
Csinálnom kellene egy olyan progit, ami minden 5 karakternél hosszabb szót egy tömb-be rak, és azt EOF kor ki ír a képernyőre egymás alá. Csináltam egy kezdetleges progit de nem az igazi. Ez csak az első szót rakja be a tömbbe, de akkor is ha nincs 5 karakter, de ami utána érkezik nem rakja bele. Itt a progim:#include <stdio.h>
#define MAXSOR 1000
/* tömb be írja a 5 kakakternél hosszabb szavakat */
main(){
int i, k;
char c, tomb[MAXSOR], hossz[MAXSOR];
for(i = 0; (c = getchar()) != EOF &&
c !=' ' && c != '\n'; ++i) hossz[i] = c; /* rövidített ciklus */
(c == ' ' || c == '\n') ? hossz[i] = '\n', ++i : ""; /* if szerkezet helyett */
hossz[i] = '\0';
for(k = 0; k < i; ++k) tomb[k] = hossz[k];
printf("\nTomb tartalma: \n--------------\n");
for(i=0; tomb[i] != '\0'; ++i)
printf("%c", tomb[i]);
printf("\n");
}Szerintem valamit nagyon elnéztem. Ha tudtok segíteni azt nagyon megköszönöm.
-
kingabo
őstag
válasz
Korcsii
#2375
üzenetére
Ok, igazad van.
A szemem az értékadáson akadt meg illetve ezen a mondaton: "csak viszont igy a tomb2 memoriacime mindig felulirodik es az utolso elem tartalma lesz mindig benne" Erre megoldás az strcpy, azt viszont tényleg nem vettem észre, hogy nincs hely foglalva a paramétereknek.
-
Korcsii
őstag
válasz
gergo00
#2372
üzenetére
nah, szóval hogy olvasunk be sztringet?
char szoveg[123];
scanf("%s", szoveg);mondjuk ha azt írod be, hogy alma, akkor a végeredmény ez lesz:
szoveg[0] = 'a';
szoveg[1] = 'l';
szoveg[2] = 'm';
szoveg[3] = 'a';
szoveg[4] = '\0';magyarul a sztringeket a hosszuknál eggyel nagyobb char tömbben tároljuk
mivel neked kell még egy sor és egy oszlop/szó is (legalábbis remélem jól értettem), ezért kell még 2 dimenzió ezeknek is...
1. sor
2. oszlop/szó
3. karakter helyepl
char szoveg[12][12][123];
scanf("%s", szoveg[0][0]);
szoveg[0][0][0] = 'a';
szoveg[0][0][1] = 'l';
szoveg[0][0][2] = 'm';
szoveg[0][0][3] = 'a';
szoveg[0][0][4] = '\0'no de ez ronda, mert ki tudja, hogy hány oszlop/sor kell, illetve milyen hosszú lesz a szöveg, amit tárolni akarunk...
erre jó a dinamikus memóriafoglalás, úgy csak annyit foglalunk le, amennyi tényleg kelleni fog (a mostani esetben 12*12*123 bájtot foglaltunk le, függetlenül attól, hogy tárolunk-e benne valamit)... viszont jó pár sorral több lesz úgy a kód, meg kicsit jobban oda ekll figyelni...
viszont érettséginél mindig megmondják, hogy max mekkora lehet (legalábbis tavalyig így volt), így csak azokat az értékeket kell behelyettesíteni...
-
kingabo
őstag
válasz
Korcsii
#2370
üzenetére
"kingabo: strcpy jó, csak épp semmi nem létezik, amit neki adni kéne..."
Hogy hogy nem létezik?
Tehát amit beolvas a file-ból az semmi?(#2372) gergo00: maga a string is egy tömb. Vagyis a 3. dim a beolvasott szövegeket fogja tárolni.
(#2371) gergo00: miért foglalsz le 255 oszlopú tömböt, ha a ciklus végén 6 oszlop után új sort kezdesz?
-
gergo00
csendes tag
válasz
Korcsii
#2368
üzenetére
Mondjuk ha igy probálom akkor nem fut le a program, mondjuk 3dtombbel se.
int main()
{
char *tomb[255][255],sor=0,oszlop=0;FILE *fp;
fp=fopen("c:\\all.txt","rw");while(!feof(fp))
{
fscanf(fp,"%s",tomb[sor][oszlop]);
oszlop++;
if(oszlop>6)
{
sor++;
oszlop=0;
}
}system("pause");
}
5let? -
Korcsii
őstag
-
Korcsii
őstag
válasz
gergo00
#2367
üzenetére
char *tomb[25][25][123];
while (!feof(fp))
{
fscanf(fp, "%s", tomb[sor][oszlop]);
}a kódodból kiindulva így gondoltam a 3D tömböt... mondjuk abban nem vagyok biztos, hogy a feof() nem csak eggyel később így fog igazzal visszatérni...
dinamikusan ez jóval összetettebb, de végül is szebb megoldást ad...
-
gergo00
csendes tag
válasz
Korcsii
#2366
üzenetére
Akkor beszéljunk programnyelven
Mutatnal egy rovid peldat a haromdimenzios tombbel.
Mondjuk én a dinamikussal probalkoztam csak azzal az volt a baj hogy:char *tomb[25][25],*tomb2,
while(!feof(fp))
{
fscanf(fp,%s,tomb2)
tomb[sor][oszlop]=tomb2
}
csak viszont igy a tomb2 memoriacime mindig felulirodik es az utolso elem tartalma lesz mindig benne -
Korcsii
őstag
válasz
gergo00
#2365
üzenetére
ha 2 dimenziós tömbben akarsz stringet tárolni (pl [sor][oszlop]), akkor 3 dimenziós char tömb kell... vagy egy 2 dimenziós char * tömb, és akkor csak a pointerét tárolod, viszont akkor dinamikusan kell neki memóriát foglalni, és annak a helyét megadni pointernek... én érettségin az előbbit választottam, főleg azért, mert a dinamikus foglalásig nem jutottam el (nekem sem volt tanárom)...
-
gergo00
csendes tag
Sziasztok fórumozók!
Egy olyan függvény szeretnék létrehozni amely, külső pl:.txt állománybol sztringenkét beolvas egy két dimenziós tömbe.
Szóval, már irtam hasonló programot, amely kétdimenziós tömbe, külső állományból számokat olvas be.(egyébként emelt info érettségire készulok és azért kell). A problémám ott van hogy van egy állomány és annak az első sora pl:AAA aa a 0 1 2 3
Van egy tomb[255][255]-om, és azt szeretném hogy az AAA sztringem a tomb[0][0] helyére kerüljenek. Mert ugy megtudom valósitani hogy a három A betű kozül egyet a helyére berak.
Lehetséges fscanf(fp, %s, *ketdimentomb) rogton a memória cimeket tárolni egy mutatós kétd.tombe?
Lehet hülyeségeket kérdek, azért ne haragudjatok de sosem volt tanárom aki tanitott volna, és egymagában az embernek nem túl könnyű.
előre is kossz -
kingabo
őstag
válasz
RexpecT
#2361
üzenetére
Leírom megint hátha: Legközelebb programkódként idézd a progid! (a félkövér gomb alatt van a programkód gomb
)"Viszont azt is meg kellene oldani, hogy a csiga ne tudjon negatív irányba visszacsúszni,de erre még nem jöttem rá, hogy hogyan is kellene."
A korábban idézett megoldásodban két pozitív számot szoroztál össze, ami mindig pozitív lesz. Ha az előző hsz-emben leírt módszert használod, akkor a for ciklus-ba tegyél egy + feltételt, hogy a visszacsúszás pozitív, vagy a ciklusban miután viszacsúszás új értéket kap megvizsgálod, hogy nempozitív-e, ha igen akkor egy break;-kel kilépsz a ciklusból. Illetve a Failure-ös részbe akkor is be kell lépni, ha a visszacsúszás nempozitív.Nincs mit!
-
RexpecT
addikt
válasz
kingabo
#2352
üzenetére
Köszi szépen.
A Te progid a feladatban megadott pl-re rossz eredményt fog adni, mivel amikor kiér a csiga, Nálad akkor is visszacsúszik.
Ez tényleg így van.ezt már sikerült javítanom ezzel:
for(i=1;magassag<=h && magassag>=0;i++)
{
magassag+=u;
if(magassag<h)
{
magassag-=d;
}
u=u*f;
printf("magassag %f\n",magassag);
}
Viszont azt is meg kellene oldani, hogy a csiga ne tudjon negatív irányba visszacsúszni,de erre még nem jöttem rá, hogy hogyan is kellene. -
#2360
kingabo
őstag
Pcmagicnet
#2359
kingabo
őstag
válasz
Pcmagicnet
#2359
üzenetére
De sikerült megoldanod a * kiíratást az a lényeg.
Én meg kétszer is megnéztem mit akarsz mire rájöttem.
A kódtáblát én sem tudom fejből, ezért is linkeltem.
Nincs mit!
(#2358) Carpigabi: nagy segítség lett volna ha elforgatod a képeket. Az első képen az 1 egy ciklust jelől, a 2 return-t (szerintem). Ha jól sejtem, valamilyen iterációval számol ki adatokat.
-
#2359
Pcmagicnet
csendes tag
kingabo
#2357
Pcmagicnet
csendes tag
válasz
kingabo
#2357
üzenetére
Értem már, köszi
. Jó hogy mondod ezeket a dolgokat: printf("%s","*"); helyett printf("\*");
mert ezekről nem tudtam. Még csak most kezdtem el tanulni a C -t eddig csak webes nyelveket tanultam.
Csináltam egy másik progit amiben számmal indexelt tömböt használok, a te példádhoz hasonlóan. A kódtábla megvan köszi, de szerintem soha nem fogom tudni megtanulni mindet
.
Köszi mégegyszer mindent -
Carpigabi
csendes tag
Hali !
Mivel idáig nem nagyon volt dolgom folyamatábrával...
Eltudná nekem vlki magyarázni, hogy az alábbi folyamatábrán mit jelentenek, ill. mivel kell megoldani az (1) és (2) számokat? .... .. http://www.imagehost.co.za/share-8912_4D737A8A.html .... http://www.imagehost.co.za/share-1A99_4D737A8A.html ... -
#2357
kingabo
őstag
Pcmagicnet
#2355
kingabo
őstag
válasz
Pcmagicnet
#2355
üzenetére
A az 'i2' és a 'k2' azok milyen betűk?
Ehelyett :printf("(%1.1f%s) \n", (a / k), "%" ); ez is írható: printf("(%1.1f\%) \n", (a / k));. Ha egy string-ben egy foglalt operátort akarsz használni, mint itt pl a %-ot, vagy idézőjelet("), akkor szimplán írj elé egy \ jelet.Ha a \ jel kellene az így néz ki: \\ Pont ugyanígy a printf("%s","*"); helyett printf("\*"); Illetve ha csak 1 karaktert íratsz ki akkor szebb a %s helyett a %c.
Ha akarsz a progidon rengeteget rövidíteni: ascii.![;]](//cdn.rios.hu/dl/s/v1.gif)
Kicsit bővebben, a ciklusban a c1 a bekért betű ascii kódját fogja tárolni (vagyis ha nem %c-vel íratod ki, hanem %d-vel akkor a betű helyett az ascii kódja kerül a képernyőre). Az ascii kódot pedig szépen fel tudod használni egy tömb indexelésére. Pl a szám tömb indexeléséhez:
if (c1>='0' && c1 <='9')
{
++szam[c1-48]; //a 0 ascci kodja 48, vagyis ezt le kell vonni
}
Hasonlóan rövid lesz a betűk esetén is az 'A' esetén 65-t kell levonni, a 'a' esetén 97-et. Persze a megfelelő méretű tömböket elötte le kell foglalni.(#2356) Pcmagicnet: ránézésre jó, kipróbálod és kiderül.
-
#2356
Pcmagicnet
csendes tag
Pcmagicnet
#2355
Pcmagicnet
csendes tag
válasz
Pcmagicnet
#2355
üzenetére
Itt a megoldás.( Ha jól gondolom )
/* százalék számítás */
k = (nc/100.0) ;
printf("\na:");
a2 = (nc/70.0); /* max 70 karaktert ír ki ha 100%. Ha pl: nc=100 ez osztva 70.0 -el
= 1.4. Ez a 70 karakternek az 1% -a! De ha az öszes karakter (nc)=1 akkor (nc/70.0)
= 0.01. Ekkor ez a 70 karakter 1% -a.*/
for(i=0; i<=(a/a2); ++i){ /* Az (a/a2) -vel megnézem hogy a 70 -nek az 1% -a hányszor
van meg az 'a' változóba. Ha pl: a=10 és az összes karakter is 10 amiből adódóan
az a2 értéke 0.1 akkor (a/a2) azaz 10 / 0.1 = 100. Így a kapott eredmény
100% és 70db * karaktert ír ki. Másik példával: ha öszzes karakter (nc)=100
ez osztva 70.0 -el = 1.4. Ez a 70 karakternek az 1% -a! Ebből 20db az 'a' betű, a többi más
akkor (a/a2) azaz 20 / 1.4 = 14. Tehát 14db karakter a 70 karakter 20%-a. */
printf("%s","*");
}
printf("(%1.1f%s) \n", (a / k) , "%" ); -
#2355
Pcmagicnet
csendes tag
kingabo
#2354
Pcmagicnet
csendes tag
válasz
kingabo
#2354
üzenetére
Igazad van! Tényleg rosszul közelítettem meg a feladatot. Most csináltam egy olyat, hogy a bevitt karakterek száma adja meg a 100% -ot. Ez ugye bármennyi lehet! Ennek megfelelően számolom ki az egyes karakterek előfordulási gyakoriságát %-ban.
Szerintem jó lett, de azért nézd meg. Kíváncsi vagyok a véleményedre.
#include <stdio.h>
main()
{
int c1, nc, i, ures, nulla,egy,ketto,harom,negy,ot,hat,het,nyolc,kilenc,egyeb;
int a,b,c,d,e,f,g,h,i2,j,k2,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;
float k;
ures=c1=nc=a=b=c=d=e=f=g=h=i2=j=k2=l=m=n=o=p=q=r=s=t=u=v=w=x=y=z = 0;
nulla=egy=ketto=harom=negy=ot=hat=het=nyolc=kilenc=egyeb= 0;
while((c1 = getchar()) != EOF){
++nc;
switch(c1){
case 'a': ++a; break;
case 'b': ++b; break;
case 'c': ++c; break;
case 'd': ++d; break;
case 'e': ++e; break;
case 'f': ++f; break;
case 'g': ++g; break;
case 'h': ++h; break;
case 'i2': +i2; break;
case 'j': ++j; break;
case 'k2': ++k2; break;
case 'l': ++l; break;
case 'm': ++m; break;
case 'n': ++n; break;
case 'o': ++o; break;
case 'p': ++p; break;
case 'q': ++q; break;
case 'r': ++r; break;
case 's': ++s; break;
case 't': ++t; break;
case 'u': ++u; break;
case 'v': ++v; break;
case 'w': ++w; break;
case 'x': ++x; break;
case 'y': ++y; break;
case 'z': ++z; break;
case ' ': ++ures; break;
case '\n': ++ures; break;
case '\t': ++ures; break;
case '0': ++nulla; break;
case '1': ++egy; break;
case '2': ++ketto; break;
case '3': ++harom; break;
case '4': ++negy; break;
case '5': ++ot; break;
case '6': ++hat; break;
case '7': ++het; break;
case '8': ++nyolc; break;
case '9': ++kilenc; break;
default: ++egyeb; break;
}
}
printf("Osszes karakter:%ddb=(100%s)\n\nEbbol:", nc, "%");
/* százalék számítás */
k = (nc/100.0) ;
printf("\na:");
for(i=0; i<=a; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (a / k), "%" );
printf("b:");
for(i=0; i<=b; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (b / k), "%" );
printf("c:");
for(i=0; i<=c; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (c / k), "%" );
printf("d:");
for(i=0; i<=d; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (d / k), "%" );
printf("e:");
for(i=0; i<=e; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (e / k), "%" );
printf("f:");
for(i=0; i<=f; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (f / k), "%" );
printf("g:");
for(i=0; i<=g; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (g / k), "%" );
printf("h:");
for(i=0; i<=h; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (h / k), "%" );
printf("i2:");
for(i=0; i<=i2; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (i2 / k), "%" );
printf("j:");
for(i=0; i<=j; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (j / k), "%" );
printf("k:");
for(i=0; i<=k2; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (k2 / k), "%" );
printf("l:");
for(i=0; i<=l; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (l / k), "%" );
printf("m:");
for(i=0; i<=m; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (m / k), "%" );
printf("n:");
for(i=0; i<=n; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (n / k), "%" );
printf("o:");
for(i=0; i<=o; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (o / k), "%" );
printf("p:");
for(i=0; i<=p; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (p / k), "%" );
printf("q:");
for(i=0; i<=q; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (q / k), "%" );
printf("r:");
for(i=0; i<=r; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (r / k), "%" );
printf("s:");
for(i=0; i<=s; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (s / k), "%" );
printf("t:");
for(i=0; i<=t; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (t / k), "%" );
printf("u:");
for(i=0; i<=u; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (u / k), "%" );
printf("v:");
for(i=0; i<=v; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (v / k), "%" );
printf("w:");
for(i=0; i<=w; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (w / k), "%" );
printf("x:");
for(i=0; i<=x; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (x / k), "%" );
printf("y:");
for(i=0; i<=y; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (y / k), "%" );
printf("z:");
for(i=0; i<=z; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (z / k), "%" );
printf("Ures:");
for(i=0; i<=ures; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n\n", (ures / k), "%" );
printf("0:");
for(i=0; i<=nulla; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (nulla / k), "%" );
printf("1:");
for(i=0; i<=egy; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (egy / k), "%" );
printf("2:");
for(i=0; i<=ketto; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (ketto / k), "%" );
printf("3:");
for(i=0; i<=harom; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (harom / k), "%" );
printf("4:");
for(i=0; i<=negy; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (negy / k), "%" );
printf("5:");
for(i=0; i<=ot; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (ot / k), "%" );
printf("6:");
for(i=0; i<=hat; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (hat / k), "%" );
printf("7:");
for(i=0; i<=het; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (het / k), "%" );
printf("8:");
for(i=0; i<=nyolc; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n", (nyolc / k), "%" );
printf("9:");
for(i=0; i<=kilenc; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n\n", (kilenc / k), "%" );
printf("Egyeb karakter:");
for(i=0; i<=egyeb; ++i){
printf("%s","*");
}
printf("(%1.1f%s) \n\n", (egyeb / k), "%" );
system("PAUSE");
return 0;
}Most már csak azt kéne megoldani a hisztogram kinyomtatásánál, hogy a 100% az max. 70 karakter vagyis * legyen. Az 50% 35 *, a 10 % 7 *....stb. Ezt hogy oldjam meg?
Köszi a segítséget!!!
-
#2354
kingabo
őstag
Pcmagicnet
#2353
kingabo
őstag
válasz
Pcmagicnet
#2353
üzenetére
Ezt írtad :"kinyomtatja a bemenetre adott különböző karakterek előfordulási gyakoriságának hisztogramját" Ebben én nem látom sehol sem, hogy soronként kéne számolni, inkább az egészre.
"van 10db karakterem , ebből 6db 'a', és 4db 'b'. Akkor úgy kellene megjeleníteni, hogy 60% 'a', és 40% 'b' ?"
Szerintem így lenne értelme.
-
#2353
Pcmagicnet
csendes tag
kingabo
#2352
Pcmagicnet
csendes tag
válasz
kingabo
#2352
üzenetére
Ha 10db a betűm van, akkor az 14.3% lesz. Mert ha 70 karakterben határozzuk meg a 100% -ot, akkor ( a / 0.7 ) az 14.3 lesz. A 10 ennyi % - a a 70 -nek.
De most esett le hogy kellene meg csinálni.
Úgy kellene megcsinálni, hogy akár 1db karakter is 100% legyen? És ha több szót karaktereket beírunk akkor karakterekre felbontva számolja ki hogy melyikből hány % -nyi van? pl: van 10db karakterem , ebből 6db 'a', és 4db 'b'. Akkor úgy kellene megjeleníteni, hogy 60% 'a', és 40% 'b' ?
Jól értem? Mert akkor én egy teljesen más vonalon indultam el -
kingabo
őstag
válasz
RexpecT
#2348
üzenetére
Tedd az u = u * f;-et a ciklus végére és nem kell az if, ill írhatod ezt is helyette u*= f;. Vagy még szebb, ha a for-ban az i++ után teszed.
"Annyi a baj, hogy mindig az első naphoz képest fárad a csiga, az én kódomban meg mindig az előzőnaphoz."
Pont fordítva. A Te progid a feladatban megadott pl-re rossz eredményt fog adni, mivel amikor kiér a csiga, Nálad akkor is visszacsúszik.
C-ben nincs konstans. A legegyszerűbb az, ha deklarálsz még 1 változót, amiben azt tárolod, hogy mennyivel mászik kevesebbet naponta a csiga és ezt vonod le az u-ból.Legközelebb programkódként idézd a progid, mert könnyebb átlátni, ha benne vannak a tabok.
(#2351) Pcmagicnet: ezt már akkor se értettem igazán, hogy mit akartál ezzel leírni. (csak kimaradt a hsz-ből)
Szerintem nem jó, mert ha pl van 10db 'a' betűd és semmi más, akkor (ha jól értem a kódod) 70% lesz az 'a'-k aránya a 100% helyett. -
#2351
Pcmagicnet
csendes tag
kingabo
#2350
Pcmagicnet
csendes tag
válasz
kingabo
#2350
üzenetére
Igen, már elkezdtem csinálni. Az alja felé van egy rész, ami az 'a' karaktert már %-ban írja ki.
/* Ha pl: 70 karakter széllességben határozzuk meg a 100% -ot */
if(a != 0){a2 = a / 0.7; /* elosztom az 'a' értékét a 70. 1 % -ával. Ennyi % lesz! */
printf("a:");
for(szam=0; szam <= a; ++szam){
if(szam <= 70){
printf("%s", "*" );
}
}if(a2 <= 100.0){
printf("(%1.1f%s)", a2,"%");
}
else{
printf("(100.0%s)", "%");
}
}Tizedestörttel íratom ki, így nem kell kerekíteni. Úgy csináltam, hogyha túl menne a 100% -on, pl: 93 'a' betű, akkor ne írja ki hogy pl: 132%, hanem ha elértem a 70 karaktert, akkor 100% ot jelezzen. Ez így jó?
-
#2350
kingabo
őstag
Pcmagicnet
#2349
kingabo
őstag
válasz
Pcmagicnet
#2349
üzenetére
Őőő, bocs csak most vettem észre: a hisztogrammban %-os eloszlást szokás mutatni. Tehát a-ból van 5%, e-ből 12%... az összegük meg 100%. VAgyis minden elemre le kell osztani a karakterek számával és megszorozni 100-al. (az osztásnál használj kasztolást, hogy ne int hanem float osztás legyen: int-nél 1/10 = 0 float-nál: 1/10=0.1)
(#2348) RexpecT: majd késöbb átnézem, ha nem jön addig senki sem.
-
RexpecT
addikt
Gazdinfó szakra járok, de megnéztem a PTI-sek házifeladatát.
Itt van a feladat:[link]Eddig jutottam el:
#include<stdio.h>
#include<stdlib.h>
int main()
{
/*
h=kut magassaga
u=első nap mászása
d=visszacsuszas
f=faradekonysagi tenyezo
*/
float h,u,d,i,f,magassag=0;
printf("Kerem a 'h''u''d''f' parametereket.\n");
scanf("%f%f%f%f",&h,&u,&d,&f);
f=1-(f*0.01);
for(i=1;magassag<=h && magassag>=0;i++)
{
if(i>1)
{
u=u*f;
}
magassag+=u;
magassag-=d;
printf("magassag %f\n",magassag);
}
if(magassag>=h)
printf("Success on day %f\n",i-1);
if(magassag<=0)
printf("Failure on day %f\n",i-1);
system("PAUSE");
return 0;
}Annyi a baj, hogy mindig az első naphoz képest fárad a csiga, az én kódomban meg mindig az előzőnaphoz.Ezt kellene szerintem kijavítani és akkor jó is lenne.(Konstansnak lehet egy változó értékét adni?,vagy mutatóval kellene?)
Mentségemre legyen, hogy sok mindent nem vettünk még programozásból(ebben a félévben kezdtük el). -
#2347
kingabo
őstag
Pcmagicnet
#2345
kingabo
őstag
válasz
Pcmagicnet
#2345
üzenetére
Végülis így is megoldható.
5letek: a sok if helyett lehetne egy switch-ben:
switch (c)
{
case 'a': ++a; break;
...
case 'z': ++z; break;
}A case ágak végére KELL a break.
Esetleg használhatnál tömböket a számokhoz, betükhöz és sokkal rövidebb lenne a kód. -
#2346
Pcmagicnet
csendes tag
Pcmagicnet
csendes tag
Az előbb elfelejtettem, hogy a kód amit bemásoltam, egy olyan program, ami kinyomtatja a bemenetre adott különböző karakterek előfordulási gyakoriságának hisztogramját, csak nem tudom hogy jól csináltam-e. Ha valaki tudja nézze meg mert nem tudom hogy ez most jó-e vagy nem. Köszönöm
-
#2345
Pcmagicnet
csendes tag
Pcmagicnet
csendes tag
Üdv mindenkinek!
C-ben kellene egy hisztogramos kiírást csinálnom, amihez egy kis segítség kellene. A lényeg az lenne hogy ki kéne nyomtatni, a bemenetre adott szavak hosszának hisztogramját.
Csináltam egy progit, elég hosszú de azért bemásolom.
#include <stdio.h>
#define KINN 0
#define BENN 1main()
{
/* deklarálom az összes változót */
int nulla,egy,ketto,harom,negy,ot,hat,het,nyolc,kilenc;
int a,b,ce,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;
int c, szam, nw, nc, mas, nl, numc, allapot;
float a2;/* definiálom a változókat */
nulla=egy=ketto=harom=negy=ot=hat=het=nyolc=kilenc = 0;
a=b=ce=d=e=f=g=h=i=j=k=l=m=n=o=p=q=r=s=t=u=v=w=x=y=z = 0;
allapot = KINN;
nw = nc = mas = nl = numc = 0;/* program magja */
while((c = getchar()) != EOF){
++nc;
if(c >= '0' && c <= '9'){
++numc; /* ha szám akkor 1-el növeli a numc értékét */
--nc; /* a numerikus kataktereket kivonom az összes karakterből */
}
if(c == ' ' || c == '\t'){
++mas; /* ha szóköz vagy tab */
}
if(c == '\n'){
++nl; /* ha sortörés */
}
if(c == ' ' || c == '\t' || c == '\n'){
allapot = KINN;
--nc; /* szóköz, tab, sortörés kivonása az összes karakterből */
}
else if( allapot == KINN ){
allapot = BENN;
++nw;
}
/* ha az aktuális karakter 0,1,2,3... vagy a,b,c,d.... stb. növelem
a hozzá tartozó változó értékét 1-el */
if(c == '0')++nulla;
if(c == '1')++egy;
if(c == '2')++ketto;
if(c == '3')++harom;
if(c == '4')++negy;
if(c == '5')++ot;
if(c == '6')++hat;
if(c == '7')++het;
if(c == '8')++nyolc;
if(c == '9')++kilenc;
if(c == 'a' || c == 'A')++a;
if(c == 'b' || c == 'B')++b;
if(c == 'c' || c == 'C')++ce;
if(c == 'd' || c == 'D')++d;
if(c == 'e' || c == 'E')++e;
if(c == 'f' || c == 'F')++f;
if(c == 'g' || c == 'G')++g;
if(c == 'h' || c == 'H')++h;
if(c == 'i' || c == 'I')++i;
if(c == 'j' || c == 'J')++j;
if(c == 'k' || c == 'K')++k;
if(c == 'l' || c == 'L')++l;
if(c == 'm' || c == 'M')++m;
if(c == 'n' || c == 'N')++n;
if(c == 'o' || c == 'O')++o;
if(c == 'p' || c == 'P')++p;
if(c == 'q' || c == 'Q')++q;
if(c == 'r' || c == 'R')++r;
if(c == 's' || c == 'S')++s;
if(c == 't' || c == 'T')++t;
if(c == 'u' || c == 'U')++u;
if(c == 'v' || c == 'V')++v;
if(c == 'w' || c == 'W')++w;
if(c == 'x' || c == 'X')++x;
if(c == 'y' || c == 'Y')++y;
if(c == 'z' || c == 'Z')++z;
}printf("\nKarakterek\na:");
for(szam = 0; szam < a; ++szam){ /* Amennyi az adott karakterhez tartozó változó értéke, */
printf("%s", "*"); /* annyi * -ot íratok ki mellé */
}
printf("(%d)\nb:", a); /* a * sor végére () -jelbe kiíratom a változó értékét,
és a következő sorba kiíratom a következő karaktert */
for(szam = 0; szam < b; ++szam){
printf("%s", "*");
}
printf("(%d)\nc:", b);
for(szam = 0; szam < ce; ++szam){
printf("%s", "*");
}
printf("(%d)\nd:", ce);
for(szam = 0; szam < d; ++szam){
printf("%s", "*");
}
printf("(%d)\ne:", d);
for(szam = 0; szam < e; ++szam){
printf("%s", "*");
}
printf("(%d)\nf:", e);
for(szam = 0; szam < f; ++szam){
printf("%s", "*");
}
printf("(%d)\ng:", f);
for(szam = 0; szam < g; ++szam){
printf("%s", "*");
}
printf("(%d)\nh:", g);
for(szam = 0; szam < h; ++szam){
printf("%s", "*");
}
printf("(%d)\ni:", h);
for(szam = 0; szam < i; ++szam){
printf("%s", "*");
}
printf("(%d)\nj:", i);
for(szam = 0; szam < j; ++szam){
printf("%s", "*");
}
printf("(%d)\nk:", j);
for(szam = 0; szam < k; ++szam){
printf("%s", "*");
}
printf("(%d)\nl:", k);
for(szam = 0; szam < l; ++szam){
printf("%s", "*");
}
printf("(%d)\nm:", l);
for(szam = 0; szam < m; ++szam){
printf("%s", "*");
}
printf("(%d)\nn:", m);
for(szam = 0; szam < n; ++szam){
printf("%s", "*");
}
printf("(%d)\no:", n);
for(szam = 0; szam < o; ++szam){
printf("%s", "*");
}
printf("(%d)\np:", o);
for(szam = 0; szam < p; ++szam){
printf("%s", "*");
}
printf("(%d)\nq:", p);
for(szam = 0; szam < q; ++szam){
printf("%s", "*");
}
printf("(%d)\nr:", q);
for(szam = 0; szam < r; ++szam){
printf("%s", "*");
}
printf("(%d)\ns:", r);
for(szam = 0; szam < s; ++szam){
printf("%s", "*");
}
printf("(%d)\nt:", s);
for(szam = 0; szam < t; ++szam){
printf("%s", "*");
}
printf("(%d)\nu:", t);
for(szam = 0; szam < u; ++szam){
printf("%s", "*");
}
printf("(%d)\nv:", u);
for(szam = 0; szam < v; ++szam){
printf("%s", "*");
}
printf("(%d)\nw:", v);
for(szam = 0; szam < w; ++szam){
printf("%s", "*");
}
printf("(%d)\nx:", w);
for(szam = 0; szam < x; ++szam){
printf("%s", "*");
}
printf("(%d)\ny:", x);
for(szam = 0; szam < y; ++szam){
printf("%s", "*");
}
printf("(%d)\nz:", y);
for(szam = 0; szam < z; ++szam){
printf("%s", "*");
}
printf("(%d)\n0:", z);
for(szam = 0; szam < nulla; ++szam){
printf("%s", "*");
}
printf("(%d)\n1:", nulla);
for(szam = 0; szam < egy; ++szam){
printf("%s", "*");
}
printf("(%d)\n2:", egy);
for(szam = 0; szam < ketto; ++szam){
printf("%s", "*");
}
printf("(%d)\n3:", ketto);
for(szam = 0; szam < harom; ++szam){
printf("%s", "*");
}
printf("(%d)\n4:", harom);
for(szam = 0; szam < negy; ++szam){
printf("%s", "*");
}
printf("(%d)\n5:", negy);
for(szam = 0; szam < ot; ++szam){
printf("%s", "*");
}
printf("(%d)\n6:", ot);
for(szam = 0; szam < hat; ++szam){
printf("%s", "*");
}
printf("(%d)\n7:", hat);
for(szam = 0; szam < het; ++szam){
printf("%s", "*");
}
printf("(%d)\n8:", het);
for(szam = 0; szam < nyolc; ++szam){
printf("%s", "*");
}
printf("(%d)\n9:", nyolc);
for(szam = 0; szam < kilenc; ++szam){
printf("%s", "*");
}
printf("(%d)\n", kilenc);/* Ha pl: 70 karakter széllességben határozzuk meg a 100% -ot */
if(a != 0){a2 = a / 0.7; /* elosztom az 'a' értékét a 70. 1 % -ával. Ennyi % lesz! */
printf("a:");
for(szam=0; szam <= a; ++szam){
if(szam <= 70){
printf("%s", "*" );
}
}if(a2 <= 100.0){
printf("(%1.1f%s)", a2,"%");
}
else{
printf("(100.0%s)", "%");
}
}printf("\nSzavak szama: %d\nKarakterek szama: %d\nMas: %d\nSorok szama: %d\nNumerikus karakterek szama: %d\n", nw, nc, mas, nl, numc );
system("PAUSE");
return 0;
}Elég kezdetleges, de soha nem csináltam még ilyet. Azt sem tudom hogy kellene kinéznie. Ha valaki tud segítsen egy kicsit. Vagy ha van valami példátok szívesen megnézném.
Előre is köszi a segítséget!!! -
Muton
addikt
Köszi! A cél a gyök fv implementálása c és algó gyakorlat cáljából. És ha működik majd egésszel, akkor meg kell oldani törtre is, majd komplex számok halmazára is. mindezt bolond biztosan
Ja, a while feltéteében meg lehet adni fv-t?
pl:
while (a<0 && akarmi(a));
Szerk: %fl-el sem működik
-
Muton
addikt
Hello!
Lámáskodom C-ből
Be szeretnék kérni egy nem negatív doublet, de nem megy. Ezt gondoltam ki, de csak akkor működik nálam a do-while ciklus, ha a nem double, hanem int. egyébként simán beveszi a negatív számokat is. Hol rontottam el?
double a;
do{
printf("Add meg a-t!\n");
scanf("%d", &a);}
while (a<0); -
-
doc
nagyúr
ha tenyleg ezt mondtak, akkor alaposan atvertek
a header file-okban csak a fuggvenydeklaraciok vannak, vagyis ha tudod a fuggveny nevet, tipusat es a parameterek tipusait, deklaralhatod te magad is, es elhagyhatod a headert
maga a fuggvenydefinicio, vagyis a fuggveny torzse a library file-okban van -
kltz
tag
Teljesen jó az elgondolásod anno én is csináltam ilyet. A képernyő törlő parancs clrscr() amihez meg kell hívni a conio.h -t. Én úgy oldottam meg ,hogy volt 2 különböző mátrixom az egyikben tároltam a számokat adatokat a másikat "kép"-nek neveztem el és abban pedig tároltam a táblázatot. Majd írtam egy egyszerű függvényt amivel egybe másoltam a 2 mátrixot.
Meg egy kis egyéb ,hogy lehet színezni is. Van egy olyan ,hogy textcolor() és a zárójelen belülre adod meg a szín a számát pl. textcolor(12) az a piros és ha így íratsz ki,hogy cprintf("valami") akkor az egészet pirosan fogja kiírni. Na a lényeg ,hogy a táblázatot nagyon szépen feltudod dobni vele.
-
Cicero
őstag
olyat szeretnék csinálni, hogy amikor elindítom a programot kirajzol egy táblázatot amibe számjegyeket vár, enter lenyomásával pedig vízszintesen ugrik a következő cellára a táblázatban. 3x3-as lenne, a sor utolsó cellája után ugrana a következő sor első cellájára. Ezeket pedig mind egy 3x3-as tömbbe természetesen beírná.
Tulajdonképpen egy 3x3-as mátrixot akarok, ami kiszámolná az x1,x2,x3-at az eredményvektorok és rendsz.m. ismeretében. A számolási algoritmus megvan, csak a grafikai ficsőr érdekelne.
Mintha lenne C-ben egy képernyő-törlés parancs, ezt kihasználva minden bevitel után kirajzolná a táblázatot a megfelelő tömb értékekkel. Kettő egymásba ágyazott for ciklus lenne, i=0-tól, i=3-ig (az első a sor, a második az oszlopokat számolná), a nem definiált tömb értéke 0-a lenne (szal rajzolás előtt le kéne foglalni egy tömböt és máris nullázni).
Valakinek valami ötlet? Előttem van részekben a dolog, csak ez a grafikus megoldás, ugrálás stb nem áll össze, olyat még nem csináltam. -
artiny
őstag
Megszeretném tanulni a C programozást. Olvasom ezt:
http://kr-c.freeweb.hu/
(KERNIGHAN - RITCHIE A C programozási nyelv)Fejezet végén van olyan,hogy probald meg te is pl.:
Hello world kiírást. Ezeket a feladatokat amik vannak gyakorlás képpen a könyvben - ezeket szeretném kipróbálni.Melyik programban kell beírni? (mint pl.pascal nyelvnel a pascal programba) -
-
Jester01
veterán
válasz
RexpecT
#2314
üzenetére
Ez egy elég tökkelütött feladat
Az adott tömbben elég sokféleképpen lehet tárolni a halmazt, az egyik módot kingabo fentebb említette. Én most egy másikat mondok, ami valószínűleg közelebb áll a kérdésfeltevő korlátolt elképzeléséhez
Használjuk az x -> h[x] leképezést a számosság tárolására. Vagyis h[0] a 0 számossága, h[1] az 1 számossága, stb.
Ez alapján az adott halmaz leképezése {0, 3, 0, 3, 0} a legnagyobb tárolható elem pedig a 4.Kicsit általánosítva x -> h[f(x)] leképezés lehet, ahol a fenti példában természetesen f(x)=x. Vegyük észre, hogy ennek a leképezésnek igazából az alaphalmaz számosságára illetve az egyes elemek előfordulására van korlátja, nem pedig az elemek nagyságára. Magyarul 5 különböző elemet használhatunk, de azok bármik lehetnek. Például ha f(x)=x-1 akkor máris az {1, 2, 3, 4, 5} alaphalmazzal dolgozunk és a legnagyobb tárolható elem az 5. Mivel a példában csak 2 különböző elem van, ezért a fennmaradó 3 elemet tetszés szerint választhatjuk meg, így bármekkora elemet is tárolhatunk.
-
kingabo
őstag
válasz
RexpecT
#2314
üzenetére
Tudom ez Neked nem segít, de az elemeket (érték, multiplicitás) formában szokás tárolni. Ez alapján (nekem!) az tűnik logikusnak, hogy egy indexre beírod az értéket utána a multiplicitását. vagyis: 3 3 1 3, hogy az 5. elem mi a fene lehet nem tudom.
A másik kérdést nem igazán értem, hogy mire akar célozni. A tömb egy elemének maximális értékét a típusa határozza meg, pl 32 bites gépen, int esetén 2^31-1; unsigned int esetén 2^32-1. Hogy erre gondoltak-e nemtom.szerk: elöbb nem vettem észre, hogy int típusú a tömböd. Ezeseben szerintem a max a 2^31-1. A többiek majd vagy megerősítik vagy kijavítanak.
-
RexpecT
addikt
Lenne itt egy feladatocskám:
Adott a következő multihalmaz={3,3,3,1,1,1}.Tárolása az int h[5] tömbben történik.
Írja fel a tömb elemeinek értékét: _ _ _ _ _
Melyik a legnagyobb elem, ami ezen reprezentáció mellett a multihalmazban tárolható?A multihalmazról csak annyit tudok, hogy egy elem többször is szerepelhet.
-
Korcsii
őstag
válasz
RexpecT
#2310
üzenetére
szerk:
kellett nekem belekezdeni, aztán nem tudom félreérthetetlenül megfogalmazni...i=3+1, maradjunk ennyiben... egészet osztasz egésszel, ezért az operátor az egész osztást valósítja meg (amennyiszer pontosan megvan benne), tárolni utána tárolhatnád másban is... csak mivel a tároló, és az osztandó itt ugyanaz, mégse teheted, mert ha doble lenne, akkor már engedné
-
RexpecT
addikt
Nekem is ezt adja ki de nem értem hogy hogy:
2-vel indul az kisebb mint 19 kiírja a 2-t majd i=2+1
3 az kisebb mint 19 kiírja a 3-t majd i=3+1,5 mivel int ezért vágás történik ezért i=4
4 az kisebb mint 19 kiírja a 4-t majd i=4+2
6 az kisebb mint 19 kiírja a 6-t majd i=6+3
9 az kisebb mint 19 kiírja a 9-t majd i=9+4,5 de megint vágás lesz ezért i=13
13 az kisebb mint 19 kiírja a 13-t majd i=13+6,5 de megint vágás lesz ezért i=19
19 nem kisebb mint 19 ezért nem fog lefutni a ciklus mag.LOL hülye vagyok
csak egy \n-et kellett volna írni és akkor világos . -
kingabo
őstag
Remélem elhiszed, hogy a fenti hsz-t nem 2 sec alatt írtam meg.
Sztem nem a felfogásoddal van a gond, hanem hogy egyetemen b@sznak magyarázni. Nem véletlenül van középsuliban tanár, egyetemen előadószerk: kár, hogy itt a ph!-n nem lehet olyat csinálni mint egyes másik oldalakon, hogy a kódot autómatikusan színezni, esetleg hosszabb soroktól nem zuhanna szét az oldal. (amit tudtam javítottam, van pár komment sor ami nem fért ki egy részét átküldtem új sorba, de oda meg elfelejtettem //-t tenni, 1 még maradt benn)
-
kingabo
őstag
Hát ez "picit hosszú lett. Remélem érthető. Ha kérdésed van kérdezz nyugodtan, ha a többiek valami hibát találnak szóljanak és modikkal javíttatom.
A pointer az egy mutató a memória egy pontjára, vagyis egy memória címet tárol (egy int-et). Minden pointernek meg kell mondani, hogy milyen típusra mutat, hogy a fordító tudja, mi van ott: pl char vs float, mekkora (1byte vs 4byte). A pointert minden esetben használat elött inicializálni kell! (egyszerűbben: értéket kell neki adni), mivel a pointer "kezdeti értéke" nem NULL (==megegyezés szerint nem mutat sehova sem /semmire sem), hanem valamilyen memória szemét, ha ezt a szemetet akarod felhasználni arra, hogy elérd a pointer által mutatot memória helyet elég csúnya dolgok történhetnek ("jobb esetben" az oprendszer nem hagyja, "rosszabb esetben" felhasználhatják a program eltérítésére). Pointer deklarálása: a "mutatandó" érték típusa és a változó neve elé egy *:
int * p;Érték adás:
- NULL:
int *p = NULL;
- Egy másik pointer(1), vagy pl tömb esetén annak egy tetszőleges eleme(2) (részletesen lentebb)
int *pt,*pt1,t2[]={1,2,3,5};
pt = t2; //(2)
pt1 = pt; //(1)
pt = pt1 + 3; //(2) a t2 4. elemére mutat (1+3)- Egy változó címe: a váltózó elé a '&' jelet kell írni
int *p, i = 5;
p = &i;
- Dinamikusan foglalunk le memóriát (ld. késöbb)Pointer értéke vs pointer ÁLTAL MUTATOTT memória hely értéke: ezek keverése miatt lehet igen csúnya dolgokat (==hibákat) művelni. A pointer értéke egy memória cím, ami (jó esetben) egy megfelelő értékre mutat. A pointer által mutatott hely értéke az elején részletezett, a pointer deklarácójakor megadott típusú érték. Ezt elérni a pointer neve elé tett *-al lehet. Pl az előző részből az utolsó példában a 'p' pointer értéke az 'i' változó CÍME a memóriában. Az általa mutatott ÉRTÉK, vagyis a *p értéke 5 (*p = i = 5).
A gondot az okozhatja, hogy "véletlenül" lemarad a 'p' elől a *, így a pointer kap értéket, nem az általa mutatott memória cím. Vagyis ha az 'i'-nek értéket akarunk adni a 'p' pointeren keresztül akkor így kell *p = 6; // ==i;. A következő kód hibás, csak szemléltető ellenpélda:p = 6;, ekkor az 'i' értéke nem változik, a 'p' értéke egy, a programunktól független (nem a program egy változójára, vagy általa dinamikusan lefoglalt memória területre mutat), a 6-os memória címre fog mutatni, ahol biztosan semmi keresni valónk nincs és valószínűleg az oprendszer adatai vannak, vagyis semmi jóra ne számítsunk. (akit érdekel picit részletesebben itt az utolsó 2 sor)Egy dimenziós tömb: avagy a vektor. Egy 'n' elemű vektor, n db a memóriában egymás után lévő érték. (mint linalgból) Szemléletesen pl 3 elemű tömb (az '_' helyére kerülnek az értékek: |_|_|_|
Pl: int t[]={1,2,3,5};
A dolog szépsége az, hogy a 't' is egy pointer lesz, mely a tömb első elemének memóriabeli címére fog mutani.
A tömb elemeinek elérése
- a pointer eltolása, vagyis a pointer értékéhez hozzáadva, vagy levonva belőle. Fontos: nincs semmilyen védelem, hogy a pointer ne tudjon a tömbről "lemenni". Célszerűbb (főleg az elején), inkább a másik megoldást alkalmazni, kisebb a hiba lehetősége.
pl (a fenti t-t felhasználva): int *masodikElem = t+1; // a t 2. elemére mutat (1+1)
int harmadikElemErteke = *(t+2); //t eltolva 2-vel, vagyis a 3
. elem címére mutat és vesszük a címen lévő értéket
- a [] operátort használva. a változó után írva, a zárójelek közé egész számot, vagy egész típusú változót írva.Fontos: a megszokottól eltérően, c-ben az indexelés 0-tól n-1-ig történik! Vagyis pl, a zárójelek közé 0-át írva az általunk megszokott első elemet, n-1-et írva az általunk megszokott utolsó elemet kapjuk. További megjegyzendő tény, hogy nincs semmi védelem az ellen, hogy ne "menjünk le" a tombről. Más szóval ha a c-s indexeléssel nézve a -1-edik vagy az n-edik elemét akarjuk elérni a tömbnek (ami nem létezik), akkor a memóriában a tömb elött és utána lévő értékeket fogjuk elérni, amiről már a legelején megemlítettem, hogy mindent csak jót nem jelent! (Érdekesség: a fordító ezesetben átfordítja az előző változatra. pl t[2]-ből *(t+2) lesz)Dinamikus helyfoglalás: adott a probléma: fordítási időben meg kell adnunk, hogy mekkora lesz a tömbünk mérete. Viszont, ha ez az érték csak futási időben derül ki, mert pl a felhasználó fogja megadni, akkor dinamikusan, azaz futási időben kell a tömböt lefoglalni. Módja 1 dimes tömb esetén:
- 1 deklarálni egy megfelelő típusú pointert, ami majd a tömb első (azaz 0.) elemére fog mutatni
- malloc-kal lefoglani n db, a fenti pointer által mutatott típusnak megfelelő méretű, folytonos memória területet
- a pointer típusára konvertálni a malloc által visszaadott pointert (ha valakit érdekel miért kédezzen rá, de nem igazán ez a szint, szerintem)
pl:int *p, n = 0;
//... n értéket kap
p = (int*) malloc (sor * sizeof (int));
Ha pl int helyett float kell, akkor 3 (azaz három) helyen kell cserélni a típust: a pointer deklarációjánál, a sizeof paraméterében (ez adja meg, hogy mekkora helyet foglal 1 adott típusú változó), illetve a malloc elött.
Esetleg célszerű egy if ágban lekezelni, hogy sikeres volt-e a hely lefoglalása:
if ( (ppt = (int*) malloc (oszlop * sizeof (int)) ) == NULL)
{ printf ("nincshely");
exit (1);
}//if
A fenti kód megpróbál oszlopnyi int-et lefoglalni, ennek első elemre mutató pointerét értékül kapja a ppt. Ezt utána megvizsgálunk, hogy NULL-e (ez az ami nem mutat sehova, vagyis nem sikerült lefoglalni), ha NULL, akkor a hibáról értesítjük a felhasználót és 1-es hibakóddal termináljuk (befejezzük) a program futását.
Memória felszabadítása: az általunk malloc-kal lefoglalt memóriát senki sem fogja felszabadítani, így ha már nincs rá szükségünk, vagy ugyanazt a pointert akarjuk használni egy újabb terület lefoglalásához, akkor elötte kötelező felszabadítani a memória területet, illetve célszerű a pointernek a NULL értéket adni. Ha az elöbbit elfelejtjük a programunk elszívárogtatja a memóriát (memoryleak). A felhasználó ebből azt veszi észre, hogy minnél többször futtatja a programunkat, annál több szabad hely fogy el, amit a program lefutása után nem kap vissza. A második inkább csak biztosági szempontok miatt szükséges, nehogy valaki véletlenül (esetleg rossz akaratúak direkt) a már felszabadított memória területről próbáljanak olvasni, esetleg írni (amivel más adatai írodnak felül) Fontos: NE felejtsük el felszabadítani a lefoglalt területet!
Felszabadítás: free(pointer); //ahol a pointer egy dinamukusan lefoglalt
memória terület kezdőcíme
Tényleg ne maradjon le az a free! Nem lehet elég sokszor hangsúlyozni.Több dimenziós tömbök: az egyszerűség kedvéért csak 2 dimes tömb, de ez alapján könnyen megoldható magasabb dimszámra is. (ugyanazt kell elvégezni még annyiszor, amíg el nem érjük a kívánt dim-et, ami alább következik)
Megvalósítás(elmélet): 2 dimes tömböt c-ben csak úgy tudunk megvalósítani, hogy létrehozunk egy tömböt, amely minden eleme a 2 dimes tömb egy sorára mutat.
Pl: 3x4-es tömb: van egy 3 elemű tömbünk, amelynek minden eleme egy-egy 4 elemű tömb első elemére mutat. Szemléletesen (a mutatást a -> jelőli)
_
|_| --------------> |_|_|_|_| első sor
|_| --------------> |_|_|_|_| második sor
|_| --------------> |_|_|_|_| harmadik sorTömbben lévő értékek elérése: mesélve: először (a fenti 3x4-es pl-nél maradva) a 3 elemű tömbben kell megkeresni a kiválaszotott sort tartalmazó tömb címét. Ezután elugrani erre a címre és a megadott oszlop elemének címét meghatározni.
Konkrét pl-en: próbáljuk meghatározni a fenti tömb (szokásos indexeléssel) a 3. sor 2. oszlopában lévő elemet. Ekkor először meg kell tudnunk a 3. sort tartalmazó vektor címét, vagyis t[2]-t (==t[3-1]). Ezután már csak a 2. oszlop elemét kell venni, vagyis t[2][1] (ld. előbb). Megvalósítás a pointer eltolásos technikával, inkább csak érdekesség képpen: a 3. sor címe: *(t + 2), az így megkapott vektor a 2. elemének értéke: *( *(t + 2) + 1)
2 dimes tömb lefoglalása: a fenti szemléltető ábrán is (remélhetőleg) jól látszik, hogy 4 (azaz négy) darab tömböt kell lefoglalnunk, melyek a memóriában "bárhol" lehetnek (az össz megkötés annyi, hogy a tömb elemei egymás után jönnek):
- 3db 4 elemű tömböt (vagyis lesz 3db pointerünk)
- 1db 3 elemű pointereket tartalmazó tömböt (vagyis ennek típusa pointereket tartalmató tömb, ami viszont szintén egy pointer, vagyis 2db csillag kell deklarációnál)
Pl:
//2 dimes tömb lefoglalása
int **ppt, sor, oszlop, i,j;
//.. értékadás a sor-nak és az oszlop-nak
//első rész lefoglaljuk az oszlop vektort, ami majd tárolja a
sorok címeit
if ( (ppt = (int**) malloc (sor * sizeof (int*)) ) == NULL)
{ printf("nincshely");
exit(1);
}//if
//második rész lefoglaljuk egyesével a sorokat
for (i = 0; i < sor; i++)
if ((ppt[i] = (int*) malloc (oszlop * sizeof (int)) ) == NULL)
{ printf ("nincshely");
exit (1);
}//if
//for//2 dimes tömb bejárása:
for(i=0;i<sor;i++)
{
for(j=0;j<oszlop;j++)
{
ppt[i][j]=j; //itt tetszüleges int állhat; értékadás
printf("%d ",ppt[i][j]); //érték "lekérése"
}//forj
printf("\n");
} //fori//2dimes tömb felszabadítása:
for(i = 0; i < sor; i++)
free(ppt[i]);
free(ppt);Pont úgy ahogy a fenti pl-nél maradva 4 tömböt kell lefoglalni 4-et is kell felszabadítani!
2 dimes tömb megvalósítása 1 dimes tömbbel: a 2 dimes tömb felfogható úgy is, hogy egymás után írjuk a sorait, így egy 1 dimes tömböt kapunk. A korábbi 3x4-es pl, így egy 1x12-es vektorra módosul. Egyetlen "probléma", hogy hogyan lehet kiszámolni a harmadik sor második elemének indexét. A megoldás nagyon egyszerű, csak végig kell gondolni mi történt az eredeti tömbbel (a szokásos indexelést használva): leírtunk egymás után 2 sort (2 * 4 elemet), majd a 3. sort megkezdve leírtunk még 2 elemet, vagyis meg is lett a 3.sor 2. eleme. (persze a többit is leírtuk, de az index kiszámításához nincs rájuk szükség) Vagyis mostmár általánosan: az x-edik sorhoz elötte el kell mennünk x-1 sor elemein, majd az x. sor elemei közül még az y-adikig. Legyen mondjuk minden sorban n db elem, ekkor az x-edik sor y-adik eleme: (x - 1) * n + y. Már csak azt kell végig gondolni, hogy a c féle 0-tól való indexelés változtat-e valamit vagy sem. Vagyis, ha a (innentől már a c-s indexelés) 0. sor 1. (ami nálunk az 1 sor 2. eleme) elemének az indexét kell meghatároznunk, akkor az 0 * n + 1 indexű lesz, ha az 1. sor 3. eleme 1 * n + 3, vagyis általánosan x-edik sor y-adik eleme: x * n + y.
Magasabb szinten, esetleg optimalizáláskor jöhet jól, ugyanis ezzel a módszerrel a tömb tetszőleges eleme 1 lépésben megkapható, míg a korábban leírt változattal csak 2 lépésben
Több dimenziós tömbök: csak vázlatosan: vizuális típusú embereknek: téglapból (XxY) úgy lehet téglát(XxYxZ) készíteni, hogy az (x,y) koordináta "fölé is teszünk 1 vektort(magasság)". Ezesetben ugyanúgy lesz 1 tömbünk, ami a sorokra mutató pointereket fog tartalmazni, viszont a sorok most szintén pointereket fognak tartalmazni, ezek lesznek az (x,y) helyen a fölé tett vektorra mutató pointerek. Vagyis lesz 1db X elemű tömb(int***), amiben lesznek a sorokra mutató pointerek (int**), lesz Xdb Y elemű vektor(int**), amik a magasság vektorokra mutató pointereket (int*) tartalmaznak és lesz X*Ydb Z elemű vektor (int*), ami tartalmazza a magasság adatokat (int).
Másként lehet úgy is nézni, hogy van egy vektorunk, aminek minden elem 1-1 két dimes tömbre mutat. Magasabb dim-ek ezzel a rekurzióval előállíthatók, vagy alkalmazható a fenti dim csökkentő módszer, bonyolultabb képlettel.Láncolt listák: mese: aki érti a 2 dimes tömböknél történteket, annak ez sem jelenthet gondot. A láncolt lista azt az ötletet használja fel, amit a sorok címének meghatározására használtunk fel. Viszont itt azt szeretnénk, hogy tárolhassunk a pointer mellett még adato(ka)t, illetve ne egy sorra mutasson a pointer, hanem egy másik ugyanilyen elemre. Ilyen adatszerkezetet használnak, akkor ha pl nem tudjuk előre, hogy mennyi adat lesz és a felhasználó sem tudja előre. Béna példa: mennyi madarfajt tudsz felsorolni? Ezt a példát tovább víve, a listában tárolandó adat a madárfaj neve, a pointer értéke kezdetben NULL, aztán ha a felhasználó megad egy újabb madárfajt, akkor dinamikusan létrehozunk még egy ilyen lista elemet, és ennek címét állítjuk be az előbb említett pointernek. Célszerű egy külön pointerben eltárolni a lista első elemét (fej/fej elem), és bejáráskor egy másik pointerrel (akt) végig menni rajtuk. (így nem veszik el az eleje)
Megvalósítás: szükséges hozzá tudni mi az a struct! A lista típusa egy struct lesz, ami lehetővé teszi, hogy adatokat is tárolhassunk és mutathassunk egy másik azonos típusú struct-ra.
Saját structunk létrehozása, illetve a fej deklarálása:
typedef struct madarFaj
{
char nev[30];
struct madarFaj *kov; // kov pointer madarFaj típusú
struktúrára
}MADARFAJ; //létrehoztuk a MADARFAJ nevű típust
MADARFAJ *fej, *akt;
char madarFajNeve[30];Új létrehozása és értékadások:
//ciklusban madárfaj bekérése
MADARFAJ p = (MADARFAJ*) malloc (sizeof (MADARFAJ) );
//új listaelem lefoglalása
p->nev = madarFajNeve; //elmentjük a faj nevét
p->kov = NULL; //még nincs következő lista elem, ezért nem mutat sehova sem
akt->kov = p; //hozzá fűzzük a listához az új elemet.Fontos: mivel a lista elemei is dinamikusan lefoglalt memória terültetek, ezért egyesével végig kell menni minden lista elemen és fölszabadítani!
akt = fej;
while (akt != NULL) //amíg van elem a listában
{
MADARFAJ *p = akt; //elmentjük az aktuális listaelem címét
akt = p->kov; //az aktot a következő elemre állítjuk
(felszabadítás után nehéz lenne)
free(p);
} -
kingabo
őstag
válasz
Korcsii
#2301
üzenetére
"i, i-1 és/vagy i+1 is létezzen"
Jobban mondva ezek az indexek is a tömbön belül legyenek: legalább 0 és legfeljebb n-1, ha n elemű a tömb."különben szépen elszáll a program..."
Miért szállna el? Nagy valószínűséggel csak memória szemetet hasonlítgatna, ha dinamikusan lett lefoglalva a tömb, ha nem akkor a veremben elötte/utána lévő dolgokat. A c, c++ nem figyeli, hogy tömbön belül indexeltél-e. (pl a pascal-lal/ada-val ellentétben) Esetleg, ha nagyon rossz helyre menne, az oprendszer nem hagyja. c++-ban acces vialation kivételt dob ha jól rémlik, c alatt passz -
#2301
Korcsii
őstag
[pod]Diablo
#2300
Korcsii
őstag
válasz
[pod]Diablo
#2300
üzenetére
if (t[i] < t[i+1]) printf("az i+1 nagyobb");
kétlem, hogy ennyire egyszerű lenne a kérdés, de amit kérdeztél, az így valósítható meg... csak épp vigyázni kell, hogy az i, i-1 és/vagy i+1 is létezzen, különben szépen elszáll a program... ha mindez esetleg egy ciklusba kerül, akkor meg főleg....
Úgy értem nem kéne minden futtatásnál más számokat kapjak a tömb ugyanazon elemére?
)
A for ciklust akkor szokás használni, ha tudod, hogy hányszor kell lefutnia, mert pl a file első sorában megadod a sorok számát, egyébbként a while. A probléma is ehhez köthető. A ciklus magod össz vissz ennyit tartalmaz: 
Tehát amit beolvas a file-ból az semmi?
Én meg kétszer is megnéztem mit akarsz mire rájöttem. 
. Jó hogy mondod ezeket a dolgokat: printf("%s","*"); helyett printf("\*");
.
![;]](http://cdn.rios.hu/dl/s/v1.gif)
Kicsit bővebben, a ciklusban a c1 a bekért betű ascii kódját fogja tárolni (vagyis ha nem %c-vel íratod ki, hanem %d-vel akkor a betű helyett az ascii kódja kerül a képernyőre). Az ascii kódot pedig szépen fel tudod használni egy tömb indexelésére. Pl a szám tömb indexeléséhez:
Új hozzászólás Aktív témák
Hirdetés
● olvasd el a téma összefoglalót!
● ha kódot szúrsz be, használd a PROGRAMKÓD formázási funkciót!
- Óra topik
- Eredeti játékok OFF topik
- Kerékpárosok, bringások ide!
- Az Oppo Find X8 Ultra lett a legvékonyabb kameramobil
- Hardcore café
- Xiaomi 14 - párátlanul jó lehetne
- MotoGP & WSBK
- HDD probléma (nem adatmentés)
- Milyen asztali (teljes vagy fél-) gépet vegyek?
- Google Pixel topik
- További aktív témák...
- Lenovo ThinkPad T14 3 Gen 16/256GB SSD, Újszerű, 1 Év Garanciával
- Xiaomi 15 Ultra 512GB, Kártyafüggetlen, 1 Év Garanciával
- Samsung Odyssey OLED G8! 32"/4k/240hz/0,03ms/10BIT/Freesync-G-sync/HDMI 2.1/Smart Monitor
- Új 512GB WD SN5000S Gen4 x4/ Steam Deck ready/ garancia/ ingyen fox
- i7 8700/ RX6500/ 32GB DDR4/ 512GB m.2/ garancia/ ingyen foxpost
- Telefon felvásárlás!! iPhone 14/iPhone 14 Plus/iPhone 14 Pro/iPhone 14 Pro Max
- BESZÁMÍTÁS! ASRock B460M i5 10400 16GB DDR4 512GB SSD RTX 2060 Super 8GB Rampage SHIVA TT 500W
- Xiaomi Redmi Note 11 Pro 128GB, Kártyafüggetlen, 1 Év Garanciával
- Külföldi csomagszállítás Packeta csomagpontokon keresztül!
- Telefon felvásárlás!! Apple iPhone SE (2016), Apple iPhone SE2 (2020), Apple iPhone SE3 (2022)
Állásajánlatok
Cég: Promenade Publishing House Kft.
Város: Budapest
Cég: PC Trade Systems Kft.
Város: Szeged