# Rechnen mit big integer



## Anfänger123 (28. Jan 2010)

Hallo !

Wir haben in der Schule gerade Java angefangen, brauche aber für eine komplexere Matheaufgabe ein Programm. Kennt ihr noch diese Multiplikationspyramiden ? 1. * 2. Zahl ergibt Zahl darüber ? Darum gehts im Endeffekt, man soll herausfinden wieviele Möglichkeiten es für die unteren Kästchen gibt, die in der Spitze 141523200000 ergeben. Das ist aber mit normal int nicht zu machen. kann mir vllt. jmd. zeigen wie ich daraus eine big int oder big dec mache ?

Bin jetzt soweit:

```
class Rechnen2 {
  public static void main(String[] args) {
    int n = 0;
    int Spitze = 10;

    //Probieren bis es klappt
    for (int faktor_a = 1; faktor_a <= (Spitze / 2); faktor_a++) {
      for (int faktor_b = 1; faktor_b <= (Spitze / 2); faktor_b++) {
        for (int faktor_c = 1; faktor_c <= (Spitze / 2); faktor_c++) {
          for (int faktor_d = 1; faktor_d <= (Spitze / 2); faktor_d++) {
            for (int faktor_e = 1; faktor_e <= (Spitze / 2); faktor_e++) {
              for (int faktor_f = 1; faktor_f <= (Spitze / 2); faktor_f++) {
                //Püfen ob Zahl schon erreicht ist
                if ((faktor_a * faktor_b * faktor_b * faktor_b * faktor_b * faktor_b * 
faktor_c * faktor_c * faktor_c * faktor_c * faktor_c * faktor_c * faktor_c * faktor_c * faktor_c * faktor_c * 
faktor_d * faktor_d * faktor_d * faktor_d * faktor_d * faktor_d * faktor_d * faktor_d * faktor_d * faktor_d * 
faktor_e * faktor_e * faktor_e * faktor_e * faktor_e * faktor_f) == 20) {
                  System.out.println("a = " + faktor_a);

                  System.out.println("b = " + faktor_b);

                  System.out.println("c = " + faktor_c);

                  System.out.println("d = " + faktor_d);

                  System.out.println("e = " + faktor_e);

                  System.out.println("f = " + faktor_f);
                  System.out.println();
                  n = n + 1;


                }
              }
            }
          }
        }
      }
    }
    //Zählen wieviele Möglichkeiten es unten gibt
    System.out.println("Anzahl = " + n);
  }
}
```


----------



## SlaterB (28. Jan 2010)

Spitze 141523200000, cool, davon die Hälfte und das hoch 6, weißt du wieviele Schleifendurchläufe das ergibt?
habe mal bei mir geloggt, mit Spitze 10 dauerts ja keine Zeit, mit Spitze 28 aber schon einer Sekunde, mit 37 fünf Sec,
das geht bald in die Jahrmillionen

technisch wäre es möglich, schon long geht, du brauchst kein BingInteger,
aber was immer du auch da ausrechnen willlst, da muss ein anderer Weg her


```
Spitze: 10, time: 16, Anzahl: 2
Spitze: 11, time: 0, Anzahl: 2  // bei unter 20 ms ist die Zeitrechnung nicht so genau
Spitze: 12, time: 0, Anzahl: 2
Spitze: 13, time: 15, Anzahl: 2
Spitze: 14, time: 16, Anzahl: 2
Spitze: 15, time: 16, Anzahl: 2
Spitze: 16, time: 46, Anzahl: 2
Spitze: 17, time: 47, Anzahl: 2
Spitze: 18, time: 78, Anzahl: 2
Spitze: 19, time: 79, Anzahl: 2
Spitze: 20, time: 156, Anzahl: 4
Spitze: 21, time: 156, Anzahl: 4
Spitze: 22, time: 281, Anzahl: 4
Spitze: 23, time: 266, Anzahl: 4
Spitze: 24, time: 453, Anzahl: 4
Spitze: 25, time: 453, Anzahl: 4
Spitze: 26, time: 735, Anzahl: 4
Spitze: 27, time: 734, Anzahl: 4
Spitze: 28, time: 1125, Anzahl: 4
Spitze: 29, time: 1141, Anzahl: 4
Spitze: 30, time: 1734, Anzahl: 4
Spitze: 31, time: 1797, Anzahl: 4
Spitze: 32, time: 2547, Anzahl: 4
Spitze: 33, time: 2484, Anzahl: 4
Spitze: 34, time: 3594, Anzahl: 4
Spitze: 35, time: 3594, Anzahl: 4
Spitze: 36, time: 5046, Anzahl: 4
Spitze: 37, time: 5016, Anzahl: 4
```


```
public class Test
{
    public static void main(String[] args)
    {

        for (long Spitze = 10; Spitze < 1000; Spitze++)
        {
            int n = 0;
            long time = System.currentTimeMillis();
            // Probieren bis es klappt
            for (long faktor_a = 1; faktor_a <= (Spitze / 2); faktor_a++)
            {
                for (long faktor_b = 1; faktor_b <= (Spitze / 2); faktor_b++)
                {
                    for (long faktor_c = 1; faktor_c <= (Spitze / 2); faktor_c++)
                    {
                        for (long faktor_d = 1; faktor_d <= (Spitze / 2); faktor_d++)
                        {
                            for (long faktor_e = 1; faktor_e <= (Spitze / 2); faktor_e++)
                            {
                                for (long faktor_f = 1; faktor_f <= (Spitze / 2); faktor_f++)
                                {
                                    // Püfen ob Zahl schon erreicht ist
                                    if ((faktor_a * faktor_b * faktor_b * faktor_b * faktor_b * 
                       faktor_b * faktor_c * faktor_c * faktor_c * faktor_c * faktor_c * faktor_c * 
                       faktor_c * faktor_c * faktor_c * faktor_c * faktor_d * faktor_d * faktor_d * 
                       faktor_d * faktor_d * faktor_d * faktor_d * faktor_d * faktor_d * faktor_d * 
                       faktor_e * faktor_e * faktor_e * faktor_e * faktor_e * faktor_f) == 20)
                                    {
                                        n = n + 1;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            System.out.println("Spitze: "+Spitze+", time: " + 
              (System.currentTimeMillis() - time) + ", Anzahl: " + n);
        }
    }
}
```


----------



## Anfänger123 (28. Jan 2010)

so was habe ich schon befürchtet, aber :

a ist max Spitze/2
b ist max 5.Wurzel(Spitze)
c ist max 10.Wurzel(Spitze)
d ist max 10.Wurzel(Spitze)
e ist max 5.Wurzel(Spitze)
f ist max Spitze/2

vllt.s so ?

da Spitze = a b^5 c^10 d^10 e^5 f


----------



## SlaterB (28. Jan 2010)

b bis e gehen vielleicht, a dazu mag sein, aber a und f sind zusammen doch schon 10^20 oder so, da habe ich Zweifel,
aber probiere es aus wenn du willst,
nimm mein Programm für long, oder teste lieber erstmal mit int wie bisher, wenn du bis 1000 und höher kommst, wäre das schon ein Erfolg,

