Négyzetszámok
Írj programot, amely kiírja az első N darab négyzetszámot! N értékét kérd a felhasználótól!
Írd ki a képernyőre az összes N-nél kisebb négyzetszámot! Vigyázz: ez nem ugyanaz a feladat, mint az előző!
Gömbök
Készíts programot, mely kiírja az 1 köbméternél kisebb térfogatú, 10 cm-ként növekvő sugarú gömbök térfogatait!
Hatványozó program
Írj programot, amely hatványozni képes! Kérdezze meg az alapot (valós) és a kitevőt (egész), és írja képernyőre a hatvány értékét!
Sorozat eleme
Írj programot, ami ki tudja számolni a következő sorozat n-edik elemét: x0=2;
xi=2·xi-1+5. Az n értékét kérd a felhasználótól! Írd meg úgy
is, hogy csak az n-edik íródik ki a képernyőre, és úgy is, hogy az első n eredmény!
Köbgyök
Newton módszere a köbgyök számítására azon alapszik, hogy ha van egy tippünk a szám köbgyökére, akkor
szám/tipp2+2·tipp
─────────────────
3
jobb közelítés. Írj az előadáson bemutatott „Hérón módszere” programhoz hasonlót köbgyök számítására!
Megoldás
#include <stdio.h>
#include <math.h>
int main(void) {
double szam, tipp;
szam = 512;
tipp = 1;
while (fabs(tipp-szam/tipp/tipp) > 0.1)
tipp = (szam/(tipp*tipp) + 2*tipp)/3;
printf("%g\n", tipp);
return 0;
}Ferde hajítás I.
Egy ágyúból kilőtt golyó v0 (m/s) kezdeti sebességgel, alfa (fok)
szöggel indul.
Írj programot, amely bekéri ezeket az adatokat, továbbá egy
t (mp) időpontot. Írja ki, hogy abban a pillanatban épp
hol jár a golyó (x és y koordináta), továbbá hogy milyen messze
van az ágyútól légvonalban!
Ehhez a math.h függvényei, a sin() és a cos()
használhatóak. Vigyázz arra, hogy a szöget ezeknek radiánban kell megadni! 1°=π/180 rad.
g=9,81 m/s2.
Megoldás
#include <stdio.h>
#include <math.h>
int main(void) {
double v0, alfa, t;
double alfa_rad, x, y, r;
printf("Ferde hajítás\n");
printf("v0=");
scanf("%lf", &v0);
printf("alfa=");
scanf("%lf", &alfa);
printf("t=");
scanf("%lf", &t);
alfa_rad = alfa*3.141593/180;
x = v0*t*cos(alfa_rad);
y = v0*t*sin(alfa_rad)-9.81/2*t*t;
r = sqrt(x*x+y*y);
printf("x=%f\n", x);
printf("y=%f\n", y);
printf("r=%f\n", r);
return 0;
}Ferde hajítás II.
Írd meg most úgy a programot, hogy t=0,0; 0,1; 0,2; … s
időpontokban (tized másodpercenként) írja ki az ágyúgolyó helyét; egészen addig, amíg
be nem csapódik az a földbe (y≤0)!
Megoldás
#include <stdio.h>
#include <math.h>
int main(void) {
double t, x, y;
double v0, alfa, alfa_rad;
double g = 9.81;
printf("Ferde hajitas\n");
printf("Add meg a kiloves sebesseget!\n");
scanf("%lf", &v0);
printf("Es a kiloves szoget!\n");
scanf("%lf", &alfa);
/* radianban */
alfa_rad = alfa*3.1415926535/180;
t = 0;
x = 0;
y = 0;
while (y >= 0) {
printf("t=%8.4f x=%8.4f y=%8.4f\n", t, x, y);
t = t+0.1;
x = v0*t*cos(alfa_rad);
y = v0*t*sin(alfa_rad) - g/2*t*t;
}
printf("t=%.4f s-ra mar biztosan becsapodott.\n", t);
return 0;
}A fenti megoldás betartja a ciklusokkal kapcsolatos, előadáson bemutatott játékszabályt.
Nevezetesen azt, hogy a ciklustörzs elején szerepel az aktuális elem feldolgozása (jelen esetben
ez a kiírást jelenti), és a végén a következő elemre lépést (most ez az idő növelése, és
értelemszerűen a koordináták újraszámolása). Ennek az az előnye, hogy egy már ellenőrzött
y értékkel megyünk be a ciklusba, amelyet külön feltétel nélkül ki is lehet írni!
Mivel így a ciklus feltétele függ az y koordinátától (ez amúgy sem lehet
másképp, mert a becsapódás időpontját keressük), az első iteráció előtt már ki kell számolnunk
x-et és y-t. Odamásolhatnánk a ciklus előttre is a ferde hajítás
képleteit, de t=0 miatt azok x=0-ra és y=0-ra
egyszerűsödnek.
Ferde hajítás III.
Most az ágyúval nem sík terepen lövünk, hanem egy adott magasságú dombra. Alakítsd át az előző programodat úgy, hogy kérdezze meg az a domb magasságát, aztán addig írja ki a röppálya adatait, amíg az ágyúgolyó a dombba be nem csapódott!
Osztók
Írj C programot, amely bekér egy számot a standard bemeneten, és kiírja az összes osztóját.
Összes szám
Írj programot, amely a képernyőre írja a 4, 5 és 6 számjegyekből képezhető összes négyjegyű számot!
Buszjegyek
Helyettesítsük az 1-9 számjegyekkel az autóbuszjegyen található lyukasztási helyeket! Írj programot, amely kiírja az összes olyan buszjegy "kódját", amely három helyen van kilyukasztva! Törekedj a képernyő minél jobb kihasználására!
Számtani sorozat
Egy program bekér a felhasználótól három valós számot, kiírja, hogy az első szám negatív
vagy nemnegatív, majd az első számtól indulva, a második szám által meghatározott lépésközzel
halad a harmadik számig, a számsorozat elemeit kiírja.
Pl. be: 3.2 0.6 5.1 ki: nemnegativ 3.2 3.8 4.4 5.0
Pl. be: -1.7 1.0 2.5 ki: negativ -1.7 -0.7 0.3 1.3 2.3
Feltételezheted, hogy az első szám kisebb, mint a harmadik, és a
második szám pozitív. Ezek ellenőrzésével nem kell foglalkoznod.
Megoldás
#include <stdio.h>
int main(void) {
double a, step, b;
scanf("%lg%lg%lg", &a, &step, &b);
if (a < 0)
printf("negativ ");
else
printf("nemnegativ ");
double i = a;
while (i <= b) {
printf("%g, ",i);
i = i + step;
}
return 0;
}Sorozat növekvő lépésekkel
Egy program bekér a felhasználótól két pozitív egész számot, és a kisebbiktől a nagyobbikig
növekvő lépésközzel kiírja a számokat. A lépésköz kezdetben 1, és minden lépésben eggyel nő. A
program akkor is helyesen működik, ha a felhasználó előbb a felső, aztán az alsó határt adja meg
(és fordítva is).
Pl. be: 4 23 ki: 4 5 7 10 14 19
Pl. be: 23 4 ki: 4 5 7 10 14 19
Megoldás
#include <stdio.h>
int main(void) {
int elso, masodik, also, felso;
printf("Elso = "); scanf("%d", &elso);
printf("Masodik = "); scanf("%d", &masodik);
if (elso > masodik) {
also = masodik;
felso = elso;
} else {
also = elso;
felso = masodik;
}
double i = also;
double step = 1;
while (i <= felso) {
printf("%d ", i);
i = i + step;
step = step + 1;
}
return 0;
}Szögek
Egy program bekér a felhasználótól két valós számot, melyek két szöget jelentenek °-ban. A
program a kisebb szögtől a nagyobbig haladva kiírja a szögeket egy fokonként, és mindegyik szög
mellett zárójelbe téve radiánban is kiírja a szöget (1°=π/180 rad). A program akkor is helyesen
működik, ha a felhasználó előbb a nagyobb, aztán a kisebb szöget adja meg (és fordítva is).
Pl. be: 11.3 14.9 ki: 11.3 (0.197), 12.3 (0.215), 13.3 (0.232), 14.3 (0.249),
Pl. be: 180 176 ki: 176 (3.07), 177 (3.09), 178 (3.11), 179 (3.12), 180 (3.14),
Megoldás
#include <stdio.h>
int main(void) {
double also, felso;
scanf("%lg %lg",&also, &felso);
if (also > felso) {
double temp = also;
also = felso;
felso = temp;
}
double i = also;
while (i <= felso) {
printf("%g (%g), ", i, i*3.14/180);
i = i + 1;
}
return 0;
}Csökkenő sorozat
Egy program bekér a felhasználótól két pozitív valós számot, és a nagyobbiktól induló
csökkenő számsorozatot ír ki. A csökkenés lépésköze a kisebbik szám. A csökkenés addig tart,
amíg a kiírandó érték nagyobb, mint a kisebbik szám. A program akkor is helyesen működik, ha a
felhasználó előbb a nagyobb, aztán a kisebb számot adja meg (és fordítva is).
Pl. be: 1.1 5.2 ki: 5.2 4.1 3.0 1.9
Pl. be: 6.3 2.1 ki: 6.3 4.2
Megoldás
#include <stdio.h>
int main(void) {
double also, felso;
scanf("%lg %lg", &also, &felso);
if (also > felso) {
double temp = also;
also = felso;
felso = temp;
}
double i = felso;
while (also<i) {
printf("%g ", i);
i = i - also;
}
return 0;
}A/0 papír
Egy A/0-s, poszter méretű lap területe 1 m2; a szélessége a magasság √2-ed része.
Az A/1-es lap ebből úgy keletkezik, hogy a
rövidebb oldalával párhuzamosan középen kettévágjuk (vagyis a hosszabbat felezzük). Az A/2-es az A/1-eshez viszonyul ugyanígy stb.
Írj programot, amelyik kiszámolja és kilistázza ezeket a papírméreteket A/0-tól A/6-ig! A program az összeset álló változatban
írja ki, ne fekvő tájolással! Pl. az A4-es állóban: 210×297 mm.
(A matek: mekkora ez alapján egy A/0-s lap? Legyen h a lap magassága, w pedig a
szélessége! Tudjuk, hogy T=w·h, és azt is, hogy w=h/√2. Ebből T=h·h/√2,
amibe az 1 m2-t is behelyettesíthetjük. 1=h·h/√2,
√2=h·h, h=√√2. A szélessége pedig w=1 m2/h.)
Megoldás
#include <stdio.h>
#include <math.h>
int main(void) {
double a_old, b_old, rovid, hosszu; /* Oldalak */
a_old = sqrt(sqrt(2)); /* A0-s papír egyik oldala */
b_old = 1/a_old; /* A0-s papír másik oldala */
/* Ciklus A0-tól A6-ig */
for (int a = 0; a <= 6; a = a+1) {
/* Megnézzük melyik a rövidebb és melyik a hosszabb oldal */
if (a_old < b_old){
rovid = a_old;
hosszu = b_old;
}
else {
rovid = b_old;
hosszu = a_old;
}
/* Kiírjuk a-t, a rövidebb és a hosszabb oldalt */
/* 1000-el szorozva, hogy milliméter legyen az egység */
printf("A%d papir: %fmm x %fmm\n", a, rovid*1000, hosszu*1000);
/* A nagyobbik oldalt felezzük */
a_old = hosszu/2;
b_old = rovid;
}
return 0;
}