 |
A 2001. októberi informatika feladatok megoldása |
A közöltek csak megoldásvázlatok, esetleg csak végeredmények. A maximális pontszám eléréséhez általában ennél részletesebb megoldás szükséges. A részletes megoldásokat a beküldött dolgozatok alapján a KöMaL-ban folyamatosan közöljük.
I. 4. ,,Nagyon'' prímeknek nevezzük az olyan prímszámokat,
amelyek bármely kezdőszelete is prímszám. Például nagyon prím a 239,
mert a 2, a 23 és a 239 is prím; nem nagyon prím a 241, ami ugyan
prímszám, a 2 is prím, de a 24 nem az. Készíts programot, amely
előállítja az összes N jegyű nagyon prímet (1
N8)! A program
írja ki ezen számok kezdőszeleteit is! A helyes megoldások közül az ér
többet, amelyik rövidebb idő alatt fut le. Példa (n=3 esetén):
2, 23, 233 2, 23,
239 2, 29,
293 3, 31, 311 (10 pont)
A megoldás tartalmazza a feladat értelmezését, azaz a specifikációt, illetve az algoritmust.
A bemenő adat N, mely megmondja, hogy hány jegyű nagyon prímekre és azok kezdőszeleteire vagyunk kíváncsiak.
Algoritmus Nagyon_primek; Be: N n_jegyuek(2,1,N); n_jegyuek(3,1,N); n_jegyuek(5,1,N); n_jegyuek(7,1,N); eljárás vége
Vagyis kiíratjuk az egyjegyűektől az N-jegyűekig a prímeket. Egyjegyű prím a 2, 3, 5, és 7. Persze ehhez kell az n_jegyuek nevű eljárás:
Eljárás n_jegyuek(p,i,n: egész);
Ha i=n
akkor
kiiras(p);
különben
j:=1;
Ciklus amíg j<=9
h:=10*p+j;
Ha prim_e(h)
akkor n_jegyuek(h,i+1,n);
j:=j+2;
ciklus vége
elágazás vége
eljárás vége
Ez az eljárás rekurzív. Ha az i paraméter megegyezik a kiírandó jegyszámmal, akkor kiírja a prímet, míg ha még több jegyet kell kiírni, akkor megpróbál egy páratlan jegyet hozzáfűzni a számhoz. Ha ez prím, akkor ezzel az egy jeggyel hosszabb prímszámmal újra meghívja (rekurzívan önmagát) az n_jegyuek nevű eljárást. Felhasználjuk a prim_e nevű függvényt és a kiiras nevű eljárást.
Függvény prim_e(i: egész): logikai;
j:=2;
Ciklus j*j<=i és i mod j>0
j:=j+1;
ciklus vége
prim_e:=j*j>i;
függvény vége
A prim_e nevű függvény eldönti egy számról, hogy az prím-e. Megnézi, hogy osztható-e a gyökénél kisebb számmal.
Eljárás kiiras(i: egész);
Ha i<10
akkor Ki: i
különben
kiiras(i div 10);
Ki: ', '+i
elágazás vége
eljárás vége
Ez a kiiras nevű eljárás ugyancsak rekurzív. Egyszerűen kiírásra kerül, ha egyjegyű az elem. Azonban ha több jegyről van szó, akkor rekurzív hívással az ennél egy jeggyel rövidebb szám (prím) kerül kiírásra és egy vessző után ez az elem.
Pascal program:
Program Nagyon_primek; uses newdelay,crt; var i,j,n: longint; f: text; Function prim_e(i: longint): Boolean; var j: longint; begin j:=2; while (j*j<=i) and (i mod j>0) do j:=j+1; prim_e:=j*j>i; end; Procedure kiiras(i: longint); var j: longint; begin if i<10 then write(f,i:5) else begin kiiras(i div 10); write(f,', ',i:5); end; end; Procedure n_jegyuek(p,i,n: longint); var j,h: longint; begin if i=n then begin kiiras(p); writeln(f); end else begin j:=1; while j<=9 do begin h:=10*p+j; if prim_e(h) then n_jegyuek(h,i+1,n); j:=j+2; end; end; end; begin clrscr; repeat write('Hány jegyűek?'); readln(n); until n>0;} assign(f,'prim.out'); rewrite(f); for n:=1 to 8 do begin n_jegyuek(2,1,n); n_jegyuek(3,1,n); n_jegyuek(5,1,n); n_jegyuek(7,1,n); writeln(f); end; close(f); repeat until keypressed; end.
I. 5. Készítsünk programot, amely egy egységkockát ábrázol a képernyőn drótvázas és takart vonalas ábrázolásban! A kocka középpontja az origóban legyen, és a z tengely irányából adott távolságról nézzük. A program a kockát tetszőleges koordináta tengely körül tudja forgatni! (10 pont)
A megoldás egyszerűsített forrásértelmezése:
Program SZ_5;
Szükségünk lesz egy-két új típusra. A 3D-s vektorokat reprezentálóra, illetve a forgatást mátrix-vektor szorzással valósítjuk meg, ezért a mátrixot és a vektort leíró típusokra.
vektor=Rekord
x,y,z:Valós;
Rekord vége;
TMatrix=Tömb(1..4,1..4) Valós;
TVektor=Tömb(1..4) Valós;
A kockát a nyolc csúcsba mutató helyvektor írja le. Ezeket a csúcsokat egy tömbben tároljuk, kezdőértékkel rendelkező változóként definiáljuk.
kocka:Tömb(0..7) vektor=((x:-0.5;y:-0.5;z:0.5), (x:0.5;y:-0.5;z:0.5),
(x:-0.5;y:-0.5;z:-0.5), (x:0.5;y:-0.5;z:-0.5),
(x:-0.5;y:0.5;z:0.5), (x:0.5;y:0.5;z:0.5),
(x:-0.5;y:0.5;z:-0.5), (x:0.5;y:0.5;z:-0.5));
A kocka hat lapjának normálvektorát is egy tömbbe helyezzük.
lap:Tömb(1..6) vektor=((x:0;y:-1;z:0), (x:0;y:0;z:1),
(x:-1;y:0;z:0), (x:1;y:0;z:0),
(x:0;y:0;z:-1), (x:0;y:1;z:0));
Azt, hogy melyik laphoz mely csúcsok tartoznak egy másik tömbben mentjük le.
lapleiras:Tömb(1..6,1..4 ) indexsorszám=((0,1,3,2), (0,1,5,4), (0,2,6,4),
(1,3,7,5), (2,3,7,6), (4,5,7,6));
A következő konstansok csak az olvashatóságot segíti.
Balra=1;
Jobbra=2;
Fel=3;
Le=4;
BOldalra=5;
JOldalra=6;
Az alábbi változókra lesz szükségümk:
oldallap:Tömb(1..4) 2D-os pont; segít kirajzolni a kocka lapjait.
vonalak:Logikai; értéke szerint rajzolunk ki drótvázas vagy takart vonalas ábrát.
Ch:Karakter; a billentyű leütés figyelésénél kell.
szog:Valós; az elforgatás szögét tartalmazza. Későbbi fejlesztési lehetőség, hogy ez is változhat.
A következő eljárás a Rajzolást valósítja meg.
Eljárás Rajzol;
Az alábbi függvény a normálvektor egyik valós értékű vektorához rendel egy egész értékű szín konstanst.
Függvény szin(r:Valós):Egész;
Ez a függvény a takart vonalas ábrázoláshoz választja ki a megfelelő vonalazás irányát, a j-edik lap normálvektorának koordinátáitól függően.
Függvény toltes(j:Egész):Egész;
Kezdődhet a Rajzol eljárás:
Képernyőtörlés;
Vagy a drótvázas rajzolást végezzük el,
Ha vonalak
akkor
Kezdőpontba ugrás;
Vonalrajzolások a kocka bejárására;
vagy a takart vonalas ábrázolást.
különben
Ciklus i:=1-től 6-ig
Mind a hat lapot ki kell rajzolni, ha látszik; vagyis, ha a lap normálvektorának z komponense nagyobb, mint nulla.
Ha lap[i].z>0
Akkor
Oldallap leírás a négy csúcspont x és y koordinátáival(oldallap)
Kitöltési stílus beallítása(toltes(i), szin(lap[i].z));
Kitöltött poligon rajzolás(4,oldallap);
Elágazás vége;
Ciklus vége;
Elágazás vége;
Eljárás vége;{_Rajzol}
A szögfüggvényeket radiánba kell megadni, ezért át kell számolnunk fokból radiánba.
Függvény Rad(b:Valós):Valós;
Rad:=b*Pi/180;
Függvény vége;{_Rad}
A következő eljárás fogja a forgatást elvégezni.
Eljárás Forgat(merre:Egész);
Szükségünk lesz egy-két segéd változóra. Egy mátrixra és két vektorra a forgatás számolásáshoz.
A:TMatrix;
v,v2:TVektor;
i:Integer;
Eljárás MatrixVektorSzorzas(M:TMatrix;b:TVektor;Var k:TVektor);
Segéd változóink:
j,l:Byte;
Ciklus j:=1-től 4-ig
k[j]:=0;
Ciklus l:=1-től 4-ig
k[j]:=k[j]+M[j,l]*b[l];
Ciklus vége;
Ciklus vége;{_For}
Eljárás vége;{_MatrixVektorSzorzas}
A forgatás egyszerűen csak egy mátrix-vektor szorzás. A mátrixot lejjebb adjuk meg. Ezt a módszert és a grafika matematikai elméletét most nem tárgyaljuk részletesen.
Eljárás Forgatas;
MatrixVektorSzorzas(A,v,v2);
Eljárás vége;{_Forgatas}
Hogy milyen mátrixszal kell számolnunk ebben az eljárásban adjuk meg.
Eljárás MatrixMegadas;
Elágazás merre szerint
Boldalra esetén
A[1,1]:=cos(rad(szog));
A[1,2]:=0;
A[1,3]:=-sin(rad(szog));
A[2,1]:=0;
A[2,2]:=1;
A[2,3]:=0;
A[3,1]:=sin(rad(szog));
A[3,2]:=0;
A[3,3]:=cos(rad(szog));
Joldalra esetén
A[1,1]:=cos(rad(-szog));
A[1,2]:=0;
A[1,3]:=-sin(rad(-szog));
A[2,1]:=0;
A[2,2]:=1;
A[2,3]:=0;
A[3,1]:=sin(rad(-szog));
A[3,2]:=0;
A[3,3]:=cos(rad(-szog));
Balra esetén
A[1,1]:=cos(rad(-szog));
A[1,2]:=-sin(rad(-szog));
A[1,3]:=0;
A[2,1]:=sin(rad(-szog));
A[2,2]:=cos(rad(-szog));
A[2,3]:=0;
A[3,1]:=0;
A[3,2]:=0;
A[3,3]:=1;
Jobbra esetén
A[1,1]:=cos(rad(szog));
A[1,2]:=-sin(rad(szog));
A[1,3]:=0;
A[2,1]:=sin(rad(szog));
A[2,2]:=cos(rad(szog));
A[2,3]:=0;
A[3,1]:=0;
A[3,2]:=0;
A[3,3]:=1;
Fel esetén
A[1,1]:=1;
A[1,2]:=0;
A[1,3]:=0;
A[2,1]:=0;
A[2,2]:=cos(rad(-szog));
A[2,3]:=-sin(rad(-szog));
A[3,1]:=0;
A[3,2]:=sin(rad(-szog));
A[3,3]:=cos(rad(-szog));
Le esetén
A[1,1]:=1;
A[1,2]:=0;
A[1,3]:=0;
A[2,1]:=0;
A[2,2]:=cos(rad(szog));
A[2,3]:=-sin(rad(szog));
A[3,1]:=0;
A[3,2]:=sin(rad(szog));
A[3,3]:=cos(rad(szog));
Elágazás vége;
Ezek minden esetben megegyeznek.
A[1,4]:=0;
A[2,4]:=0;
A[3,4]:=0;
A[4,1]:=0;
A[4,2]:=0;
A[4,3]:=0;
A[4,4]:=1;
Eljárás vége;
A forgatás eljárás a következőkből áll:
MatrixMegadas;
A kocka mind a nyolc csúcsát el kell forgatnunk. A forgatás bemenő adata a v vektor a kimenő pedig a v2 lesz.
Ciklus i:=0-tól 7-ig
v[1]:=kocka[i].x;
v[2]:=kocka[i].y;
v[3]:=kocka[i].z;
v[4]:=1;
Forgatas;
kocka[i].x:=v2[1];
kocka[i].y:=v2[2];
kocka[i].z:=v2[3];
Ciklus vége;
És a hat lap normálvektorait is el kell forgatnunk.
Ciklus i:=1-től 6-ig
v[1]:=lap[i].x;
v[2]:=lap[i].y;
v[3]:=lap[i].z;
v[4]:=1;
Forgatas;
lap[i].x:=v2[1];
lap[i].y:=v2[2];
lap[i].z:=v2[3];
Cikus vége;
Eljárás vége;{_Forgat}
Ezekkel az eljárások segítségével már nagyon könnyű a programot megírni.
KépernyőTörlés; GrafikusKépernyőVálasztása;
Először drótvázasan ábrázoljuk a kockát.
vonalak:=TRUE;
Az elforgatás szöge:
szog:=10;
A rajzolás színe pedig legyen fehér.
SzínBeállítás(White);
Ciklus
Rajzol;
BillentyűLeütésreVár(Ch)
Elágazás Ch szerint
#PageDown# esetén Forgat(BOldalra);
#PageUp# esetén Forgat(JOldalra);
#Fel# esetén Forgat(Fel);
#Le# esetén Forgat(Le);
#Jobb# esetén Forgat(Jobbra);
#Bal# esetén Forgat(Balra);
#End# esetén Ha vonalak
akkor vonalak:=FALSE
különben vonalak:=TRUE;
elágazás vége;
Elágazás vége;
amíg Ch=#Escape#;
KarakteresKépernyőVisszaÁllítása;
Program vége.
Pascal program:
Program Okt2; Uses newdelay,Crt,Graph; Type vektor=Record x,y,z:Real; End;{_Record} TMatrix=Array[1..4,1..4] Of Real; TVektor=Array[1..4] Of Real; Const {_Kezdoertekkel rendelkezo valtozo} kocka:Array[0..7] Of vektor=((x:-0.5;y:-0.5;z:0.5),(x:0.5;y:-0.5;z:0.5),(x:-0.5;y:-0.5;z:-0.5),(x:0.5;y:-0.5;z:-0.5), (x:-0.5;y:0.5;z:0.5),(x:0.5;y:0.5;z:0.5),(x:-0.5;y:0.5;z:-0.5),(x:0.5;y:0.5;z:-0.5)); lap:Array[1..6] Of vektor=((x:0;y:-1;z:0),(x:0;y:0;z:1),(x:-1;y:0;z:0),(x:1;y:0;z:0),(x:0;y:0;z:-1),(x:0;y:1;z:0)); lapleiras:Array[1..6,1..4] Of Byte=((0,1,3,2),(0,1,5,4),(0,2,6,4),(1,3,7,5),(2,3,7,6),(4,5,7,6)); path:STRING=''{'g:\munka\tp\bgi'}; BOldalra=5; JOldalra=6; Balra=1; Jobbra=2; Fel=3; Le=4; Var oldallap:Array[1..4] Of PointType; vonalak:Boolean; Ch:Char; szog:Real; Procedure OpenGraph; Var gd,gm:Integer; Begin gd := Detect; InitGraph(gd,gm,path); End;{_OpenGraph} Procedure Rajzol; Var i:Byte; Function szin(r:Real):Word; Begin szin:=Trunc(15*r); End; Function toltes(j:Byte):Word; Begin If lap[j].x>0 Then toltes:=BkSlashFill Else toltes:=SlashFill; If lap[j].y>0.5 Then toltes:=SolidFill; End; Begin SetFillStyle(1,0); Bar(0,0,GetMaxX,GetMaxY); If vonalak Then Begin MoveTo(GetMaxX div 2 + Trunc((GetMaxY div 4)*kocka[0].x),GetMaxY div 2 - Trunc((GetMaxY div 4)*kocka[0].y)); LineTo(GetMaxX div 2 + Trunc((GetMaxY div 4)*kocka[1].x),GetMaxY div 2 - Trunc((GetMaxY div 4)*kocka[1].y)); LineTo(GetMaxX div 2 + Trunc((GetMaxY div 4)*kocka[3].x),GetMaxY div 2 - Trunc((GetMaxY div 4)*kocka[3].y)); LineTo(GetMaxX div 2 + Trunc((GetMaxY div 4)*kocka[2].x),GetMaxY div 2 - Trunc((GetMaxY div 4)*kocka[2].y)); LineTo(GetMaxX div 2 + Trunc((GetMaxY div 4)*kocka[0].x),GetMaxY div 2 - Trunc((GetMaxY div 4)*kocka[0].y)); LineTo(GetMaxX div 2 + Trunc((GetMaxY div 4)*kocka[4].x),GetMaxY div 2 - Trunc((GetMaxY div 4)*kocka[4].y)); LineTo(GetMaxX div 2 + Trunc((GetMaxY div 4)*kocka[5].x),GetMaxY div 2 - Trunc((GetMaxY div 4)*kocka[5].y)); LineTo(GetMaxX div 2 + Trunc((GetMaxY div 4)*kocka[7].x),GetMaxY div 2 - Trunc((GetMaxY div 4)*kocka[7].y)); LineTo(GetMaxX div 2 + Trunc((GetMaxY div 4)*kocka[6].x),GetMaxY div 2 - Trunc((GetMaxY div 4)*kocka[6].y)); LineTo(GetMaxX div 2 + Trunc((GetMaxY div 4)*kocka[4].x),GetMaxY div 2 - Trunc((GetMaxY div 4)*kocka[4].y)); LineTo(GetMaxX div 2 + Trunc((GetMaxY div 4)*kocka[5].x),GetMaxY div 2 - Trunc((GetMaxY div 4)*kocka[5].y)); LineTo(GetMaxX div 2 + Trunc((GetMaxY div 4)*kocka[1].x),GetMaxY div 2 - Trunc((GetMaxY div 4)*kocka[1].y)); LineTo(GetMaxX div 2 + Trunc((GetMaxY div 4)*kocka[3].x),GetMaxY div 2 - Trunc((GetMaxY div 4)*kocka[3].y)); LineTo(GetMaxX div 2 + Trunc((GetMaxY div 4)*kocka[7].x),GetMaxY div 2 - Trunc((GetMaxY div 4)*kocka[7].y)); LineTo(GetMaxX div 2 + Trunc((GetMaxY div 4)*kocka[6].x),GetMaxY div 2 - Trunc((GetMaxY div 4)*kocka[6].y)); LineTo(GetMaxX div 2 + Trunc((GetMaxY div 4)*kocka[2].x),GetMaxY div 2 - Trunc((GetMaxY div 4)*kocka[2].y)); End Else Begin For i:=1 To 6 Do Begin If lap[i].z>0 Then Begin oldallap[1].x:=GetMaxX div 2 + Trunc((GetMaxY div 4)*kocka[lapleiras[i,1]].x); oldallap[1].y:=GetMaxY div 2 - Trunc((GetMaxY div 4)*kocka[lapleiras[i,1]].y); oldallap[2].x:=GetMaxX div 2 + Trunc((GetMaxY div 4)*kocka[lapleiras[i,2]].x); oldallap[2].y:=GetMaxY div 2 - Trunc((GetMaxY div 4)*kocka[lapleiras[i,2]].y); oldallap[3].x:=GetMaxX div 2 + Trunc((GetMaxY div 4)*kocka[lapleiras[i,3]].x); oldallap[3].y:=GetMaxY div 2 - Trunc((GetMaxY div 4)*kocka[lapleiras[i,3]].y); oldallap[4].x:=GetMaxX div 2 + Trunc((GetMaxY div 4)*kocka[lapleiras[i,4]].x); oldallap[4].y:=GetMaxY div 2 - Trunc((GetMaxY div 4)*kocka[lapleiras[i,4]].y); SetFillStyle(toltes(i), szin(lap[i].z)); FillPoly(4,oldallap); End; End;{_For} End; End;{_Rajzol} Function Rad(b:Real):Real; Begin Rad:=b*Pi/180; End;{_Rad} Procedure Forgat(merre:Byte); Var A:TMatrix; v,v2:TVektor; i:Integer; Procedure MatrixVektorSzorzas(M:TMatrix;b:TVektor;Var k:TVektor); Var c:TVektor; j,l:Byte; Begin For j:=1 To 4 Do Begin c[j]:=0; For l:=1 To 4 Do c[j]:=c[j]+M[j,l]*b[l]; End;{_For} For j:=1 To 4 Do k[j]:=c[j]; End;{_MatrixVektorSzorzas} Procedure Forgatas; Begin MatrixVektorSzorzas(A,v,v2); End;{_Forgatas} Procedure MatrixMegadas; Begin Case merre Of BOldalra:Begin A[1,1]:=cos(rad(szog)); A[1,2]:=0; A[1,3]:=-sin(rad(szog)); A[2,1]:=0; A[2,2]:=1; A[2,3]:=0; A[3,1]:=sin(rad(szog)); A[3,2]:=0; A[3,3]:=cos(rad(szog)); End;{BOldalra} JOldalra:Begin A[1,1]:=cos(rad(-szog)); A[1,2]:=0; A[1,3]:=-sin(rad(-szog)); A[2,1]:=0; A[2,2]:=1; A[2,3]:=0; A[3,1]:=sin(rad(-szog)); A[3,2]:=0; A[3,3]:=cos(rad(-szog)); End;{JOldalra} Balra:Begin A[1,1]:=cos(rad(-szog)); A[1,2]:=-sin(rad(-szog)); A[1,3]:=0; A[2,1]:=sin(rad(-szog)); A[2,2]:=cos(rad(-szog)); A[2,3]:=0; A[3,1]:=0; A[3,2]:=0; A[3,3]:=1; End;{_Balra} Jobbra:Begin A[1,1]:=cos(rad(szog)); A[1,2]:=-sin(rad(szog)); A[1,3]:=0; A[2,1]:=sin(rad(szog)); A[2,2]:=cos(rad(szog)); A[2,3]:=0; A[3,1]:=0; A[3,2]:=0; A[3,3]:=1; End;{_Jobbra} Fel:Begin A[1,1]:=1; A[1,2]:=0; A[1,3]:=0; A[2,1]:=0; A[2,2]:=cos(rad(-szog)); A[2,3]:=-sin(rad(-szog)); A[3,1]:=0; A[3,2]:=sin(rad(-szog)); A[3,3]:=cos(rad(-szog)); End;{_Fel} Le:Begin A[1,1]:=1; A[1,2]:=0; A[1,3]:=0; A[2,1]:=0; A[2,2]:=cos(rad(szog)); A[2,3]:=-sin(rad(szog)); A[3,1]:=0; A[3,2]:=sin(rad(szog)); A[3,3]:=cos(rad(szog)); End;{_Le} End;{_Case} A[1,4]:=0; A[2,4]:=0; A[3,4]:=0; A[4,1]:=0; A[4,2]:=0; A[4,3]:=0; A[4,4]:=1; End;{_MatrixMegadas} Begin MatrixMegadas; For i:=0 To 7 Do Begin v[1]:=kocka[i].x; v[2]:=kocka[i].y; v[3]:=kocka[i].z; v[4]:=1; Forgatas; kocka[i].x:=v2[1]; kocka[i].y:=v2[2]; kocka[i].z:=v2[3]; End; For i:=1 To 6 Do Begin v[1]:=lap[i].x; v[2]:=lap[i].y; v[3]:=lap[i].z; v[4]:=1; Forgatas; lap[i].x:=v2[1]; lap[i].y:=v2[2]; lap[i].z:=v2[3]; End; End;{_Forgat} Begin ClrScr; OpenGraph; vonalak:=TRUE; szog:=10; SetColor(15); Repeat Rajzol; Ch:=ReadKey; If Ch=#0 Then Ch:=ReadKey; Case Ch Of #75:Forgat(BOldalra); #77:Forgat(JOldalra); #72:Forgat(Fel); #80:Forgat(Le); #73:Forgat(Jobbra); #81:Forgat(Balra); #49,#79:If vonalak Then vonalak:=FALSE Else vonalak:=TRUE; End;{_Case} Until Ch=#27; CloseGraph; End.
I. 6. A rugó rezgésének ,,szemléltetésére'' a következő a
szimulációs modellt alkotjuk. Az ,,ideális'' (elhanyagolható tömegű)
rugóra akasszunk óvatosan egy M tömegű testet, aminek hatására
a rugó valamennyire megnyúlik, majd nyugalomban marad. Ezzel a
tömeggel együtt L hosszúságúra nyújtjuk a rugót. Elengedve, a
rugón a tömeg rezgőmozgásba kezd. Ezt a mozgást kell utánozni úgy,
hogy kellő rövidségű időegységet választva (
t)
kiszámítjuk az abban a pillanatban érvényes megnyúlást, eredő erőt
(ami az M tömeg súlyából és a rugó megnyúlásától függő erőből
tevődik össze), gyorsulást és sebességet. Írjunk Excel táblázatot
(amelynek neve: RUGO.XLS) ennek a fizikai modellnek a vizsgálatára!
a) Adjuk meg az F (eredő erő), az a (gyorsulás), a v (sebesség) és az l (megnyúlás) alakulását az első 200 időegységben.
b) Ábrázoljuk grafikonon a megnyúlás változását!
c) A modell paraméterei (D rugóállandó, KE közegellenállási együttható, az L kezdeti megnyúlás, az M tömeg és a \(\displaystyle Delta\)t időintervallum) a táblázat bal felső sarkában legyenek találhatók (igény szerint módosíthatók).
d) Hogyan alakul a szimuláció, ha a közegellenállást is figyelembe vesszük? (10 pont)
A megoldás ez az Excel táblázat:
A B1-tól B5-ig található cellákba és a B8 cellába Valamilyen értéket kell megadnunk értelemszerűen. A többi adat már mind számolt.
B6 természetesen a B1 és B4 szorzata.
B7 az egyenes vonalú egyenletesen gyorsuló közelítés miatt egy előre kiszámolt konstans értéket tartalmaz. Mégpedig: t2/2.
A B9 cellába kiszámolásra kerül a nyugalmi szint úgy, hogy a rugóra akasztott test egyszerűen csak lóg. Vagyis a megnyúlás, ami ekkor a nyugalmi szint egyenlő lesz a súlyának és a rugó rugóállandójának hányadosával. x0=Mg/D=$B$6/$B$2
B11 a kezdő időpont, vagyis 0.
A 11. sorban szerepel a kezdettől eltelt idő úgy, hogy mindig az előző cella értékéhez hozzáadunk egyet, a dT-t.
B12 a kezdősebesség nulla, hiszen a megnyújtás után csak elengedjük a testet.
A 12. sorban szerepel a sebesség, mely az elengedés
pillanatában nulla, majd periodikusan változik. Függ az előző
sebességtől illetve az előző gyorsulástól. Itt azt a közelítést
használjuk, hogy nagyon kis időintervallumokat véve feltételezzük az
egyenletesen gyorsuló mozgást. v2=v1+at. Tehát például:
D12=C12+C15*$B$3.
B13 a kezdeti kitérés az, amennyire megnyújtottuk a testet, azaz B5-tel megegyezik.
A 13 sorban tovább a kitérések található, melyeket az s2=s1+v1t+(a/2)t2 közelítéssel számolunk ki, vagyis például D13=C13+C12*$B$3+$B$7*C15
B14 a rugóerőnek az a része, ami csak a nyugalmi helyzettől való eltérésből származik, így ez kezdetben F=Dx , azaz B14=$B$2*B13.
A 14. sorban tovább az erő kiszámításánál a közegellenállásból származó erőt is figyelembe vesszük, hozzáadjuk az előbbi módon kiszámított erőhöz. Például D14=-$B$2*D13+D17
A 15. sor végig az adott időhöz tartozó gyorsulást mutatja. a=F/m, azaz például: B15=B14/$B$1.
A 16. sorban már a rugó nyugalmi helyzetéhez viszonyított pozíció szerepel. Vagyis a 13. sor van eltolva a nyugalmi szintre.
A 17. sorban a közegellenállásból származó erőt számoljuk ki, olyan közelítéssel, hogy ez az erő egyenesen arányos sebességgel. Például: F17=-F12*$B$8. Itt a negatív előjelre az erő iránya miatt van szükség.