und immer schön sparen, das bisherige Programm rechnet z.B. unendlich oft (Spitze / 2) neu aus, für jeden Schleifendurchlauf in jeder Schleife,
das könnte man auch genau EINMAL berechnen und gut ist (Variable anlegen), 
bei den Wurzeln wäre es noch teurer

und wenn nur die innerste Schleife durchlaufen wird, müssen die 30 Terme für die äußeren Schleifenvariablen nicht jedesmal neu ausgerechnet werden,

und neben diesen Kleinkram noch ne gute Idee:
wenn bei bestimmten a und b alle a * alle b alleine schon > als Spitze sind, dann brauchst du gar nicht erst die c, d, e und f Schleife anfangen,
also am besten in jeder Schleife Zwischenergebnisse berechnen und nur dann tiefer gehen wenn auch nötig,
mit dieser Optimierung scheint eine endliche Rechnung gar nicht mehr so unmöglich


außerdem kannst du f auf immer >= a einschränken, e >= b, c >= d
denn wenn du eine Kombination mit a = 5 und f = 7 gefunden hast, dann wird es mit a= 7 und f = 5 genauso funktionieren,
das musst du nicht extra ausprobieren, das ist immer so,
dadurch kann man auch einiges sparen, nur nicht vergessen am Ende auch die andere Kombination mitzuzählen,
ist dagegen bei einer Kombination a und f gleich, zählt diese nur einmal,
na gut, das ist ziemlich kompliziert, kannst du wohl lieber weglassen


----------



## Anfänger123 (28. Jan 2010)

Vielen Dank für die guten Ideen, leider bin ich wirklich noch Anfänger und habe leider keine Ahnung wie man das umsetzen kannueh: Ich hab mal long eingebaut und die Zahlen manuell ausgerechnet, außerdem habe ich das Ergebnis verfeinert, sodass nur Faktoren ausgegeben werden die *nicht* 1 sind. Hättest du vllt. noch einen Tipp für mich ?


```
class Rechnen2 {
  public static void main(String[] args) {
    int n = 0;
    long Spitze = 141523200000L;
    long Spitze2 = 70761600000L;

    //Probieren bis es klappt
    // Wurzeln habe ich jetzt manuell ausgerechnet
    for (int faktor_a = 1; faktor_a <= Spitze2; faktor_a++) {
      for (int faktor_b = 1; faktor_b <= 169; faktor_b++) {
        for (int faktor_c = 1; faktor_c <= 13; faktor_c++) {
          for (int faktor_d = 1; faktor_d <= 13; faktor_d++) {
            for (int faktor_e = 1; faktor_e <= 169; faktor_e++) {
              for (int faktor_f = 1; faktor_f <= Spitze2; faktor_f++) {
                //Püfen ob Zahl schon erreicht ist
                if ((faktor_a * faktor_b * faktor_b * faktor_b * faktor_b * faktor_b * faktor_c * faktor_c * faktor_c * faktor_c * faktor_c * faktor_c * faktor_c * faktor_c * faktor_c * faktor_c * faktor_d * faktor_d * faktor_d * faktor_d * faktor_d * faktor_d * faktor_d * faktor_d * faktor_d * faktor_d * faktor_e * faktor_e * faktor_e * faktor_e * faktor_e * faktor_f) == Spitze) {
                  if (faktor_a == 1) {
                  } else {
                    System.out.println("a = " + faktor_a);
                  }

                  if (faktor_b == 1) {
                  } else {
                    System.out.println("b = " + faktor_b);
                  }

                  if (faktor_c == 1) {
                  } else {
                    System.out.println("c = " + faktor_c);
                  }

                  if (faktor_d == 1) {
                  } else {
                    System.out.println("d = " + faktor_d);
                  }

                  if (faktor_e == 1) {
                  } else {
                    System.out.println("e = " + faktor_e);
                  }

                  if (faktor_f == 1) {
                  } else {
                    System.out.println("f = " + faktor_f);
                  }

                  System.out.println();
                  n = n + 1;
                }
              }
            }
          }
        }
      }
    }

    //Zählen wieviele Möglichkeiten es unten gibt
    System.out.println("Anzahl = " + n);
  }
}
```


----------



## SlaterB (28. Jan 2010)

dass du die Wurzel kaum ausrechnen kannst ist verständlich aber
    long Spitze = 141523200000L;
    long Spitze2 = 70761600000L;
muss doch nicht sein, schreibe
    long Spitze = 141523200000L;
    long Spitze2 = Spitze/2;

zum Haupttipp:

```
for a..
  for b ..
     double x = 1.0 * faktor_a * faktor_b * faktor_b * faktor_b * faktor_b * faktor_b;
     if (x > Spitze) {
        break;
     }
```
besser erstmal mit double rechnen, dann ist ein Überlauf des Zahlenbereichs unwahrscheinlicher,
durch das break; wird direkt die aktuelle b-Schleife abgebrochen, das b selber ist schon zu groß, und alle größeren b noch schlimmer

falls es doch zum c geht, dann dort weiterrechnen:

```
for c ..
     double y = x * c * c ...
     if (y > Spitze) {
        break;
     }
```
usw., das sollte dazu helfen,
ganz in der Mitte aber nicht darauf verlassen, dass die double-Werte genau Spitze entsprechen, dann ruhig wie bisher nochmal alles als long multiplizieren und vergleichen

und wirklich erstmal mit Zahlen wie 1000 testen, die inneren Faktoren kannst du ruhig so lassen wie sie sind,

wahrscheinlich funktioniert es so immer noch nicht, morgen kann ich da etwas genauer prüfen,
aber wenn du es nicht selber machst, musst du zumindest warten 
(oder jemand anders schaut hier rein)


edit: auch wieder besser wäre, die kürzeren Schleifen b, c, d, e nach außen zu legen,
dann muss c^10 als äußerste Schleife nur insgesamt 13x berechnet werden statt  Milliarden Mal für fast jedes a neu,


----------



## Anfänger123 (28. Jan 2010)

Ich habe mir das Problem nochmal mathematisch angeschaut und habe b,c,d,e auf jeweils max 4 Variablen begrenzen können. Natürlich hab eich wie immer keine Ahnung wie man das umwandeln kann  Ist leider ziemlich unübersichtlich geworden.

Bsp: In Faktor_c muss entweder 1 oder 2 rein. Wenn c bsp. 2 ist, darf d nicht 2 sein, also 1. Es dürfen aber auch beide 1 sein. Ich hoffe dass du mir iwie weiterhelfen kannst. geht das mit boolean oder sowas ?


