Szia! Köszi szépen a tanácsot őszintén szólva van más programozós fejlesztői környezet is már a gépemen DevC++ is . Csak sajna suliba Eclipsbe kell zh-t írnunk majd ezért gondoltam jobb ha már most hozzá szokok a használatához.

Átírtam volna a forráskódot a gépemen anno, de már nem értem hol rejlik a hiba és egyedül nem is fogom megtudni soha....

Szia! Jó tanács, ha nem tudsz helyesen írni és megtanulni se már. Használd pl a Word nyelvi ellenőrzőjét. Nem bántásból mondom nekem is mindig rossz volt a helyesírásom, habár a nyelvtani szabályokat tudtam. Tollbamondásra legjobb esetben is csak hármast kaptam.
Szóval, ha fontosabb helyekre vagy nyilvános helyre írok én is mindig Wordbe ellenőriztettem előbb.

Így ebben a bejegyzésbe is legalább már 4 hibát kiszűrtem, de még ígyis maradt benne biztos.

[ Szerkesztve ]

Átírtam volna a forráskódot a gépemen anno, de már nem értem hol rejlik a hiba és egyedül nem is fogom megtudni soha....

Nekem is lenne itt egy feladatom:

A vb hangja
„KO-RE-A, KO-RE-A” – kiabálta 54 000 boldog futballszurkoló, miután csapatuk a hazai rendezésű világbajnokságon bejutott az elődöntőbe. Izgatottságuk dacára azonban a koreai emberek természetüknél fogva nagyon szervezettek. Például hatalmas, hajókürthöz hasonló hangú trombitákkal szurkoltak a pályán játszó csapatuknak. A szurkolók egy állandó zajszintet szeretnének fenntartani a meccs teljes ideje alatt.
A trombiták sűrített levegővel működnek, azonban ha 2 másodpercig folyamatosan fújják őket, elromlanak. Ezért amikor a trombita hangot ad, minden rendben van, de a trombitahangok szüneteiben a szurkolóknak a „KO-RE-A” kiáltást kell harsogniuk.
A mérkőzés előtt egy szurkolócsoport összegyűl és eldönti a kiáltás mintáját. A minta 0-k és 1-esek sorozata, amelyet a következőképpen értelmezünk: ha a minta 1-es, akkor a trombita kerül megfújásra, ha pedig 0, akkor a „KO-RE-A” kiáltás következik. Annak érdekében, hogy a trombiták nehogy elromoljanak, a minta nem tartalmazhat két egymást követő 1-est.
Ebben a feladatban tehát egy adott, pozitív egész n-re meg kell határozni az ilyen hosszúságú kiáltási mintákat, vagyis azon n bites sorozatok darabszámát, amelyek nem tartalmaznak egymás melletti 1-eseket. Például n = 3 esetén a megoldás 5 (a 000, a 001, a 010, az 100 és az 101 sorozatok elfogadhatóak, míg a 011, az 110 és az 111 nem).

Input
Az első sor a tesztesetek számát tartalmazza. Az első sort követő sorok mindegyike egy-egy tesztesetet ír le. Minden teszteset egy olyan sor, amely egyetlen, 51-nél kisebb egész számot tartalmaz.

Output
Minden teszteset kimenete egy olyan sorral kezdődik, amely a „Scenario #i:” szöveget tartalmazza, ahol i a teszteset sorszáma. A tesztesetek sorszámozása 1-től indul. Ezt követően egy újabb sorba kell kiírni az egymás melletti 1-eseket nem tartalmazó n bites sorozatok darabszámát. Minden teszteset kiírását egy üres sorral kell lezárni.

Példa input
2
3
1

Példa output
Scenario #1:
5

Scenario #2:
2

Ez elsőre inkább kombinatorikának tűnik, mint programozási feladatnak...

Kombinatorikailag megy? (nekem elsőre nincs jó ötletem)

AE

[ Szerkesztve ]

