# Zweierpotenzen addieren



## Jats (25. Okt 2010)

Hey, kann mir jemand helfen, eine Datei zu schreiben, die Zweierpotenzen von 2^1 - 2^10 addiert ?

Habe mal so angefangen:


```
public class Potenzieren {						

public static void main(String [] args) {

for ( int f = 1; f <= 10; f++) {

	int summe = 1;

		for ( int s = 1; f <= 10; f++) {
	
		summe = summe + (potenzieren(2,f));
		System.out.println(summe);
		
		}

	}

}

public static int potenzieren(int basis, int exponent) { 		//Methode potenzieren faengt an

	int potenz = 1;

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

	potenz = potenz * basis;

}

return potenz;

}									//Ende potenzieren

}
```
Aber ich komme irgendwie nicht weiter .. kann mir jemand mal helfen ?


----------



## Firephoenix (25. Okt 2010)

Benutz doch für Potenzen Math.pow(Basis,Exponent) oder willst du bewusst um den befehl herum?
Gruß


----------



## Jats (25. Okt 2010)

Firephoenix hat gesagt.:


> Benutz doch für Potenzen Math.pow(Basis,Exponent) oder willst du bewusst um den befehl herum?
> Gruß



Ja, will ich


----------



## Firephoenix (25. Okt 2010)

wie wäre es denn damit (ungetestet)

```
for ( int s = 1; s <= 10; s++) {
				int summe = 0;
				summe = summe + (potenzieren(2,f));
				System.out.println(summe);
			
			}
	 
 
	public static int potenzieren(int basis, int exponent) {        //Methode potenzieren faengt an
	 
		int potenz = 0;
	 
		for (int i = 1; i <= exponent; i++) {
	 
		potenz = potenz * basis;
	 
		}
	 
		return potenz;
	 
	}                                   //Ende potenzieren
```


----------



## XHelp (25. Okt 2010)

Es könnte vllt daran liegen, dass du summe mit 1 und nicht mit 0 initialisierst?


----------



## Gast2 (25. Okt 2010)

```
for ( int s = 1; s <= 10; s++) {
                int summe = 0;
                summe = summe + (potenzieren(2,f));
                System.out.println(summe);
            
            }
```
summe sollte wohl außerhalb der if initalisiert werden, oder?


----------



## Jats (25. Okt 2010)

Also so .. 
	
	
	
	





```
public class Potenzieren {						//Potenzieren, 06.10.2010, 21:20Uhr, Jason Tschorn		

public static void main(String [] args) {

for ( int s = 1; s <= 10; s++) {
                int summe = 0;
                summe = summe + (potenzieren(2,f));
                System.out.println(summe);
            
            
	}


	}

}

public static int potenzieren(int basis, int exponent) { 		//Methode potenzieren faengt an

	int potenz = 1;

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

	potenz = potenz * basis;

}

return potenz;

}									//Ende potenzieren

}
```

das geht nicht, dann kommt immer zehnmal 2,4,8 usw. raus :/


----------



## Firephoenix (25. Okt 2010)

bau dir noch eine int gesamtsumme rein und führe nach jedem durchlauf folgendes aus:

```
gesamtsumme += summe
```
am Ende gesamtsumme ausgeben.


----------



## Gast2 (25. Okt 2010)

oder summe einfach vor der if initialisieren...


----------



## XHelp (25. Okt 2010)

Zumal noch eine Anmerkung... Ist es immer zur Basis 2? Das ganze mal binär betrachtet:

```
2^1 =   10
2^2 =  100
2^3 = 1000
dementsprechend:
2^1+2^2 =   110
+2^3    =  1110
+2^4    = 11110
usw.
```

Dann könntest du dir das Potenzieren sparen. Zumal du zum Potenzieren bzw. *2 auch Shiften kannst.


----------



## Jats (25. Okt 2010)

XHelp hat gesagt.:


