# In Java potenzieren



## Ceka (23. Jul 2017)

Hallo,

ich habe folgende Frage:
beide Codes sollten doch das gleiche Ergebnis ausgeben oder nicht?
Ich weiß, dass Java den Überlauf einfach abschneidet, daher vermute ich, dass die Schleifen Version deshalb ein anderes Ergebnis ausgibt.
Gibt es eine Möglichkeit, dass Ergebnis der Schleifen Version in konstanter Zeit zu bekommen bzw. ohne Schleife?

```
int g = 257
for (int j = 0; j < 4; j++) {
      g *= 257;
    }
return g;
```



```
return (int)Math.pow(257, 5);
```


----------



## Dompteur (23. Jul 2017)

Initialisiere "g" in deinem ersten Beispiel mit 1 und probier es noch einmal.


----------



## Ceka (23. Jul 2017)

Dürfte das eigentlich kein Unterschied machen?
Dann könnte ich die Bedingung j < 5 setzten aber vom Wert müsste das gleiche raus kommen.


----------



## DrZoidberg (23. Jul 2017)

257^5 ist 1121154893057. Eine int Variable kann aber maximal den Wert 2147483647 haben. Du müsstest also long verwenden. Wenn du den Überlauf aber haben möchtest, kannst du schreiben (int)((long)Math.pow(257, 5)).


----------



## Ceka (23. Jul 2017)

Vielen Dank =)


----------



## Ceka (24. Jul 2017)

Jetzt habe ich nochmal eine Frage:

Bei folgendem:

```
int i = 257;
    for (int j = 0; j < 148; j++) {
      i *= 257;
    }
```
kommt
-1659726591

Und bei:


```
int c = (int) (long) Math.pow(257, 149);
return c;
```

kommt -1 raus

Woran liegt das?

Weil das über long geht?
und wie bekomme ich mein eigentlich gewolltes Ergebnis dann?


----------



## Flown (24. Jul 2017)

Zahlen ohne Begrenzung sind `BigInteger`(für ganze Zahlen) und `BigDecimal`(für Fließkommazahlen).


----------



## Flown (24. Jul 2017)

Dann bekommst du auch 
	
	
	
	





```
257^149=12023623715634237231815653215429
88890656337778991649834438
75873330226290939237752461
06097564973437686661724040
42284212601861662515173801
22148110797524690221315441
56431877340180489035972485
34773344771765516900076456
71553522701703133639183477
33660574770194455058155581
53506040633895677907275860
30529610329746078647219761
28953156103527228086480495
1208636988953857
```
 raus.


----------



## Ceka (24. Jul 2017)

Anders geht es nicht?


----------



## Flown (24. Jul 2017)

Hast du dir die Zahl schon mal angesehen?
Hier sind die Maxima und Minima der einzelnen Datentypen und dann zieh mal einen Schluss.


----------



## Flown (24. Jul 2017)

Für double ist es `1.7976931348623157E308`
Deine Zahl ist aber `1.202362371563423723181565321542988890656337778991649... × 10^359`

Ergo?


----------



## Ceka (24. Jul 2017)

Ja, ich kenne die Datentypen und deren Grenzen.
Danke trotzdem =)


----------



## DrZoidberg (26. Jul 2017)

Ich frage mich wofür du das brauchst und wieso eine Schleife nicht gut genug ist?
Hier ist mal eine alternative Lösung, die sehr viel schneller ist als deine Schleife.

```
static int pow(int a, int b) {
  if(b == 0) return 1;
  if(b == 1) return a;
  if(b % 2 == 1) {
    return pow(a, b-1) * a;
  }
  int x = pow(a, b/2);
  return x * x;
}
```


----------

