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ó?

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.

[ Szerkesztve ]

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

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.

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!!!

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) , "%" );

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. 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.

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 ...

É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

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.

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.

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!

Üdv!

Tudtok ajánlani jó programozási könyvet C/C++ kategóriában? (C-ből Kernighan - Ritchie könyvét ajánlották eddig (1. hszből) )

Illetve, ha most tanulom a C#-ot, melyikkel érdemes először foglalkozni? (C alapabb lenne, de sajnos így se ő lesz az első )

nem volt hozzá szerencsém, de tényleg mindenki azt ajánlja... abból is az ISO szabványok szerint újraírt verziót... a neten is kering valahol, de most meg nem mondom honnan érhető el...

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

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)...

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

[ Szerkesztve ]

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...

[ Szerkesztve ]

Ha ehhez a megoldáshoz ragaszkodsz, akkor tomb[sor][oszlop]=tomb2 helyett inkább strcpy-val kellene.

persze a * nem kell az elejére, hülyeséget írtam, sry...
a lényeg, hogy a számokkal ellentétben sztringeknél kell egy 3. dimenzió is, mivel a string az egy char tömb, így azt is kell indexelni...

kingabo: strcpy jó, csak épp semmi nem létezik, amit neki adni kéne...

[ Szerkesztve ]

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?

Hát kossz szépem igazad volt. a 3dimenziós tombbel ugy tényleg mukodik...
csak ezt elmondod hogy ebben a háromdimenziós tombben a harmadik dimenzióba mit tárol?

"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?

[ Szerkesztve ]

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 helye

pl
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...

egy sehova nem mutató pointer-be nem tudom, hogy mit tud beolvasni egy fájlból... sok értelmes dolgot szerintem nem... a cél szintén nem létezik, szóval...

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.

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.

[ Szerkesztve ]

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?

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...

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 pl

szerintem a legjobb megoldas altalanos beolvasasra az, hogy getline-al beolvasol egy egesz sort es aztan szetszeded komponensekre az adott feladat szerint

Nem vagyok egoista, csak uborkagyalu!

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;
}

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

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.

[ Szerkesztve ]

Sk8erPeter

Oxika

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?

%e >> %f

tmp2++; >> tmp++, és tmp-vel kéne visszatérni.

Thank you to god for making me an atheist

%e, %f hiába minden még mindig rossz...

%lf -el probaldd
a kerekit fuggveny kicsit egyszerubben/rovidebben:

int kerekit (double szam)
{
double maradek = szam - (int)szam;
return (maradek >= 0.5) ? (int)(szam + 1) : (int)szam;
}

[ Szerkesztve ]

some men just wanna watch the world burn...

Ja igen, %lf akart lenni, mert double.

Thank you to god for making me an atheist

Hehe a te verziód kicsit rövidebb
Lefutott, de ezt amúgy nem értem miért lehetett probléma. Amennyire én tapasztaltam az %lf, %g, %e, %f között csak a kiírásban volt különbség. Melyiket érdemes használni? Valaki pár mondatban összefoglalná a különbséget?

Kolléga írta, szintén kőbalta avatárral. Az eEfgG (uazok) floatnál lett volna jó, így meg azért lf kell,mert a 'szamm' változód double típusú.

Thank you to god for making me an atheist

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?

A rand() % n függvény nem kéne random legyen? Úgy értem nem kéne minden futtatásnál más számokat kapjak a tömb ugyanazon elemére?

int main(){
int i, *ar;
ar=(int*)malloc(100*sizeof(int));
for(i=0;i<100;i++){
*(ar+(i*sizeof(int)))=rand() % 1000 +1;
}
printf("%d", *(ar+sizeof(int)*2));
}

Elszáll mint a szó.. nem tudom miért. Hibakódot se dob...

Rakd bele ezt a részt a változok létrehozássá után:

srand(time(NULL));

Üdv KLtz

Hiába minden még mindig hibát dob. Ráadásul a time függvényt nem is ismeri, hiába adtam hozzá az stdlibet...

Elfelejtettem ,hogy a time.h is hozzá kell adni! De nekem e-nélkül is ment.

Üdv KLtz

Ment? Lefuttattad a kódom és ment? Akkor nálam lesz valami nagy gond..