> Zumal noch eine Anmerkung... Ist es immer zur Basis 2? Das ganze mal binär betrachtet:
> 
> ```
> 2^1 =   10
> ...



Tut mir Leid, bin grad ein bisschen durch den Wind .. ihr hab nicht zufaellig ein Forum fuer zwischenmenschliches ? :/ 

Also .. es ist schon immer mit 2 als Basis, sind ja Zweierpotenzen .. aber ich verstehe deinen Ansatz nicht.
Tut mir Leid, ich muss jetzt weg .. ich gucke, dass ich das entweder gleich nochmal oder morgen mache .. trtozdem danke .


----------



## XHelp (25. Okt 2010)

Jats hat gesagt.:


> aber ich verstehe deinen Ansatz nicht.



Vllt wird er dadurch deutlicher:

```
public static void workOR() {
	int b = 0;
	int c = 1;
	for (int i = 0; i < 9; i++) {
		c = c << 1;
		b = b | c;
		System.out.println(b);
	}
}

public static void workBinary() {
	char[] sum = new char[] { '0', '0', '0', '0', '0', '0', '0', '0', '0', '0' };
	for (int i = sum.length - 2; i >= 0; i--) {
		sum[i] = '1';
		System.out.println(Long.parseLong(String.valueOf(sum), 2));
	}
}
```

Die erste Methode bezieht sich auf das Shiften, dadurch kannst du entweder *2 oder /2 rechnen.
Die 2. bezieht sich auf das einfache Setzen der Bits (wobei es in dieser Form eher zur Veranschaulichung gilt)


----------



## Jats (26. Okt 2010)

XHelp hat gesagt.:


> Vllt wird er dadurch deutlicher:
> 
> ```
> public static void workOR() {
> ...



Okay, alles klar hab's soweit verstanden.
Aber ich glaube, ich verschachtel die Schleifen entweder falsch, oder mache falsche Wertzuweisungen.
Bei mir kommt fast immer 4,1 oder die Zweierpotezen von 1 bis 10, nur das nach jeder Runde -1 gerechnet wird -.-

Wie muss ich die Schleifen veschachteln .. falls ich das muss ^^


----------



## Andi_CH (26. Okt 2010)

Warum denn kompliziert wenns auch einfach geht? ;-)


```
int Summe = 0;
		for (int i =1; i<=10; i++) {
			Summe += Math.pow(2.0, i);
			System.out.println("i = " + i + ", Summe = " + Summe);
		}
```

und anstellen von Math.pow passt jede beliebige implementation von "pow" ;-)


----------



## mariusbopp (26. Okt 2010)

ja aber gerade so wollte er es nicht machen!

soll anscheind kompliziert sein


----------



## XHelp (26. Okt 2010)

Du musst nicht verschechteln. Das sind 2 verschiedene Ansätze


----------



## Jats (26. Okt 2010)

mariusbopp hat gesagt.:


> ja aber gerade so wollte er es nicht machen!
> 
> soll anscheind kompliziert sein



Richtig, ich will kein Math.pow benutzen, sondern lieber meine eigene Methode .
Aber die muss ich jetzt doch nur so einsetzen, wie Math.pow von Andi_CH gezeigt wurde, oder ?

Dann würde ich das so machen 
	
	
	
	





```
public class Potenzieren {                      
 
public static void main(String [] args) {
 
int summe = 0;

for ( int f = 1; f <= 10; f++) {

		summe += (potenzieren(2,f));
    		System.out.println(summe);        
        }
 
}
 
public static int potenzieren(int basis, int exponent) {        //Methode potenzieren faengt an
 
    int potenz = 1;
 
for (int i = 1; i <= exponent; i++) {
 
    potenz = potenz * basis;
 
}
 
return potenz;
 
}                                   //Ende potenzieren
 
}
```

und das würde herauskommen:


----------



## mariusbopp (26. Okt 2010)

>



stimmt aber nicht ganz...

s fehlen immer 2...soweit ich das jetzt sehe...


----------



## XHelp (26. Okt 2010)

Warum sollen denn da werlche fehlen?


----------



## Andi_CH (26. Okt 2010)

```
private static int pow(int pBase, int pExp) {
		if (pExp < 1) {
			System.out.println("ungültig!");
			return 0;
		}
		if (pExp == 1)
			return pBase;
		else
			return (pBase * pow(pBase, pExp-1));
	}
```

Na ja ich gebs zu '-'liesse sich sicher auch so implementieren, aber ich war zu faul ;-)


----------



## LadyMilka (26. Okt 2010)

sieht doch gut aus

2+*4*=6
6+*8*=14
usw..


----------



## Landei (26. Okt 2010)

Nehmt wenigstens einen ordentlichen Algorithmus...

