Tömb elemeinek az összeszorzása és hatványozás rekurzívan pascalban?
Adott a feladat:Irjunk rekurzív függvényt, ami kiszámolja az a–t a b-ediken.
Ezt a feladatot próbáltam megoldani tömbbel kevés sikerrel mert már nem tudom hogy kell a tömb elemit összeszorozni.
Megpróbáltam úgy hogy a k:=k*t[i] de a k mégis 0 marad.
Kérlek segítsetek akár a teljes feladattal akár csak az összeszorzással kapcsolatban.
válasza: válasza:rekurzív függvényhez felesleges tömböket használnod.
lesz a és b, valamint egy szorzat és szamlalo változód
szorzat = 1;
szamlalo = 1;
function hatvany(){
szorzat = szorzat * a;
szamlalo++;
if (szamlalo < b){
hatvany(); //ezért rekurzív, mert itt hívja meg önmagát
}
}
tudom, nem pascalban írtam, de már rég volt, és nincs kedvem előszedni a szintaktikáját
válasza: válasza:Felesleges ide tömb.
Rekurzív összefüggés:
a^b= a*a^(b-1) , ha b>1
a^b=a, ha b=1
a^b=1, ha b=0
Paraméterbe add át a alapot és kitevőt. A függvény hívja meg önmagát 1-el kevesebb kitevővel és ezt szorozza össze az alappal a megfelelő feltétel szerint.
válasza:Ez nem jó, azt sem tudod mi a rekurzió.
Wikipédia szerint : "A rekurzió a matematikában, valamint a számítógép-tudományban egy olyan művelet, mely végrehajtáskor a saját maga által definiált műveletet, vagy műveletsort hajtja végre, ezáltal önmagát ismétli; a rekurzió ezáltal egy adott absztrakt objektum sokszorozása önhasonló módon."
Függvények rekurziójára kiváló példa a Fibonacci-sorozat
F(0)=0
F(1)=1
ha n>1 akkor F(n) = F(n − 1) + F(n − 2)
válasza:Ne csinálj tömböt, attól nem lesz rekurzív, cserébe pazarlod a memóriát és lassítod a programot. A hatványozás így néz ki (ha nem rontom el, rég Pascaloztam, mostanában inkább C++-t használok):
Function hatvany(alap: LongInt, kitevo: Byte): LongInt;
Begin
If (kitevo=0) Then
hatvany:=1
Else
hatvany:=alap*hatvany(alap, kitevo-1);
End;
Vagy egy szintén rekurzív, ám sokkal gyorsabb hatványozás:
Function hatvany(alap: LongInt, kitevo: Byte): LongInt;
Begin
If (kitevo=0) Then
hatvany:=1
Else
Begin
If ((kitevo Mod 2)=0) Then
hatvany:=hatvany(alap, kitevo Div 2)*hatvany(alap, kitevo Div 2)
Else
hatvany:=alap*hatvany(alap, kitevo-1);
End;
End;
Ez a módszer viszont sokkal memóriaigényesebb (persze ez a LongInt mérete miatt nem feltűnő, hamarabb léped túl a méretét, mint hogy ebből gond legyen. De mondjuk c++-ban az első módszer 8 mp alatt számolta ki a 2^10000-t, míg a második 2,5 mp alatt - bár itt már saját típust használtam.)
Esetleg egy nem rekurzív, viszont rövid módszer:
hatvany:=Round(exp(x*ln(alap)));
válasza:A harmadikban x a kitevő, a másodikban pedig ha definiálsz egy s: LongInt változót, és a (kitevo Mod 2=0) részbe azt írod:
s:=hatvany(alap, kitevo Div 2);
hatvany:=s*s;
akkor gyorsabb és kevesebb memóriát eszik.
Tudom mi a rekurzió, tudom hogy a for ciklusokat if-re kell átírni csak elöbb megpróbáltam megoldani iteratívan és majd átírni, iteratívan működik,rekurzívan még nem de még próbálkozok.Megpróbáltam a többi módszert is azzal működnek de én megpróbálnám hátha meglehet így is itt az iteratív programom, ezt kéne átírni:
var a,b,k:integer;
function hatvany(a,b:integer;k:real):real;
var t:array[1..99] of integer;
i:integer;
begin
k:=1;
for i:=1 to 99 do
t[i]:=1;
for i:=1 to b do
begin
t[i]:=a;
k:=k*t[i];
end;
hatvany:=k;
end;
begin
readln(a,b);
writeln(hatvany(a,b,k):0:0);
readln;
end.
Kapcsolódó kérdések:
Minden jog fenntartva © 2025, www.gyakorikerdesek.hu
GYIK | Szabályzat | Jogi nyilatkozat | Adatvédelem | Cookie beállítások | WebMinute Kft. | Facebook | Kapcsolat: info(kukac)gyakorikerdesek.hu
Ha kifogással szeretne élni valamely tartalommal kapcsolatban, kérjük jelezze e-mailes elérhetőségünkön!