```
class Rechner2 {
  public static void main(String[] args) {
    int n = 0;
    long Spitze = 141523200000L;
    long HaelfteSpitze = Spitze/2;

    //Probieren bis es klappt
        for (int faktor_c = 0; faktor_c <= 2; faktor_c = 2??) {    //faktor_c ist entweder 1 oder 2
           if(faktor_c==2){
//gleich weiter springen zu faktor_b, da entweder c oder d die 2 haben können  oder gar keiner von beiden

           }
      for (int faktor_d = 0; faktor_d <= 2; faktor_d = 1??) {     //faktor_d ist entweder 1 oder 2, aber c und d sind nie gleichzeitig 2, wenn c 2 ist, ist also d 1


        for (int faktor_b = 1; faktor_b <= 5; faktor_b=??) { //faktor b kann 1, 2,3 oder 5 sein. e und b können gleichzeitig 1 oder 2 sein, aber nicht die anderen Zahlen (3,5) gleichzeitig
          if (faktor_b==1 or 2 ???) {
            //Alle Möglichkeiten inclusive 1 und 2 für e ausprobieren
          }
          

          for (int faktor_e = 1; faktor_e <= 5; faktor_e=??)

            for (int faktor_a = 1; faktor_a <= HaelfteSpitze; faktor_a++) {
              double x = faktor_b * faktor_b * faktor_b * faktor_b * faktor_b * faktor_c * faktor_c * faktor_c * faktor_c * faktor_c * faktor_c * faktor_c * faktor_c * faktor_c * faktor_c * faktor_d * faktor_d * faktor_d * faktor_d * faktor_d * faktor_d * faktor_d * faktor_d * faktor_d * faktor_d * faktor_e * faktor_e * faktor_e * faktor_e * faktor_e;
                if (t > Spitze) {break;}

                //kann man hier vllt. einstellen, dass das nur alle ca. 100.000 Zahlen geprüft werden soll ?
              }

              for (int faktor_f = 1; faktor_f <= HaelfteSpitze; faktor_f++) {


                //Püfen ob Zahl schon erreicht ist
                if ((faktor_a * faktor_b * faktor_b * faktor_b * faktor_b * faktor_b * faktor_c * faktor_c * faktor_c * faktor_c * faktor_c * faktor_c * faktor_c * faktor_c * faktor_c * faktor_c * faktor_d * faktor_d * faktor_d * faktor_d * faktor_d * faktor_d * faktor_d * faktor_d * faktor_d * faktor_d * faktor_e * faktor_e * faktor_e * faktor_e * faktor_e * faktor_f) == Spitze) {
                  if (faktor_a == 1) {
                  } else {
                    System.out.println("a = " + faktor_a);
                  }

                  if (faktor_b == 1) {
                  } else {
                    System.out.println("b = " + faktor_b);
                  }

                  if (faktor_c == 1) {
                  } else {
                    System.out.println("c = " + faktor_c);
                  }

                  if (faktor_d == 1) {
                  } else {
                    System.out.println("d = " + faktor_d);
                  }

                  if (faktor_e == 1) {
                  } else {
                    System.out.println("e = " + faktor_e);
                  }

                  if (faktor_f == 1) {
                  } else {
                    System.out.println("f = " + faktor_f);
                  }

                  System.out.println();
                  n = n + 1;
                }
              }
            }
          }
        }
      }
    }

    //Zählen wieviele Möglichkeiten es unten gibt
    System.out.println("Anzahl = " + n);
  }
}
```


----------



## moormaster (29. Jan 2010)

Irgendwie kommt mir das alles recht chaotisch vor 

Also es gibt eine Zahl an der Wurzel, die sich aus Multiplikation der beiden Nachfolgerzahlen darunter ergeben soll... im Prinzip haben wir also einen Baum. Dieser wird nun eindeutig bestimmt durch die Werte, die ganz unten in den Blättern stehen. Das heisst man muss auch nur diese durchprobieren...

Und um diese zu bestimmen, muss man nicht 200 000 Faktoren wild mit ner for Schleife durchlaufen, sondern man führt eine Primfaktorzerlegung durch.

Für die Zahl 200 z.B.:  200 = 2*2*2*5*5

D.h. es gibt insgesamt 5 Primfaktoren... 5 Elemente in alle möglichen Reihenfolgen anzuordnen, liefert 5*4*3*2 (also 5! ) Möglichkeiten... nun haben wir in diesem Fall aber 3 gleiche Faktoren (die 2en) und auch von den 5en haben wir 2 gleiche... also dividieren wir noch durch die Anzahl der Möglichkeiten, die 2en untereinander zu tauschen... genauso mit den 5en... ergibt insgesamt

5*4*3*2 / (3*2) * (2) = 5*4 / 2 = 5*2 = 10

Es gibt also 10 verschiedene Multiplikationsbäume (mit Primzahlen in den Blättern), die in der Wurzel 200 zu stehen haben...

Dein Programm muss also allgemein für eine gegebene Zahl n alle Primfaktoren und deren Häufigkeiten finden.

n = p_1 ^(h_1) * p_2^(h_2) * ... * p_k^(h_k)

wobei die p's jetzt Primzahlen und die h's deren Häufigkeiten sind. Aus den Häufigkeiten rechnet man nun genauso wie im obigen Beispiel aus, wieviele Möglichkeiten es gibt, die Primfaktoren anzuordnen:

(h_1 + ... + h_k)!  / (h_1! * h_2! * ... * h_k! )

fertig.

Verstehst du, was ich meine? 

Was du also brauchst, sind alle Primzahlen <= Wurzel(n)   ( z.B. über die Methode des Siebs von Eratosthenes )
und dann könntest du für jede Primzahl überprüfen, ob und wie oft man die Zahl n dadurch teilen kann.

Sieb des Eratosthenes ? Wikipedia

Wenn man nicht nur Primzahlen in der Wurzel stehen haben möchte, muss man auch noch berücksichtigen, auf wieviele Arten man Primfaktoren zusammenfassen kann in den Blättern ^^


----------



## SlaterB (29. Jan 2010)

da fährst du ja schwere mathematische Geschütze auf 

unabhängig davon finde ich das Ausprobieren und Optimieren daran weiter hochinteressant,
mit Spitze/2 hilft aber fast alles nichts, schon eine Schleife bis 70 Mil. ist zu lang,

man könnte als Obergrenze für die Schleifen Wurzel(Spitze) nehmen, 376.195, 
schon deutlich übersichtlicher,

nur fehlen dann eine Menge Kombinationen, z.B. 2 * (Spitze/2), falls es gerade hinkommt,
allerdings bestehen all die fehlenden Kombinationen mit einem Faktor > Wurzel(Spitze) aus nur zwei Faktoren,
daher kann man diese durch eine einzelne separate Schleife bestimmen

hier das Programm soweit, Fehler nicht ausgeschlossen, 
Mathematik wie von moormaster evtl. doch leichter 