Csinálok egy adag popcornt, és leülök fórumozni --- Ízlések és pofonok - kinek miből jutott --- Az igazi beköpőlégy [http://is.gd/cJvlC2]

hmm... elkezdtem kézzel, és nekem egy Fibonacci sor jött ki... az előzőt mindig megismételheted egy 0-t az elejére írva, majd jön az előtte lévő, 10-t elé írva...

hova jársz?

[ Szerkesztve ]

Sziasztok!

Van egy ekkora számom:
700.000.000.000 (7 billió ~ azt hiszem. )

Kérdésem ez mekkora változóba fér bele? Ennél nagyobb már nem lesz, csak kisebb (osztással).

32 bites rendszeren long long, 64 bitesen eleg a long. lasd: limits.h

Nem vagyok egoista, csak uborkagyalu!

Köszön szépen a long longra volt szükségem. A listát könyvjelzőztem.

Kellene még egy kis segítség, legalább, hogy merre induljak.

Adott egy szam, egy ujszam1 és egy ujszam2 változó.

Azt kellene elérni, hogy az ujszam1 a szam változó első három karaktere legyen.
Az uj szam2 az utolsó három karaktere, csak megfordítva.

Pl:

(összesen hat karakteres a szam változó):

szam = 300003
ujszam1 = 300

ujszam2 = 300 (a 003-ról megfordítva).

Valakinek ötlet? Tömbbel kell karakterenként beolvastatni? Vagy van egyszerűbb mód?

fix 6 hosszú, vagy bármekkora lehet?

fix 6 hosszú

ujszam1 = szam / 1000;
ujszam2 = ((szam % 10) * 100) + (((szam % 100) / 10) * 10) + ((szam % 1000) / 100);

ui: preferencia rulz, tudom

Köszönöm, ez a megoldás eszembe se jutott.

Viszont csak nem akar működni a programom.

Elkezdtem C tanulni és azt tanácsolták, hogy mellette nézegessem a Project Euler oldalt. Ott akadtam el a negyedik feladatnál. Az eredmény 580085 lesz, amit nem fogad el az oldal (projecteuler.net). Mi lehet a probléma? (Lehet, hogy meg lehetne egyszerűbben és szebben is oldani, de kb. 2 hete C-zek, szóval ne bántsatok ezért. )

/*
============================================================================
Name : pe4.c
Author : Ödön Tóth
Version : 1.0
Copyright : GPL
Description : Project Euler

A palindromic number reads the same both ways. The largest palindrome made from the product
of two 2-digit numbers is 9009 = 91 × 99.
Find the largest palindrome made from the product of two 3-digit numbers.
============================================================================
*/


#include <stdio.h>

int main()
{
int szam1=100, szam2=100, i;
long szamuj, szamuj_bal, szamuj_jobb, p1=0, p2=0;
for(szam1=100; szam1 <= 999; szam1++)
{
szamuj = szam1 * szam2;
//szétszedés
szamuj_bal = szamuj / 1000;
szamuj_jobb = ((szamuj % 10) * 100) + (((szamuj % 100) / 10) * 10) + ((szamuj % 1000) / 100);
if(szamuj_bal == szamuj_jobb)
{
p1 = szamuj;
}
for(szam2=100; szam2 <= 999; szam2++)
{
szamuj = szam1 * szam2;
//szétszedés
szamuj_bal = szamuj / 1000;
szamuj_jobb = ((szamuj % 10) * 100) + (((szamuj % 100) / 10) * 10) + ((szamuj % 1000) / 100);
if(szamuj_bal == szamuj_jobb)
{
p2 = szamuj;
}
}
}
if(p1 > p2)
{
printf("A keresett szám: %d", p1);
}
else
{
printf("A keresett szám: %d", p2);
}
return 0;
}

[ Szerkesztve ]

szam1 <= 999 * 100 az nekem akárhogy is számolom, 5 számjegyű...

n! means n (n 1) ... 3 2 1

For example, 10! = 10 9 ... 3 2 1 = 3628800,
and the sum of the digits in the number 10! is 3 + 6 + 2 + 8 + 8 + 0 + 0 = 27.

Find the sum of the digits in the number 100!

Hogyan tudok eltárolni egy ekkora számot?

eulert nem ismerem, de ha programozos problemak kellenek akkor:

topcoder: tobb kategoriaban lehet versenyezni, en az algorithm-et probaltam. hetente vannak versenyek ahol 3 peldat kell megoldani ha jol emlekszem masfel ora alatt. ket kategoria van, a nehezebbik eleg durva meg lehet nezni masok megoldasait, amibol sokat lehet tanulni. lehet a versenyen kivul is megoldani a peldakat, valaszthato nyelvek c++, c# es java

spoj ezt nem ismerem, de szoktak ajanlani, ez nem verseny, hanem kulonbozo nehezsegu feladatok gyujtohelye.

RexpecT: bignum library kell hozza, neten lehet talani, vagy irsz sajatot

Nem vagyok egoista, csak uborkagyalu!

Ez miért nem jó?

#include <stdio.h>
#include <stdlib.h>
void line(char ch, int n)
{
int i;
for(i=1;i<=n;i++)
printf("%c \n",ch);
}
int main()
{
line("-",50);
line("*",8);
system("PAUSE");
return 0;
}

[ Szerkesztve ]

printf("%c \n",ch); helyett printf("%c",ch);

[ Szerkesztve ]

line("-",50); helyett line('-',50); ?

system("PAUSE"); - ezt meg keruld.

some men just wanna watch the world burn...

Igen ez volt a baj .
system("PAUSE"); - ezt meg keruld. --> Ezt tudom, hogy nem jó(bár eddig hibát nálam nem okozott).Az alternatíva amit javasoltatok annak idején meg nem működött.

Itt van hogy mi miatt.

Ahogy látom a getchar(); is egy megoldás erre a problémára.

fflush(stdin);
getchar();

a fflush(stdin); se epp a legszebb dolog. idezet a szabvanybol:

#include <stdio.h>
int fflush(FILE *stream);

Description

If stream points to an output stream or an update stream in which
the most recent operation was output, the fflush function causes any
unwritten data for that stream to be delivered to the host environment
to be written to the file; otherwise, the behavior is undefined.

persze ez nem jelenti, hogy xy fordito nem implementalja, viszont ha forditofuggetlenek szeretnenk lenni, akkor illik nem hasznalni.
a masik dolog, hogy ezt altalaban scanf utan szokas hasznalni, mert az sok esetben otthagy valamit az input streamen. ha viszont egyaltalan nem hasznalunk scanf-et (ami szerintem jo otlet), nem kell a fflush se.

Nem vagyok egoista, csak uborkagyalu!

Ti milyen GUI-t használtok C programokhoz?

Sziasztok!

Elég kezdő vagyok még programozásban, pontosabban kb 3-4 napja kezdtük el.. Remélem jó helyre teszek fel 1-2 kérdést..
- hogyan lehet 1 szám valahányadik hatványát venni?
- hogyan lehet PI konstanssal számolni a program során?

Egyelőre ennyi lenne!

Köszi előre is!

Üdv!

pow(mit, hanyadikra);

M_PI, ami a math.h-ban van benne...

Mmint az IDE-re gondolsz?
Legtöbbször szövegszerkesztőben pötyögök csak. Mondjuk nem is írok komoly progikat. Ha mégis akkor Eclipse-t.

Picit értetlenül állok a kérdéseid előtt. Ha 3-4 napja tanulod, akkor lehet hogy inkább algoritmus szintjén kell meghatározni a hatványt és a pi értékét?

Standard C-ben a math.h tartalmazza ahogy olvashattad. Nemtudom hogy ez mond-e neked valamit (3-4 nap után nem tudom hogy az #include-ot tanultátok-e)

Algoritmus szintjén pedig triviális. (Összeszorzod az alapot annyiszor amennyi a kitevő. A pi pedig a kerület és a sugár hányadosa.)

Persze a változók értékhatárai problémát okozhatnak. Lehet hoyg épp az a célja az oktatónak hogy ezt bemutassa.

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

Nem. IDE-nek az Eclipse-t használom. Még én is csak tanulom a C nyelvet. Előtte Pythonnal foglalkoztam és ott a Tkinter-t használtam. Itt mit használunk, ha grafikus programot akarunk írni.

1/5. feladat
Készítsen programot, amely kiszámítja a henger felszínét és térfogatát, ha adott a henger magassága és az átmérője. Nézze meg a HELP-ben és használja az M_PI rendszer konstansot !

Nem tudtam sajnos magamtól, vagyis az M_PI-t sejtettem, a math.h-nak utánaolvastam.
A négyzetes dolog nem lett volna kötelező, de most igazából szerintem mind1, hogy ezt most tanultam meg, vagy később vmikor.. Eddig 1 gyakorlatom volt, meg 2 előadás..

[ Szerkesztve ]

Írnék egy C programot, de van egy hiba, aminek nem találom az okát már vagy másfél órája.
Itt a forrás (egyelőre csak egy példa, úgymond vázlat program, erre épülne majd egy jóval bonyolultabb):

...
int b=1;
char c;
...
while(b==1)
{
c=getchar();
switch(c)
{
case '1':
{
i=1;
printf("The number is %i\n",i);
b=0;
break;
}


case '2':
{
i=2;
printf("The number is %i\n",i);
b=0;
break;
}

case '3':
{
i=3;
printf("The number is %i\n",i);
b=0;
break;
}

case '4':
{
i=4;
printf("The number is %i\n",i);
b=0;
break;
}

default:
{
printf("That is not a menu option, please try again: ");
b=1;
break;
}

}
}

A problémám az lenne, hogy a default parancsai duplán hajtódnak végre. Mindig duplán írja ki a "That is not a menu option, please try again: " szöveget. Megpróbáltam írni a getchar() elé és mögé egy szöveget printf-fel, de a defaultra azokat is duplán írta ki, jól láthatóan egyszer átugrotta a getchar()-t. Próbáltam kivenni a ciklusból a ciklus elé és újra betenni a defaulthoz, de úgy is szimplán átugrotta egyszer. Nem értem, de nagyon nem. Próbáltam getchar() helyett scanf()-et is, de azt is átugorja egyszer, így annál is dupla lesz a default végrehajtódása. Mitől lehet ez?

[ Szerkesztve ]

Erkölcstelen csíkot húzni a másik krumplifőzelékébe csak azért, hogy legyen egy szünet.

Használnod kellett volna egy debuggert és jól megnézhetted volna, mi a c értéke:

Breakpoint 3, main () at t.c:10
10 switch(c)
(gdb) p c
$1 = 53 '5'
(gdb) c
Continuing.

Breakpoint 3, main () at t.c:10
10 switch(c)
(gdb) p c
$2 = 10 '\n'

Így már érted, vagy magyarázzam még?

Jester

Azt hiszem fogalmam sincs, hogy mit is írtál, de azt látom, hogy nem C kód, debuggerekről meg eddig csak hallottam (és még érthető leírás sincs semelyik használatáról sehol). C-vel sem volt dolgom múlt hétig, csak Turbo Pascallal és Pythonnal (előbbiből emelt szintű érettségiig, utóbbival autodidakta módon), de sose használtam semmilyen debuggert.
Szóval ebben a formában ha csak nem adsz egy leírást a debbuggerek használatáról az alapoktól, nem veszem hasznát egy breakpointnak.
Egyébként megnéztem a gdb-t, de magas.

Arra viszont rájöttem, hogy ha a default eset fut le, a c értéke kiürítődik ahelyett, hogy bekérné a getchar() és emiatt a második default futás, hisz a c üres. De hogy az elsőnél miért ugorja át a getchar()-t, azt lenne jó tudni. A c értéke ettől független, az egészen addig a pontig pont annyi, amit a getchar() bekér, amíg a default eset végre nem hajtódik, ott válik valahogy üressé (nincs törlésre utasítás, sőt ha értéket adok neki a printf előtt, akkor az az érték megmarad, de mégis duplán fut a ciklus), majd a ciklus újrafutása mellőzi a getchar()-t. Az alapján, amit a programozásról tudok, ez lehetetlen, egy program nem hagyhat ki csak úgy parancsokat, ha csak utasítást nem kap rá. De itt nincs ilyen, a default esettel vissza kéne mennie a ciklus elejére, ahol a getchar()-nak ismét kérnie kéne a karakterét. De ez nem történik meg egyszer, csak második futásra.

[ Szerkesztve ]

Erkölcstelen csíkot húzni a másik krumplifőzelékébe csak azért, hogy legyen egy szünet.

De, a te C kódodat futtattam. Egy debuggert mihamarabb meg kellene tanulnod, mert azzal tudod a saját programhibáidat felderíteni. gdb-ben nagyjából 8 paranccsal kiválóan el lehet boldogulni (break, run, step, next, continue, print, x, exit) vagy használhatsz valamilyen grafikus felületet.

Jelen esetben abba futottál bele, hogy a standard input az soronként pufferelt továbbá a getchar szorgalmasan visszaadja a sorvég jelet is. Én például azt írtam be, 5<enter>. Ezt a gép úgy dolgozza fel, hogy az első getchar hívásnál látja, hogy nincs semmi a bemeneti pufferben, tehát beolvas egy egész sort, majd visszaadja az első karaktert (az 5-öt). Erre lefut a switch-ed majd visszamegy a ciklus miatt a getchar-hoz. Ezúttal viszont van még a pufferben valami, mégpedig a sorvég jel, tehát a getchar nem vár és azt adja vissza. Ez ismétcsak a default ágra jut. Hasonló történik akkor is ha másik ágra futsz, a pufferben még mindig benne lesz a sorvég illetve bármi amit a felhasználó még elé írt. Ezt a következő beolvasás vissza is fogja adni.

Ezért tehát mindig célszerű a teljes sort beolvasni majd igény szerint feldolgozni. Például mi legyen, ha a felhasználó 11-et ír be.

Jester

Értem már! Windows alatt ezt egy _flushall() megoldja, de Linux alatt nem ismeri, és ahogy nézem Google-ben, nem is létezik hasonló. Vagy igen?
Egyelőre viszont akkor megoldottam úgy, hogy if(c!='\n'), ebbe ment a switch, utána pedig bekerült egy while(getc(stdin)!='\n'){}, így csak az első karakter marad.
Nem szép és nem dolgoz fel több karaktert, hogy azt is visszajelezze hibás megadásként, de ezzel megkerültem a hibát. Persze jó kérdés mi lenne akkor, ha egy stringet kéne így feldolgoznom. Próbáltam átírni úgy, de valamiért minden karaktere a string-nek (null) lett. De erről még úgyis olvasok később, egyelőre egy karakter elég.

[ Szerkesztve ]

Erkölcstelen csíkot húzni a másik krumplifőzelékébe csak azért, hogy legyen egy szünet.

Igaz én is csak kezdő vagyok, de azt hiszem a fflush(stdin) parancs erre jó. Ha mégsem, valaki javítson pls.

Az fflush a szabvány szerint csak kimeneti streamre van definiálva, bár tény, hogy manapság a legtöbb rendszeren bemenetre is működik.

Jester

Windows alatt működik, de Linuxon nem.

Erkölcstelen csíkot húzni a másik krumplifőzelékébe csak azért, hogy legyen egy szünet.

Ahogy Jester01 ajánlotta sort olvass be, amit az atoi-val (ascci to int) alakíts át számmá és ennek az eredményét vizsgáld a switch-ben. Elötte persze ellenőrizni kell, hogy mit adott vissza az atoi: pl 11a esetén 11-t, a esetén 0-t (de 0 esetén is 0-t ad vissza, ami jó!), ilyenkor nyilván újra be kell kérni.

[ Szerkesztve ]

atoi, köszönöm! Akkor meg is van egyelőre, egy !c[1] feltétellel pedig azt is elértem, hogy például az 1a-t ne tekintse 1-nek és ne fogadja el. Eszerint már tudom módosítani, ha később kétjegyű számok is bekerülnek a képbe.

[ Szerkesztve ]

Erkölcstelen csíkot húzni a másik krumplifőzelékébe csak azért, hogy legyen egy szünet.