```
public static long pow(long x, int n) {
        long result = 1;
        for (;n > 0; x *= x, n >>= 1) 
           if ((n & 1) != 0) result *= x;
        return result;
    }
```


----------



## mariusbopp (26. Okt 2010)

XHelp hat gesagt.:


> Warum sollen denn da werlche fehlen?



naja weil es ja sein müsste
2^1=2
2^2=4
2^3=8
...
2^10=1024
usw...

und ich denke es geht darum die potenzen von 2^1 bis 2^10 auszugeben oder???(und wenns so ist dann stimmen die ausgaben ja nicht!)


----------



## Andi_CH (26. Okt 2010)

Landei hat gesagt.:


> Nehmt wenigstens einen ordentlichen Algorithmus...
> 
> ```
> public static long pow(long x, int n) {
> ...



Ach immer diese Landeier die in einem früheren Leben mal C-Programmierer waren ;-)
(Meiner gefällt mir viel besser )

Aber gibt mal einen negativen Exponenten ein - das Resultat dürfte spektakulär sein 

siehe Zeile: n--;


----------



## XHelp (26. Okt 2010)

mariusbopp hat gesagt.:


> und ich denke es geht darum die potenzen von 2^1 bis 2^10 auszugeben oder???(und wenns so ist dann stimmen die ausgaben ja nicht!)



Selbst der Threadtitel heißt "Zweierpotenzen *addieren*"


----------



## Andi_CH (26. Okt 2010)

XHelp hat gesagt.:


> Selbst der Threadtitel heißt "Zweierpotenzen *addieren*"



Das Thema hat sich mutiert und heisst nun: "*Zweierpotenzen* addieren"


----------



## mariusbopp (26. Okt 2010)

oh man wie blind kann man sein^^
dann tuts mir leid für meinen unqualifizierten beitrag zu diesem thema 

edit okay dann wars doch nicht so falsch gewesen es hieß mal nur ausgeben!!! :toll:
hab schon an mir gezweifelt grade^^


----------



## VfL_Freak (26. Okt 2010)

Moin,



XHelp hat gesagt.:


> Warum sollen denn da werlche fehlen?



die Aussage war auch nicht, dass da einzelne Zahlen fehlen, sondern das jedes Ergebnis um 2 zu niedrig ist :
*2^2 = 4
2^3 = 8
2^4 = 16
2^5 = 32
2^6 = 64 ..... etc.*

Gruß
Klaus


----------



## Landei (26. Okt 2010)

Andi_CH hat gesagt.:


> Ach immer diese Landeier die in einem früheren Leben mal C-Programmierer waren ;-)


War ich nie. Und den Code habe ich noch etwas verhypscht.



> (Meiner gefällt mir viel besser )


Dafür ist er ineffizient. Du hast O(n) und ich habe O(log n) oder so: Binäre Exponentiation ? Wikipedia



> Aber gibt mal einen negativen Exponenten ein - das Resultat dürfte spektakulär sein
> 
> siehe Zeile: n--;


Nörgler! Negative Exponenten lassen sich grundsätzlich nicht in einer Funktion behandeln, die einen Ganzzahltyp zurückgibt. Einfach einen Wrapper drum schreiben, und gut ist:


```
public static double betterPow(long x, int n) {
   return n > 0 ? pow(x,n) : 1.0 / pow(x, -n); 
}
```


----------



## Andi_CH (26. Okt 2010)

Nörgeln tue ich doch gerne .... gleich noch was: :lol:

Vergiss 2^0 nicht

die Reihe könnte auch
2^0 = 1
+ 2^1 = 3
+ 2^2 = 7
sein ...


----------



## XHelp (26. Okt 2010)

2^0 wird doch richtig ausgerechnet... :bahnhof:


----------



## Andi_CH (26. Okt 2010)

VfL_Freak hat gesagt.:


> Moin,
> die Aussage war auch nicht, dass da einzelne Zahlen fehlen, sondern das jedes Ergebnis um 2 zu niedrig ist :
> *2^2 = 4
> 2^3 = 8
> ...


Es geht um den Ausdruck "... um 2 zu niedrig ..."
ich nörgle nicht immer an denselben Usern rum - es dürfen alle was haben ...

Edit: Laut Ausgangsposting beginnt die Reihe bei 2^1, also liege ich daneben

PS: Das mit O(n) habe ich schon im Nachdiplomstudium nicht so richtig begriffen - hab aber danach doch so einen Zettel erhalten ;-)


----------



## Jats (26. Okt 2010)

mariusbopp hat gesagt.:


> stimmt aber nicht ganz...
> 
> s fehlen immer 2...soweit ich das jetzt sehe...




Ich weiß ^^
Das ist ja das Problem .. ich hatte das Programm schon so weit, dass es mir jede Potenz zusammenrechnet, aber das wäre ja dasselbe, wie 2^n*2.
Ich möchte aber (2^1)+(2^2)+(2^3)...(2^10) ausgerechnet haben.
Vor mir aus kann das Programm schon jeden Schritt einzeln ausgeben, aber es muss doch irgendwie auch das richtige rauskommen 

Jetzt fehlt doch eigentlich nurnoch der Schritt, indem das, was beim ersten Durchgang von "summe += potenzieren(2,f);" herauskommt zu dem Ergebnis vom nächsten Durchgang dazugerechnet wird, und dann imemr so weiter, oder ?


----------



## Andi_CH (26. Okt 2010)

Jats hat gesagt.:


> Ich weiß ^^
> Das ist ja das Problem .. ich hatte das Programm schon so weit, dass es mir jede Potenz zusammenrechnet, aber das wäre ja dasselbe, wie 2^n*2.
> Ich möchte aber (2^1)+(2^2)+(2^3)...(2^10) ausgerechnet haben.
> Vor mir aus kann das Programm schon jeden Schritt einzeln ausgeben, aber es muss doch irgendwie auch das richtige rauskommen
> ...



???:L += rechnet doch dazu ???:L


----------



## XHelp (26. Okt 2010)

Jats hat gesagt.:


> Ich möchte aber (2^1)+(2^2)+(2^3)...(2^10) ausgerechnet haben.



Öhm... was soll denn deiner Meinung für ein Ergebnis rauskommen, wenn nicht 2046?


----------



## Jats (26. Okt 2010)

Andi_CH hat gesagt.:


> ???:L += rechnet doch dazu ???:L



Ja, aber das Ergebnis stimmt doch nicht, oder .. ? :bahnhof:
Es würde ja als Addition so aussehen:
2+4+8+16+32+64+128+256+512+1024+2048 

Dann is das was oben herauskommt aber falsch .. oder wie oder was oder .. was macht das Programm überhaupt, ich begreif es nicht, dass da einfach 2 pro Ergebnis fehlen ^^


----------



## Jats (26. Okt 2010)

XHelp hat gesagt.:


> Öhm... was soll denn deiner Meinung für ein Ergebnis rauskommen, wenn nicht 2046?



Alles zusammen .. bis dahin ist es ja richtig (wenn nicht 2 fehlen würden, Prinzip stimmt ja) und dann noch 2048 dazu .
Also 4096 .. EDIT: SCHEIßE :lol:
Jaa .. ihr habt Recht .. ich sollte Kopfrechnen besser üben oder erstmal gucken, was ich schreibe ^^
Also dann müsste es ja so stimmen, oder ? 
Nur das immer 2 fehlt ..


----------



## XHelp (26. Okt 2010)

2048 ist 2^11, in wie fern soll es bei der Summe von 2^1 bis 2^10 auftauchen? :bahnhof:
Nimm dir doch ein Zettel und ein Strift und rechne es nach.


----------



## Andi_CH (26. Okt 2010)

i = 1 : 0 + 2 = 2
i = 2 : 2 + 4 = 6
i = 3 : 6 + 8 = 14
i = 4 : 14 + 16 = 30
i = 5 : 30 + 32 = 62
i = 6 : 62 + 64 = 126
i = 7 : 126 + 128 = 254
i = 8 : 254 + 256 = 510
i = 9 : 510 + 512 = 1022
i = 10 : 1022 + 1024 = 2046

da fehlt nichts!


----------



## Jats (26. Okt 2010)

Andi_CH hat gesagt.:


> i = 1 : 0 + 2 = 2
> i = 2 : 2 + 4 = 6
> i = 3 : 6 + 8 = 14
> i = 4 : 14 + 16 = 30
> ...



Gut, jetzt hat auch der letzte es Verstanden 
Dann weiß ich jetzt, wodran es liegt, aber ich weiß noch nicht Recht, warum es mir nicht vorher aufgefallen ist .

Auf jeden Fall danke für eure Mühe und Geduld :toll:


----------