```
public class Test
{
    public static void main(String[] args)
    {

        long time = System.currentTimeMillis();
        long countTotal = 0;
        int n = 0;

        long spitze = 141523200000L;
        long wurzel = (long)(Math.sqrt(spitze));
        long spitzeP1 = spitze + 1;
        System.out.println("spitze: " + spitze);
        System.out.println("wurzel: " + wurzel);


        for (long i = 2; i <= wurzel; i++)
        {
            long k = spitze / i;
            if (k * i == spitze)
            {
                System.out.println(i + ", 1, 1, 1, 1, " + k);
                n++;
                if (i != k)
                {
                    System.out.println(k + ", 1, 1, 1, 1, " + i);
                    n++;
                }
            }
        }


        for (long c = 1; c <= 13; c++)
        {
            double xc = 1.0 * c * c * c * c * c * c * c * c * c * c;
            for (long d = 1; d <= 13; d++)
            {
                double xd = xc * d * d * d * d * d * d * d * d * d * d;
                if (xd > spitzeP1)
                {
                    break;
                }
                for (long b = 1; b <= 169; b++)
                {
                    double xb = xd * b * b * b * b * b;
                    if (xb > spitzeP1)
                    {
                        break;
                    }
                    for (long e = 1; e <= 169; e++)
                    {
                        if (c == 1 && d == 1 && b == 1 && e == 1)
                        {
                            // alles 1 uninteressant, das macht schon die for-i-Schleife
                            // am Anfang
                            break;
                        }
                        double xe = xb * e * e * e * e;
                        if (xe > spitzeP1)
                        {
                            break;
                        }
                        for (long a = 1; a <= wurzel; a++)
                        {
                            double xa = xe * a;
                            if (xa > spitzeP1)
                            {
                                break;
                            }
                            double minf = spitze / xa; // wenn alles bis auf f schon feststeht und < 140 ist,
                            // dann braucht man mit f < 1 Mill. gar nicht erst anfangen 
                            // um als Produkt 140 Mill. erreichen

                            for (long f = (long)(minf - 3); f <= wurzel; f++)
                            {
                                double xf = xa * f;
                                if (xf > spitzeP1)
                                {
                                    break;
                                }

                                // Püfen ob Zahl schon erreicht ist
                                if ((a * b * b * b * b * b * 
                                    c * c * c * c * c * c * c * c * c * c * 
                                    d * d * d * d * d * d * d * d * d * d * 
                                    e * e * e * e * e * f) == spitze)
                                {
                                    System.out.println(a + ", " + b + ", " + c + ", " + 
                                                       d + ", " + e + ", " + f);
                                    n = n + 1;
                                }
                            }
                        }
                    }
                }
            }
        }

        System.out.println("Anzahl = " + n + ", Zeit: " + (System.currentTimeMillis() - time));
    }
}
```


3637 Kombinationen in 12 sec berechnet


----------



## function (29. Jan 2010)

also die idee von moormaster ist ja schon ganz nett, aber ich glaube dabei tauchen nun auch anderen probleme auf. Hier geht es ja schon um eine ziemlich große Wurzel ~150milliarden, und mit dem sieb speichert man ja die primzahlen mit sicherheit zu speichproblemen führen wird, wenn man nur alle primzahlen bis 1milliarde speichert sind das schon ~51mio zahlen, bis 150milliarden kommen da noch einige zu...


----------



## SlaterB (29. Jan 2010)

der Wert selber ist 150 Mill., die Faktoren sind maximal die Wurzel, also 400.000,
und speichern muss man doch eher nur die tatsächlichen Faktoren, ne Handvoll


----------



## function (29. Jan 2010)

joa aber worstcase, nur im hinblick auf die primfaktor zerlegung, es existieren nur 2 primfaktoren {2, ~75mill} um das überhaupt erst festzustellen muss man wenigstens alle primzahlen von 37,5mill zwischenspeichern.


**EDIT**
ach sry, hatte grad ein brett vorm kopf bzw war beim falschen algo, das sieb läuft ja max bis i^2<n... dann ist es doch praktikabel
**/EDIT**


----------



## SlaterB (29. Jan 2010)

hmm nein,
man schaut sich alle Zahlen zwischen 2 und 400.000 an,
wenn nur die 2 ein Teiler ist, dann weiß man dass 75 Mill. auch einer ist

bzw. anders, ich weiß jetzt gar nicht wie das Sieb es macht oder wovon immer wir sprachen,
Anfangen mit 150 Mill., suchen bis 400.000,
bei der 2 schon fündig -> 2 merken,
mit Rest 75 Mill. neu anfangen, bis 300.000 suchen, nix gefunden? -> dann ist 75 Mill. prim, also insgesamt 2 und 75 Mill.,
sonst weitere Faktoren herausnehmen und Rest immer kleiner machen, sowie von vorne anfangen

so denke ich mir das gerade/ erinnere ich, gibt vielleicht verschiedene Verfahren


----------



## Anfänger123 (29. Jan 2010)

```
public class PrimfaktorZerlegung {

    static void teilen (long zahl) {
        long i;
        long max;
        max = (long) Math.round(Math.sqrt((double) zahl));

        if (zahl <= 1) {
      return;
    }

        if (zahl%2 == 0) {
            System.out.print("2*");
            teilen(zahl/2);
            return;
        }

        for (i=3; i<=max; i=i+2) {

            if (zahl%i == 0) {
                teilen(i);
                teilen(zahl/i);

                return;
            }
        }
        System.out.print(zahl + "*");

    }

    //*******************************************************************************
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        long zahl = 141523200000L;

        System.out.println("Primfaktorzerlegung\n\nDie zu zerlegende Zahl lautet: " + zahl);
        System.out.println("");
        teilen(zahl);

    }

}
```

Man muss das Rad ja nicht neu erfinden 

@moormaster: Deine Idee habe ich auch schon überlegt und z.T. in die Lösung darüber eingebunden.


----------



## Anfänger123 (29. Jan 2010)

Wie kann ich schreiben, dass einmal für e=1, 2, 3, 5, 13 eingesetzt wird ? Noch eine Frage: Wie schreibt man 5. Wurzel ? (Lässt sich auch als x^(1/5) darstellen)


----------



## Anfänger123 (29. Jan 2010)

und gleich noch Potenzen ?


----------



## SlaterB (29. Jan 2010)

Math.pow, 
^5 = ^5 
^0.2 = 5. Wurzel

e beim Ursprungsprogramm?
lege dir ein int[] an und durchlaufe das von Anfang bis Ende


----------



## Anfänger123 (30. Jan 2010)

Danke schonmal! Wie baut man das int [] genau ein ?


----------



## SlaterB (30. Jan 2010)

na korrekt? welche Schritte sind dir nicht bekannt, die Definition oder das Durchlaufen in einer Schleife?
Galileo Computing :: Java ist auch eine Insel (8. Auflage) – 3.10 Arrays


----------



## Anfänger123 (30. Jan 2010)

beim Durchlaufen der SChleife, aber ich bin grad dabei es auszuprobieren


----------



## Anfänger123 (30. Jan 2010)

eingebaut ist es, aber wie krieg ich ihn dazu, int mit int [] zu vergleichen ?


----------



## Anfänger123 (30. Jan 2010)

Ok ich habs geschafft, aber der Fehler ist int[] mit int zu vergleichen. z.b. bei if(faktor_c == 2) und faktor_c [] = {1,2,3,5} bsp.


----------



## SlaterB (30. Jan 2010)

wie sieht denn die Schleife aus?


----------



## Anfänger123 (30. Jan 2010)

Bei mir sieht's jetzt so aus: Problem maxa und maxb werden gar nicht ausgerechnet ???:L


