Potenzieren eines Feldes

[witch doctor]

Hallo,

wir hatten als Aufgabe ein Programm in Java zu schreiben, das eine eingegebene Zahl n die Potenzen 2 hoch n, 3 hoch n bis 11 hoch n berechnet, die Ergebnisse in einem Array speichert und diesen Array dann ausgibt.

Wir sollten zur Berechnung eine Funktion verwenden.

Ich habe schon ein wenig "gebastetlt" bekomme es aber nicht hin.

Das ganz soll ohne Java.math laufen.

Hier, was ich bisher geschrieben habe:

import java.io.*;


public class potenzfeld

{


	public static void main(String args[])

	throws IOException

	{

		int n;

		int x=10;

		int y[];


		BufferedReader din = new BufferedReader(

	                    new InputStreamReader(System.in));


		System.out.print("Bitte geben Sie die Potenz ein: ");

        n = Integer.parseInt(din.readLine()); 


    	y=new int[x];	


    	y[0]=2;

    	y[1]=3;

    	y[2]=4;

    	y[3]=5;

    	y[4]=6;

    	y[5]=7;

    	y[6]=8;

    	y[7]=9;

    	y[8]=10;

    	y[9]=11;    


		for (int i=0; i<=x; i++) //durchläuft das Feld

		{

			for(int j=1; j<n; j++)

			{

				y[i]=potenz(y[i]);	

			}


		}


    }


	private static int potenz(int x) 

	{


		int y;

		y=x;


		return y=y*x;


    }


}

Die Konsole gibt mir aber einen Fehler zurück. Dieser lautet folgendermaßen:

java.lang.ArrayIndexOutOfBoundsException: 10 at potenzfeld.main(potenzfeld.java:36) Exception in thread "main"

Doch wo überschreite ich das Feld. Ich komme mir so blöd vor, das sollte doch total einfach sein. Denn wenn ich das ganze nur mit einer einzelnen Zahl machen soll bekomme ich das hin, denn dann würde der Code lediglich so lauten:

import java.io.*;


public class potenz

{

	public static void main(String args[])

	throws IOException

	{

		int n;

		int y;

		int z=4;

		System.out.println(+z);


		BufferedReader din = new BufferedReader(

	                    new InputStreamReader(System.in));


		System.out.print("Bitte geben Sie die Potenz ein: ");

        n = Integer.parseInt(din.readLine()); 


    	y=z;


    	if (n==0)

    	y=1;

    	if (n==1)

    	y=z;

    	else


    	while(n!=1) //nicht ungleich 0! Denn dann multipliziert er einmal zuviel

    	{


    		y=y*z;

    		n--;

    	} 	


    	System.out.println(+y);


     }

}

Dabei fällt mir auf, dass ich oben gar nicht die Potenzen 0 und 1 berücksichtigt habe. Aber das wäre ja das kleinere Problem, wenn ich wüsste wie ich das ganze mit einem Feld und einer Funktion löse.

[A.Z.R.A.E.L.]

Hi!

Ich glaub ich hab deinen Fehler entdeckt:

--------------------------------------------

Verbesserung:

for (int i=0; i<x; i++) //durchläuft das Feld

{

for(int j=1; j<n; j++)

{

y=potenz(y);

}

}

------------------------------------------------

bei der 1. Forschleife hast "<=x" gemacht, richtig wäre aber halt "<" !

Arrays beginnen mit 0 und bei ihrer Deklaration muss du die Größe angeben!

Hier würdest du auf das 11. Element zugreifen obwohl dein Array nur für 10 reserviert ist!

Gruß

Azrael

[witch doctor]

Also bei <x terminiert das Programm nicht.

Und es sind ja 10 Elemente. Es geht ja von 2 bis 11, also 10.

Bin schon richtig verzweifelt. Wenn ich schon so ein einfaches Prog nicht hinbekomme...

[witch doctor]

Quatsch termininiert wohl, habe nur die Programmausgabe vergessen. *lol*

Doch ganz korrekt ist es noch nicht.

Der gibt mir bei einer Eingabe von Potenz 4 folgendes aus:

Bitte geben Sie die Potenz ein: 4

256

6561

65536

390625

1679616

5764801

16777216

43046721

100000000

214358881

Die Werte sind ein wenig zu hoch, denke ich.

Ach ja benutze ich anstatt der zweiten For-Schleife eine while - Schleife mit folgendem Code

while(n!=1)

{

         y[i]=potenz(y[i]);

         n--;

}

Dann errechnet er mir nur den ersten Wert im Array, also er rechnet nur 2 hoch n. Warum?

Er müsste doch genauso durchlaufen, oder nicht?

[witch doctor]

Komisch bei Potenzen von 1 und 2 rechnet er richtig.

Ab 3 nicht mehr. Verstehe ich nicht.

Bei gibt er folgendes aus:

Bitte geben Sie die Potenz ein: 3

16

81

256

625

1296

2401

4096

6561

10000

14641

Das entspräche aber der Potenz von 4. Wie kann das?

Bei 2 ist alles korrekt, aber bei 3 nciht mehr.

Eigentlich sollte man froh sein, dass es die java.math Klasse gibt.

Denn dann sähe ein funktionierendes Programm so aus:

import java.io.*;

import java.math.*;

public class aufgabe12

