Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
public static BigInteger s(int k)
{
BigInteger s0 = BigInteger.ONE;
BigInteger alpha = new BigInteger("618");
BigInteger beta = new BigInteger("89");
BigInteger p = new BigInteger("809");
BigInteger u = new BigInteger("1");
BigInteger v = new BigInteger("2");
BigInteger w = new BigInteger("3");
if (k==0)
{
return s0;
}
if (((s(k-1)).mod(w)).equals(u))
{
return (s(k-1).multiply(alpha)).mod(p);
}
if (((s(k-1)).mod(w)).equals(v))
{
return (s(k-1).multiply(beta)).mod(p);
}
else
{
return ((s(k-1)).multiply(s(k-1))).mod(p);
}
}
diese prozedur funktioniert zwar aber wenn ich mir später mit einer for schleife die ersten z.b. 9 si ausgeben lassen will
wird es sehr sehr langsam (da es ja für jedes si alle vorhergegangenen immer wieder berechnet). deswegen suche ich nach einer möglichkeit diesses problem zu lösen. eine möglichkeit wäre ja die funktion iterativ zu definieren (woran ich aber schon scheiter) gibt es noch andere (die werte irgendwie zwischenspeichern oder sowas?)?
hoffe mir kann jemand helfen.
Du greiffst immer nur auf das Element "k-1" zurück, um das Element "k" zu berechnen, also reicht es, jeweils ein Vorgänger-Element zu speichern.
Mal mit zwei Methoden, damits ein bisschen übersichtlicher ist.
Code:
// Die iterative Schleife
public X get( int k, X s0 ){
X sx = s0;
for( int i = 0; i < k; i++ ){
sx = next( sx );
}
return sx;
}
// Das nächste Element aus dem Vorgänger berechnen
public X next( X old ){
if ((old.mod(3)).equals(1))
{
return (old.multiply(a)).mod(p);
}
if ((old.mod(3)).equals(2))
{
return (old.multiply(b)).mod(p);
}
else
{
return (old.pow(2)).mod(p);
}
}
danke für deine antwort beni. aber wenn ich mir z.b. die ersten 50 si ausgeben lassen will funktioniert es bei meiner rekursion schon ab dem 9. si nicht mehr (da zuviel speicherplatz benötigt wird da alle vorgänger für jedes si immer wieder neu berechnet werden). klappt das bei deinem vorschlag(da ja dort auch immer wieder nur auf das vorherige si zurückgegriffen wird)?
Probiers aus. Ich erhebe kein Anspruch auf Korrektheit :wink:
Allerdings wundern mich deine Zahlen, bei der Variante mit Rekursion gibt es gleichzeitig maximal die Rekursionstiefe viele Elemente, also nicht mehr als 50. Was sind denn deine Objekte für Riesenbomber, dass schon 50 von ihnen den Speicher sprengen?
public static int get(int k)
{
int s0=1,sx=s0,i;
for(i=0;i<k;i++)
{
sx=next(sx);
}
return sx;
}
public static int next(int k)
{
int s0=1,alpha=618,beta=89,p=809,q=101,old=1;
if (k==0)
{
return s0;
}
if ((old%3)==1)
{
return (old*alpha)%p;
}
if ((old%3)==2)
{
return (old*beta)%p;
}
else
{
return (old*old)%p;
}
}
und später eine for schleife gemacht aber es wurde immer nur (so oft wie die schleife durchlaufen wird) der erste wert der si ausgegeben. warum funktioniert es nicht? kann mir jemand den fehler aufzeigen?