```
class Rechner2 {
  int n = 0;
  long Spitze = 50L;
  long HaelfteSpitze = Spitze / 2;
  double maxa;
  double maxb;

  public Rechner2() {
    //Probieren bis es klappt
    for (int faktor_c = 1; faktor_c <= 2; faktor_c++) {
      //faktor_c ist entweder 1 oder 2
      if (faktor_c == 2) { //gleich weiter springen zu faktor_b, da entweder c oder d die 2 haben können  oder gar keiner von beiden

        int faktor_d = 1; //faktor_d ist entweder 1 oder 2, aber c und d sind nie gleichzeitig 2. Wenn c 2 ist, ist also d 1

        int[] faktor_b = { 1, 3, 5 };

        for (int i = 0; i <= faktor_b.length; i++) {
          if (faktor_b.length == 3) {
            int[] faktor_e = { 1, 5 };

            for (int e = 0; e <= faktor_e.length; e++) {
              double maxa = Spitze / (Math.pow(faktor_b.length, 5) * Math.pow(faktor_c,
                                                                              10) * Math.pow(faktor_d,
                                                                                             10) * Math.pow(faktor_e.length,
                                                                                                            5));

              for (int faktor_a = 1; faktor_a <= maxa; faktor_a++) {
                double maxb = Spitze / (faktor_a * Math.pow(faktor_b.length, 5) * Math.pow(faktor_c,
                                                                                           10) * Math.pow(faktor_d,
                                                                                                          10) * Math.pow(faktor_e.length,
                                                                                                                         5));

                for (int faktor_f = 1; faktor_f <= maxb; faktor_f++) {
                  if ((faktor_a * Math.pow(faktor_b.length, 5) * Math.pow(faktor_c,
                                                                            10) * Math.pow(faktor_d,
                                                                                             10) * Math.pow(faktor_e.length,
                                                                                                              5) * faktor_f) == Spitze) {
                    if (faktor_a == 1) {
                    } else {
                      System.out.println("a = " + faktor_a);
                    }

                    if (faktor_b.length == 1) {
                    } else {
                      System.out.println("b = " + faktor_b.length);
                    }

                    if (faktor_c == 1) {
                    } else {
                      System.out.println("c = " + faktor_c);
                    }

                    if (faktor_d == 1) {
                    } else {
                      System.out.println("d = " + faktor_d);
                    }

                    if (faktor_e.length == 1) {
                    } else {
                      System.out.println("e = " + faktor_e.length);
                    }

                    if (faktor_f == 1) {
                    } else {
                      System.out.println("f = " + faktor_f);
                    }

                    System.out.println();
                    n = n + 1;
                  }
                }
              }
            }
          }

          if (faktor_b.length == 5) {
            int[] faktor_e = { 1, 3 };

            for (int e = 0; e <= faktor_e.length; e++) {
              double maxa = Spitze / (Math.pow(faktor_b.length, 5) * Math.pow(faktor_c,
                                                                              10) * Math.pow(faktor_d,
                                                                                             10) * Math.pow(faktor_e.length,
                                                                                                            5));

              for (int faktor_a = 1; faktor_a <= maxa; faktor_a++) {
                double maxb = Spitze / (faktor_a * Math.pow(faktor_b.length, 5) * Math.pow(faktor_c,
                                                                                           10) * Math.pow(faktor_d,
                                                                                                          10) * Math.pow(faktor_e.length,
                                                                                                                         5));

                for (int faktor_f = 1; faktor_f <= maxb; faktor_f++) {
                  if ((faktor_a * Math.pow(faktor_b.length, 5) * Math.pow(faktor_c,
                                                                            10) * Math.pow(faktor_d,
                                                                                             10) * Math.pow(faktor_e.length,
                                                                                                              5) * faktor_f) == Spitze) {
                    if (faktor_a == 1) {
                    } else {
                      System.out.println("a = " + faktor_a);
                    }

                    if (faktor_b.length == 1) {
                    } else {
                      System.out.println("b = " + faktor_b.length);
                    }

                    if (faktor_c == 1) {
                    } else {
                      System.out.println("c = " + faktor_c);
                    }

                    if (faktor_d == 1) {
                    } else {
                      System.out.println("d = " + faktor_d);
                    }

                    if (faktor_e.length == 1) {
                    } else {
                      System.out.println("e = " + faktor_e.length);
                    }

                    if (faktor_f == 1) {
                    } else {
                      System.out.println("f = " + faktor_f);
                    }

                    System.out.println();
                    n = n + 1;
                  }
                }
              }
            }
          }

          int[] faktor_e = { 1, 3, 5 };

          for (int f = 0; f <= faktor_b.length; f++) {
            double maxa = Spitze / (Math.pow(faktor_b.length, 5) * Math.pow(faktor_c,
                                                                            10) * Math.pow(faktor_d,
                                                                                           10) * Math.pow(faktor_e.length,
                                                                                                          5));

            for (int faktor_a = 1; faktor_a <= maxa; faktor_a++) {
              double maxb = Spitze / (faktor_a * Math.pow(faktor_b.length, 5) * Math.pow(faktor_c,
                                                                                         10) * Math.pow(faktor_d,
                                                                                                        10) * Math.pow(faktor_e.length,
                                                                                                                       5));

              for (int faktor_f = 1; faktor_f <= maxb; faktor_f++) {
                if ((faktor_a * Math.pow(faktor_b.length, 5) * Math.pow(faktor_c,
                                                                          10) * Math.pow(faktor_d,
                                                                                           10) * Math.pow(faktor_e.length,
                                                                                                            5) * faktor_f) == Spitze) {
                  if (faktor_a == 1) {
                  } else {
                    System.out.println("a = " + faktor_a);
                  }

                  if (faktor_b.length == 1) {
                  } else {
                    System.out.println("b = " + faktor_b.length);
                  }

                  if (faktor_c == 1) {
                  } else {
                    System.out.println("c = " + faktor_c);
                  }

                  if (faktor_d == 1) {
                  } else {
                    System.out.println("d = " + faktor_d);
                  }

                  if (faktor_e.length == 1) {
                  } else {
                    System.out.println("e = " + faktor_e.length);
                  }

                  if (faktor_f == 1) {
                  } else {
                    System.out.println("f = " + faktor_f);
                  }

                  System.out.println();
                  n = n + 1;
                }
              }
            }
          }
        }
      }

      if (faktor_c == 1) {
        //faktor_d ist entweder 1 oder 2
        for (int faktor_d = 1; faktor_d <= 2; faktor_d++) {
          int[] faktor_b = { 1, 2, 3, 5 };

          for (int i = 0; i <= faktor_b.length; i++) {
            if (faktor_b.length == 3) {
              int[] faktor_e = { 1, 2, 5 };

              for (int e = 0; e <= faktor_b.length; e++) {
                double maxa = Spitze / (Math.pow(faktor_b.length, 5) * Math.pow(faktor_c,
                                                                                10) * Math.pow(faktor_d,
                                                                                               10) * Math.pow(faktor_e.length,
                                                                                                              5));

                for (int faktor_a = 1; faktor_a <= maxa; faktor_a++) {
                  double maxb = Spitze / (faktor_a * Math.pow(faktor_b.length, 5) * Math.pow(faktor_c,
                                                                                             10) * Math.pow(faktor_d,
                                                                                                            10) * Math.pow(faktor_e.length,
                                                                                                                           5));

                  for (int faktor_f = 1; faktor_f <= maxb; faktor_f++) {
                    if ((faktor_a * Math.pow(faktor_b.length, 5) * Math.pow(faktor_c,
                                                                              10) * Math.pow(faktor_d,
                                                                                               10) * Math.pow(faktor_e.length,
                                                                                                                5) * faktor_f) == Spitze) {
                      if (faktor_a == 1) {
                      } else {
                        System.out.println("a = " + faktor_a);
                      }

                      if (faktor_b.length == 1) {
                      } else {
                        System.out.println("b = " + faktor_b.length);
                      }

                      if (faktor_c == 1) {
                      } else {
                        System.out.println("c = " + faktor_c);
                      }

                      if (faktor_d == 1) {
                      } else {
                        System.out.println("d = " + faktor_d);
                      }

                      if (faktor_e.length == 1) {
                      } else {
                        System.out.println("e = " + faktor_e.length);
                      }

                      if (faktor_f == 1) {
                      } else {
                        System.out.println("f = " + faktor_f);
                      }

                      System.out.println();
                      n = n + 1;
                    }
                  }
                }
              }
            }

            if (faktor_b.length == 5) {
              int[] faktor_e = { 1, 2, 3 };

              for (int e = 0; e <= faktor_b.length; e++) {
                double maxa = Spitze / (Math.pow(faktor_b.length, 5) * Math.pow(faktor_c,
                                                                                10) * Math.pow(faktor_d,
                                                                                               10) * Math.pow(faktor_e.length,
                                                                                                              5));

                for (int faktor_a = 1; faktor_a <= maxa; faktor_a++) {
                  double maxb = Spitze / (faktor_a * Math.pow(faktor_b.length, 5) * Math.pow(faktor_c,
                                                                                             10) * Math.pow(faktor_d,
                                                                                                            10) * Math.pow(faktor_e.length,
                                                                                                                           5));

                  for (int faktor_f = 1; faktor_f <= maxb; faktor_f++) {
                    if ((faktor_a * Math.pow(faktor_b.length, 5) * Math.pow(faktor_c,
                                                                              10) * Math.pow(faktor_d,
                                                                                               10) * Math.pow(faktor_e.length,
                                                                                                                5) * faktor_f) == Spitze) {
                      if (faktor_a == 1) {
                      } else {
                        System.out.println("a = " + faktor_a);
                      }

                      if (faktor_b.length == 1) {
                      } else {
                        System.out.println("b = " + faktor_b.length);
                      }

                      if (faktor_c == 1) {
                      } else {
                        System.out.println("c = " + faktor_c);
                      }

                      if (faktor_d == 1) {
                      } else {
                        System.out.println("d = " + faktor_d);
                      }

                      if (faktor_e.length == 1) {
                      } else {
                        System.out.println("e = " + faktor_e.length);
                      }

                      if (faktor_f == 1) {
                      } else {
                        System.out.println("f = " + faktor_f);
                      }

                      System.out.println();
                      n = n + 1;
                    }
                  }
                }
              }
            }

            int[] faktor_e = { 1, 2, 3, 5 };

            for (int e = 0; e <= faktor_b.length; e++) {
              double maxa = Spitze / (Math.pow(faktor_b.length, 5) * Math.pow(faktor_c,
                                                                              10) * Math.pow(faktor_d,
                                                                                             10) * Math.pow(faktor_e.length,
                                                                                                            5));

              for (int faktor_a = 1; faktor_a <= maxa; faktor_a++) {
                double maxb = Spitze / (faktor_a * Math.pow(faktor_b.length, 5) * Math.pow(faktor_c,
                                                                                           10) * Math.pow(faktor_d,
                                                                                                          10) * Math.pow(faktor_e.length,
                                                                                                                         5));

                for (int faktor_f = 1; faktor_f <= maxb; faktor_f++) {
                  if ((faktor_a * Math.pow(faktor_b.length, 5) * Math.pow(faktor_c,
                                                                            10) * Math.pow(faktor_d,
                                                                                             10) * Math.pow(faktor_e.length,
                                                                                                              5) * faktor_f) == Spitze) {
                    if (faktor_a == 1) {
                    } else {
                      System.out.println("a = " + faktor_a);
                    }

                    if (faktor_b.length == 1) {
                    } else {
                      System.out.println("b = " + faktor_b.length);
                    }

                    if (faktor_c == 1) {
                    } else {
                      System.out.println("c = " + faktor_c);
                    }

                    if (faktor_d == 1) {
                    } else {
                      System.out.println("d = " + faktor_d);
                    }

                    if (faktor_e.length == 1) {
                    } else {
                      System.out.println("e = " + faktor_e.length);
                    }

                    if (faktor_f == 1) {
                    } else {
                      System.out.println("f = " + faktor_f);
                    }

                    System.out.println();
                    n = n + 1;
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  public static void main(String[] args) {
    Rechner2 r;
    r = new Rechner2();
  }
}
```