{

/* entspricht nicht zu 100 %

 * der Aufgabenstellung

 * Man sollte eigentlich selbst ne Funktion schreiben

 * Hier geschieht es über die java.math klasse

 */



public static void main(String args[])

throws IOException

{

	double Ergebnis=0;

    double n;


    BufferedReader din = new BufferedReader(

	                    new InputStreamReader(System.in));


System.out.print("Bitte geben Sie die Potenz ein ");

        n = Integer.parseInt(din.readLine()); // Einlesen eines Ganzzahlwertes


for (int i=0;i<=11;i++)

	{

 		Ergebnis=Math.pow(i,n);

 		System.out.println("Die Zahl " +i+ " hoch " +n+ " ergibt " +Ergebnis);

}      


     }

}

     

Doch wüsste ich schon gerne wie das math.pow arbeite bzw.

wie ich das programmieren kann ohne auf diese Klasse zuzugreifen.

[witch doctor]

bei der 1. Forschleife hast "<=x" gemacht, richtig wäre aber halt "<" !

Arrays beginnen mit 0 und bei ihrer Deklaration muss du die Größe angeben!

Hier würdest du auf das 11. Element zugreifen obwohl dein Array nur für 10 reserviert ist!

Klar das Arrays von 0 beginnen, aber irgendwie verstehe trotzdem noch nicht, warum ich nicht <= schreiben darf.

Dann greife ich doch nicht auf das 11. Element zu, sondern auf das 10. ,oder?

Aber komischerweise nimmt er das letzte Element bei < ja mit. Doch warum weiß ich nicht.

PS: Danke

[nic_power]

Bei <=10 greifst Du auf y[10] zu, dies ist aber das 11. Element [0..10].

Nic

[witch doctor]

Ach so. Okay, das habe ich verstanden.

Jetzt muss ich nur noch herausfinden, warum das Programm bei einer Potenz von 1 und 2 richtig rechnet und ab einer Potenz von 3 nicht mehr.

[Peregrin]

hi,

wenn man die funktion potenz so schreibt, wie si mathematisch definiert ist, geht das ganze recht einfach...

 

    private int potenz(int base, int exp){

        int ret = base;


        if(exp == 0){

            // x^0 is defined as 1

            return 1;

        }

        for (int i = 1; i < exp; i++){

            ret = ret * base;

        }


        return ret;

    }

ich glaub das geht nur fuer positive zahlen, habs aber nicht ausprobiert...

diese funktion einfach mit der (angegebenen) basis 10 mal mit jeweils erhoehtem exponenten aufrufen und es werden die korrekten potenzen zurueckgegeben.

hoffe, es hilft...

[Klotzkopp]

@witch doctor:

Deine potenz-Funktion liefert immer das Quadrat ihres Arguments zurück. Wenn du diesen Rückgabewert immer wieder als Argument verwendest, errechnest du nicht y hoch n, sondern y hoch (2 hoch n-1):

y = 4;

y = potenz( y ); // y = 16 (4 hoch 2)

y = potenz( y ); // y = 256 (4 hoch 4)

y = potenz( y ); // y = 65536 (4 hoch 8)

[witch doctor]

Aber ich habe es genauso gemacht, als wenn ich kein Feld hätte. Wieso macht er das? Irgendwie blicke ich da nicht durch. Probiere gleich erstmal die Funktion aus.

Edit:

Habe gerade die Funktion ausprobiert und sie funtkioniert.

Sie geht zwar nicht bis 11, aber das bekomme ich auch noch hin. Sie geht nämlich nur bis 9.

Na ja, dafür habe ich das programmieren von Funktionen und Ausführen dadurch verstanden.

[witch doctor]

Oh man so ein einfaches Programm habe ich nicht hinbekommen. *schäm*

Hier für interessierende der Programm-Code

import java.io.*;


public class potenzfeld

{


	public static void main(String args[])

	throws IOException

	{

		int n;

		int x=12;

		int y[];


		BufferedReader din = new BufferedReader(

	                    new InputStreamReader(System.in));


		System.out.print("Bitte geben Sie die Potenz ein: ");

        n = Integer.parseInt(din.readLine()); 


    	y=new int[x];	



		 	for (int i=2; i<x; i++) //durchläuft das Feld

  			 {


					y[i]=potenz(i,n);



			   System.out.println(+y[i]);

  			 }


    }


	 private static int potenz(int base, int exp)

	 {

        int temp = base;


        if(exp == 0)

        {

            // x^0 ist 1

            return 1;

        }

        for (int i = 1; i < exp; i++)

        {

            temp = temp * base;

        }


        return temp;

    }

}

Ich brauchte hier gar nicht dem Feld logischerweise nicht die Werte zuweisen. Das geschieht ja schon in der Schleife. Ich muss ihm lediglich Platz für 12 Elemente schaffen, da ja 0 bis 11. Ich durchlaufe das Feld und potenziere jedes Element von 2 bis 11 bzw. Element 12 mit Hilfe der Funktion. In der Funktion deklariere ich selbstverständlich Basis und Exponenten (das ich darauf nicht gekommen bin *schäm*). Dort überprüft er zunächst, ob der Exponent 0 ist, wenn dies zutrifft gibt er 1 zurück. Wenn nicht, dann geht er über in die Schleife, die bei 1 beginnt und bei kleiner als exponent aufhört. Bei 2 führt er also das ganze nur einmal durch.

Dort mulitpliziere ich die Variable temp, der ich zuerst den Wert der Basis zugewiesen habe, mit der Basis. Das Ergebnis wird in temp gespeichert und zurückgegeben.

Die Funktion wird im Hauptprogramm folgendermaßen aufgerufen:

y=potenz(i,n).

Jetzt wird i potenziert und im Array gespeichert.

Falls die Erklärung richtig ist, habe ich es verstanden!!

PS: Im Grunde funktioniert java.math.pow doch nicht anders oder?