----------



## SlaterB (30. Jan 2010)

man oh meter, irrsinnig sinnlos ewig langer komplizierter Code, 
aber allein dass du das du das alles eingetippt oder zurecktkopiert hast, ist ja schon eine Fleiß-Leistung,

ich jedenfalls würde nie mehr als einmal pro Bildschirmseite  Math.pow(irgendwas, 10) schreiben,
wenn ich allein schon
>  Math.pow(faktor_c, 10) * Math.pow(faktor_d,10) * Math.pow(faktor_e.length,5) 
sehe, dann brauch ich gar nicht denken, dann würde ich ganz von selber Hilfsmethoden h10(), h5() schreiben,
ergo im Hauptcode nur noch
>  h10(faktor_c) * h10(faktor_d) * h5(faktor_e) 
usw., 

faktor_c usw. ist auch sehr unhandlich lange, schau dir mein lauffähige Programm an, da schrieb ich nur c,
und c * c * c * c * c * c * c * c * c * c stand da fast nur einmal, ein zweites mal nur wegen double/ long-Rechnung

na, jeder muss selber lernen wo es hinführt,
aber einer der wichtigsten Tipps überhaupt lautet: nichts doppelt schreiben,
wenn du in Zeile 23 
>  double maxa = Spitze / (Math.pow(faktor_b.length, 5) * ...
stehen hast und Zeile 81 auf einmal wieder mit
> double maxa = Spitze / (Math.pow(faktor_b.length, 5) *
beginnt, dann ist irgendwas komplett falsch, ganz egal um welches Programm auf der Welt es geht 

--------

aber zu deiner Frage zu dem Arrays:
offensichtlich hast du meinen Link zu Grundlagen zu Arrays komplett ignoriert, du weißt überhaupt nichts darüber,
seltsame Art dann damit zu programmieren

ein Array int[] x = {0,1,2] enthält drei Elemente, mit Index i von 0 bis 2 kann man dann auf x_, auf die Array-Element zugreifen
Array.length ist wichtig sowie der Zugriff auf die Elemente, denkbar einfach aber in deinem Programm findet kein einziger Zugriff statt,

380 Zeilen ohne das irgendwas funktioniert
das erinnert mich an einen anderen ganz grundlegenden Tipp: klein anfangen, ganz ganz klein klein klein und noch viel kleiner,

definiere dir erstmal ein Array mit drei Elementen und gib diese aus, ein 5 Zeilen-Programm welches zumindest funktionieren würde 

-----

noch zu deinem Code
> if (faktor_b.length == 3) {

faktor_b ist immer gleich lang, immer dasselbe Array, wahrscheinlich meinst du das aktuelle Element, das erfordert wie gesagt den Zugriff auf den Array-Inhalt, die Länge hat nichts damit zu tun


--------

edit:


		Java:In die Zwischenablage kopieren


 if (faktor_a == 1) {
                    } else {
                      System.out.println("a = " + faktor_a);
                    }
 
                    if (faktor_b.length == 1) {
                    } else {
                      System.out.println("b = " + faktor_b.length);
                    }
 
                    if (faktor_c == 1) {
                    } else {
                      System.out.println("c = " + faktor_c);
                    }
 
                    if (faktor_d == 1) {
                    } else {
                      System.out.println("d = " + faktor_d);
                    }
 
                    if (faktor_e.length == 1) {
                    } else {
                      System.out.println("e = " + faktor_e.length);
                    }
 
                    if (faktor_f == 1) {
                    } else {
                      System.out.println("f = " + faktor_f);
                    }

ist auch ein verrückt unnötiger Code, besonders wenn mehrfach im Programm,
könnte man für sich vereinfachen oder in eine Untermethode auslagern und mehrfach aufrufen,

oder aber gleich viel einfacher und sauberer in einer Zeile ausgeben:


		Java:In die Zwischenablage kopieren


 System.out.println(a + ", " + b + ", " + c + ", " + d + ", " + e + ", " + f);

(vergleichsweise) kurz, schmerzlos, gut_


----------



## Anfänger123 (30. Jan 2010)

ok, dann mal an's auslagern:

Ich muss doch zum Beispiel dann eine Methode erstellen, die Ausgeben heißt, oder nicht?


```
public Ausgeben (Kommt hier was rein und wenn ja was? int faktor_a, int faktor_b... ??) {
if (faktor_a == 1) {
                    } else {
                      System.out.println("a = " + faktor_a);
                    }

                    if (faktor_b.length == 1) {
                    } else {
                      System.out.println("b = " + faktor_b.length);
                    }

                    if (faktor_c == 1) {
                    } else {
                      System.out.println("c = " + faktor_c);
                    }

                    if (faktor_d == 1) {
                    } else {
                      System.out.println("d = " + faktor_d);
                    }

                    if (faktor_e.length == 1) {
                    } else {
                      System.out.println("e = " + faktor_e.length);
                    }

                    if (faktor_f == 1) {
                    } else {
                      System.out.println("f = " + faktor_f);
                    }
```


----------



## Anfänger123 (30. Jan 2010)

Normal wollt ich das auch (noch) nicht machen, brauche das aber wie gesagt für eine MatheAufgabe


----------



## SlaterB (30. Jan 2010)

auch wie man Methoden definiert, mit Parametern, wie man sie aufruft, steht in Büchern, dazu Beispielprogramme,
noch mehr möchte ich nicht einzeln erklären,
Galileo Computing :: Java ist auch eine Insel (8. Auflage) – 6 Eigene Klassen schreiben

meine Kritik auch nicht als zu dramatisch sehen, ist sicher normal am Anfang


----------



## Anfänger123 (30. Jan 2010)

In den Sommerferien probier ich's nochmal und dann werd ich mich nicht mehr mit Anfänger123 anmelden


----------



## Anfänger123 (31. Jan 2010)

Geschafft! Am Auslagern bin ich schon dabei, nur kann ich die Methode leider nicht aufrufen, da schau ich nochmal. Funktionieren tut es auf jeden Fall!


```
class Rechner2 {
  int n = 0;
  long Spitze = 141523200000L;
  long HaelfteSpitze = Spitze / 2;
  double maxa;
  double maxb;

  public Rechner2() {
    //Probieren bis es klappt
    for (int faktor_c = 1; faktor_c <= 2; faktor_c++) {
      //faktor_c ist entweder 1 oder 2
      if (faktor_c == 2) { //gleich weiter springen zu faktor_b, da entweder c oder d die 2 haben können  oder gar keiner von beiden

        int faktor_d = 1; //faktor_d ist entweder 1 oder 2, aber c und d sind nie gleichzeitig 2. Wenn c 2 ist, ist also d 1

        int[] faktor_b = { 1, 3, 5 };

        for (int b = 0; b <= faktor_b.length; b++) {
          if (faktor_b[b] == 3) {
            int[] faktor_e = { 1, 5 };

            for (int e = 0; e <= faktor_e.length; e++) {
              double maxa = Spitze / (Math.pow(faktor_b[b], 5) * Math.pow(faktor_c,
                                                                          10) * Math.pow(faktor_d,
                                                                                         10) * Math.pow(faktor_e[e],
                                                                                                        5));

              for (long faktor_a = 1; faktor_a <= maxa; faktor_a++) {
                double maxb = maxa * faktor_a;

                if (((faktor_a % 2) == 0) && ((faktor_a % 7) == 0) &&
                      ((faktor_a % 3) == 0) && ((faktor_a % 5) == 0)) {
                  for (long faktor_f = 1; faktor_f <= maxb; faktor_f++) {
                    if ((faktor_f * maxb) == Spitze) {
                      if (faktor_a == 1) {
                      } else {
                        System.out.println("a = " + faktor_a);
                      }

                      if (faktor_b[b] == 1) {
                      } else {
                        System.out.println("b = " + faktor_b[b]);
                      }

                      if (faktor_c == 1) {
                      } else {
                        System.out.println("c = " + faktor_c);
                      }

                      if (faktor_d == 1) {
                      } else {
                        System.out.println("d = " + faktor_d);
                      }

                      if (faktor_e.length == 1) {
                      } else {
                        System.out.println("e = " + faktor_e[e]);
                      }

                      if (faktor_f == 1) {
                      } else {
                        System.out.println("f = " + faktor_f);
                      }

                      System.out.println();
                      n = n + 1;
                    }
                  }
                }
              }
            }
          }

          if (faktor_b[b] == 5) {
            int[] faktor_e = { 1, 3 };

            for (int e = 0; e <= faktor_e.length; e++) {
              double maxa = Spitze / (Math.pow(faktor_b[b], 5) * Math.pow(faktor_c,
                                                                          10) * Math.pow(faktor_d,
                                                                                         10) * Math.pow(faktor_e[e],
                                                                                                        5));

              for (long faktor_a = 1; faktor_a <= maxa; faktor_a++) {
                double maxb = maxa * faktor_a;

                if (((faktor_a % 2) == 0) && ((faktor_a % 7) == 0) &&
                      ((faktor_a % 3) == 0) && ((faktor_a % 5) == 0)) {
                  for (int faktor_f = 1; faktor_f <= maxb; faktor_f++) {
                    if ((faktor_f * maxb) == Spitze) {
                      if (faktor_a == 1) {
                      } else {
                        System.out.println("a = " + faktor_a);
                      }

                      if (faktor_b[b] == 1) {
                      } else {
                        System.out.println("b = " + faktor_b[b]);
                      }

                      if (faktor_c == 1) {
                      } else {
                        System.out.println("c = " + faktor_c);
                      }

                      if (faktor_d == 1) {
                      } else {
                        System.out.println("d = " + faktor_d);
                      }

                      if (faktor_e.length == 1) {
                      } else {
                        System.out.println("e = " + faktor_e[e]);
                      }

                      if (faktor_f == 1) {
                      } else {
                        System.out.println("f = " + faktor_f);
                      }

                      System.out.println();
                      n = n + 1;
                    }
                  }
                }
              }
            }
          }

          int[] faktor_e = { 1, 3, 5 };

          for (int e = 0; e <= faktor_e.length; e++) {
            double maxa = Spitze / (Math.pow(faktor_b[b], 5) * Math.pow(faktor_c,
                                                                        10) * Math.pow(faktor_d,
                                                                                       10) * Math.pow(faktor_e[e],
                                                                                                      5));

            for (long faktor_a = 1; faktor_a <= maxa; faktor_a++) {
              double maxb = maxa * faktor_a;

              if (((faktor_a % 2) == 0) && ((faktor_a % 7) == 0) &&
                    ((faktor_a % 3) == 0) && ((faktor_a % 5) == 0)) {
                for (long faktor_f = 1; faktor_f <= maxb; faktor_f++) {
                  if ((faktor_f * maxb) == Spitze) {
                    if (faktor_a == 1) {
                    } else {
                      System.out.println("a = " + faktor_a);
                    }

                    if (faktor_b[b] == 1) {
                    } else {
                      System.out.println("b = " + faktor_b[b]);
                    }

                    if (faktor_c == 1) {
                    } else {
                      System.out.println("c = " + faktor_c);
                    }

                    if (faktor_d == 1) {
                    } else {
                      System.out.println("d = " + faktor_d);
                    }

                    if (faktor_e.length == 1) {
                    } else {
                      System.out.println("e = " + faktor_e[e]);
                    }

                    if (faktor_f == 1) {
                    } else {
                      System.out.println("f = " + faktor_f);
                    }

                    System.out.println();
                    n = n + 1;
                  }
                }
              }
            }
          }
        }
      }

      if (faktor_c == 1) {
        //faktor_d ist entweder 1 oder 2
        for (int faktor_d = 1; faktor_d <= 2; faktor_d++) {
          int[] faktor_b = { 1, 2, 3, 4, 5 };

          for (int b = 0; b <= faktor_b.length; b++) {
            if (faktor_b[b] == 3) {
              int[] faktor_e = { 1, 2, 4, 5 };

              for (int e = 0; e <= faktor_e.length; e++) {
                double maxa = Spitze / (Math.pow(faktor_b[b], 5) * Math.pow(faktor_c,
                                                                            10) * Math.pow(faktor_d,
                                                                                           10) * Math.pow(faktor_e[e],
                                                                                                          5));

                for (long faktor_a = 1; faktor_a <= maxa; faktor_a++) {
                  double maxb = maxa * faktor_a;

                  if (((faktor_a % 2) == 0) && ((faktor_a % 7) == 0) &&
                        ((faktor_a % 3) == 0) && ((faktor_a % 5) == 0)) {
                    for (long faktor_f = 1; faktor_f <= maxb; faktor_f++) {
                      if ((faktor_f * maxb) == Spitze) {
                        if (faktor_a == 1) {
                        } else {
                          System.out.println("a = " + faktor_a);
                        }

                        if (faktor_b[b] == 1) {
                        } else {
                          System.out.println("b = " + faktor_b[b]);
                        }

                        if (faktor_c == 1) {
                        } else {
                          System.out.println("c = " + faktor_c);
                        }

                        if (faktor_d == 1) {
                        } else {
                          System.out.println("d = " + faktor_d);
                        }

                        if (faktor_e.length == 1) {
                        } else {
                          System.out.println("e = " + faktor_e[e]);
                        }

                        if (faktor_f == 1) {
                        } else {
                          System.out.println("f = " + faktor_f);
                        }

                        System.out.println();
                        n = n + 1;
                      }
                    }
                  }
                }
              }
            }

            if (faktor_b[b] == 5) {
              int[] faktor_e = { 1, 2, 3, 4 };

              for (int e = 0; e <= faktor_e.length; e++) {
                double maxa = Spitze / (Math.pow(faktor_b[b], 5) * Math.pow(faktor_c,
                                                                            10) * Math.pow(faktor_d,
                                                                                           10) * Math.pow(faktor_e[e],
                                                                                                          5));

                for (long faktor_a = 1; faktor_a <= maxa; faktor_a++) {
                  double maxb = maxa * faktor_a;

                  if (((faktor_a % 2) == 0) && ((faktor_a % 7) == 0) &&
                        ((faktor_a % 3) == 0) && ((faktor_a % 5) == 0)) {
                    for (long faktor_f = 1; faktor_f <= maxb; faktor_f++) {
                      if ((faktor_f * maxb) == Spitze) {
                        if (faktor_a == 1) {
                        } else {
                          System.out.println("a = " + faktor_a);
                        }

                        if (faktor_b[b] == 1) {
                        } else {
                          System.out.println("b = " + faktor_b[b]);
                        }

                        if (faktor_c == 1) {
                        } else {
                          System.out.println("c = " + faktor_c);
                        }

                        if (faktor_d == 1) {
                        } else {
                          System.out.println("d = " + faktor_d);
                        }

                        if (faktor_e.length == 1) {
                        } else {
                          System.out.println("e = " + faktor_e[e]);
                        }

                        if (faktor_f == 1) {
                        } else {
                          System.out.println("f = " + faktor_f);
                        }

                        System.out.println();
                        n = n + 1;
                      }
                    }
                  }
                }
              }
            }

            int[] faktor_e = { 1, 2, 3, 4, 5 };

            for (int e = 0; e <= faktor_e.length; e++) {
              System.out.print(faktor_e[e]);

              double maxa = Spitze / (Math.pow(faktor_b[b], 5) * Math.pow(faktor_c,
                                                                          10) * Math.pow(faktor_d,
                                                                                         10) * Math.pow(faktor_e[e],
                                                                                                        5));

              for (long faktor_a = 1; faktor_a <= maxa; faktor_a++) {
                double maxb = maxa * faktor_a;

                if (((faktor_a % 2) == 0) && ((faktor_a % 7) == 0) &&
                      ((faktor_a % 3) == 0) && ((faktor_a % 5) == 0)) {
                  for (long faktor_f = 1; faktor_f <= maxb; faktor_f++) {
                    if ((faktor_a * Math.pow(faktor_b[b], 5) * Math.pow(faktor_c,
                                                                          10) * Math.pow(faktor_d,
                                                                                           10) * Math.pow(faktor_e[e],
                                                                                                            5) * faktor_f) == Spitze) {
                      if (faktor_a == 1) {
                      } else {
                        System.out.println("a = " + faktor_a);
                      }

                      if (faktor_b[b] == 1) {
                      } else {
                        System.out.println("b = " + faktor_b[b]);
                      }

                      if (faktor_c == 1) {
                      } else {
                        System.out.println("c = " + faktor_c);
                      }

                      if (faktor_d == 1) {
                      } else {
                        System.out.println("d = " + faktor_d);
                      }

                      if (faktor_e.length == 1) {
                      } else {
                        System.out.println("e = " + faktor_e[e]);
                      }

                      if (faktor_f == 1) {
                      } else {
                        System.out.println("f = " + faktor_f);
                      }

                      System.out.println();
                      n = n + 1;
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  public static void main(String[] args) {
    Rechner2 r;
    r = new Rechner2();
  }
}
```


----------

