# Primfaktorzerlegung für alle Zahlen eines Intervalls



## XRayT1Raycer (15. Nov 2008)

Hallo!
Ich habe ein kleines Problem mit folgender Aufgabe:

Schreiben Sie ein Java-Programm, das zwei Zahlen vom Typ int als untere und obere Grenzen eines
Intervalls einliest und fuer alle Zahlen dieses Intervalls eine Primfaktorzerlegung durchfuehrt.

Beispielausgabe fuer das Intervall [31; 34]:
31 = 31
32 = 2 * 2 * 2 * 2 * 2
33 = 3 * 11
34 = 2 * 17

Den Algorithmus für die Primfaktorzerlegung habe ich am laufen, allerdings macht er die Zerlegung immer nur für die erste Zahl des Intervalls...... Auch die Ausgabe der "*" will nicht so richtig
Ist vermutlich keine große Sache, aber momentan stehe ich wirklich auf dem Schlauch....
Vielen Dank im Voraus für eure Hilfe....


----------



## Templon (15. Nov 2008)

Poste mal den Code den du bis jetzt hast.


----------



## XRayT1Raycer (15. Nov 2008)

/******************************  Primfaktorzerlegung.java  ********************/

import AlgoTools.IO;

/**
 * @version 15.11.08
 *  

 */

public class Primfaktorzerlegung {

  public static void main(String argv[]) {

     int unteregrenze, oberegrenze, faktor, h;

     unteregrenze=IO.readInt("Bitte die untere Intervallgrenze eingeben:");
     oberegrenze=IO.readInt("Bitte die obere Intervallgrenze eingeben:");

     for(h=unteregrenze; h<=oberegrenze; h++)
     {
       IO.print(h + "=");
       IO.println();

       for(faktor=2; faktor<=oberegrenze; faktor++)
       {
         while(oberegrenze%faktor==0)
         {
           IO.print("  " + faktor);
           }
           }
           }
     }
  }


Habe nochmal ein paar Dinge probiert und nun hängt das Programm in einer Endlosschleife....Irgendwie habe ich nun auch wieder den Algorithmus für die Zerlegung zerschossen... :-(
Bitte um Hilfe......
Danke


----------



## SlaterB (16. Nov 2008)

formatiert und ohne IO:

```
public class Test {

	public static void main(String argv[]) {

		int unteregrenze, oberegrenze, faktor, h;

		unteregrenze = 5;
		oberegrenze = 9;

		for (h = unteregrenze; h <= oberegrenze; h++) {
			System.out.print(h + "=");
			System.out.println();

			for (faktor = 2; faktor <= oberegrenze; faktor++) {
				while (oberegrenze % faktor == 0) {
					System.out.println(" " + faktor);
				}
			}
		}
	}
}
```

die Schleife
> while (oberegrenze % faktor == 0) {
>					System.out.println(" " + faktor);
>				}

macht keinen Sinn, 
zunächst mal, was hat oberrgrenze da zu suchen, es geht doch um h?
und wenn faktor nun ein Teiler ist, dann gibts wirklich ne Endlosschleife,

außerdem reicht es nicht, zu prüfen, ob faktor ein Teiler ist 
(das ginge mit if statt while und wäre schonmal eine gute Übung, mach das mal)

sondern ein faktor kann auch mehrmals in der aktuell untersuchten Zahl drin sein,
du musst ihn dann rausrechnen und mehrmals prüfen,

dafür ist die while-Schleife schon ganz gut,
wichtig ist nun aber, die untersuchte Zahl auch zu modifizieren, so dass die Schleife irgendwann beendet wird,

h solltest du nicht ändern, dass ist ja die Schleifenvariable,
lege dir eine Kopie von h an, die du dann bearbeiten kannst

>  for(faktor=2; faktor<=oberegrenze; faktor++) 

schon wieder oberegrenze, muss h sein,
bzw. die neue Variable, die anfangs eine Kopie von h ist und dann immer kleiner wird

----

Tipp: lasse erstmal das Interval weg, und versuche, die Zerlegung überhaupt nur für EINE Zahl hinzubekommen,
und lasse bloß die schrecklichen Eingabe weg,
genausogut kannst du doch testweise im Code die zu untersuchende Zahl vorgeben

Beispielablauf:
Zahl = 20

erster Faktor 2,
2 ist drin, ausgeben, Zahl auf 10 verkleinern,
2 immer noch drin, ausgeben, Zahl auf 5 verkleinern

3 nicht
4 nicht

die Schleife muss nun sowieso nur noch bis 5 laufen, nciht bis 20,

5 ist drin, ausgeben, Zahl auf 1 verkleinern, 
bei 1 ist Ende, aber nun bricht die Schleife eh ab

-----

um die Ausgabe des Mal-Zeichens kann man sich ganz am Ende Gedanken machen


----------



## 2plus3 (16. Nov 2008)

1. schleife = untergrenze inkrementieren 
2. schleife = faktor von 0 an hochzählen prüfen ob Primzahl 
wenn faktor gleich Primzahl dann untergrenze Modulo Faktor. wenn Rest =0 .. dann weiter mit neuem Ergebniss wenn nicht dann weiterhin faktor hochzählen. 

(muss jetzt leider los.. kann heut abend nochmal eine ausführliche beschreibung posten)


----------



## Gast (16. Nov 2008)

int x=2;
	while (a>1)
		{
		if (a%x==0) {
			System.out.print(x);
			a=a/x;
			if (a>1) System.out.print("*");
			}
		else {
			x=x+1;
			}
		}


----------



## XRayT1Raycer (16. Nov 2008)

Danke für die zahlreichen Tips.....
Für eine Zahl hatte ich das Teil schonmal am laufen, aber als ich dann versucht habe den Kram mit dem Intervall einzubauen habe ich dabei leider alles was schon funktioniert hat wieder zerschossen :-(


----------



## Gast (16. Nov 2008)

ne frage sollen die primzahlen berechnet werden oder sollen sie aus z.B. einem Array ausgelesen werden .. ?


----------



## XRayT1Raycer (16. Nov 2008)

es sollen zwei zahlen eingelesen werden, menetwegen z.b. 20 und 30...dann soll das programm für alle zahlen, die in diesem intervall liegen, eine primfaktorzerlegung durchführen...
also in diesem beispiel jeweils eine primfaktorzerlegung für die zahlen 20, 21, 22, 23, 24, 25, 26, 27, 28, 29 und 30....
alles nach dem schema
  20=2*2*5
  21=....
  22=... usw.


----------



## XRayT1Raycer (17. Nov 2008)

/******************************  Primfaktorzerlegung.java  *******************/

import AlgoTools.IO;

/**
 * @version 17.11.08
 *  

 */

public class Primfaktorzerlegung {

  public static void main(String argv[]) {

  int untergrenze, obergrenze, faktor;

  untergrenze=IO.readInt("Bitte die untere Intervallgrenze eingeben:");
  obergrenze=IO.readInt("Bitte die obere Intervallgrenze eingeben:");

    while (obergrenze<=untergrenze) {
     obergrenze=IO.readInt("Bitte die obere Intervallgrenze eingeben:");
     }

       for(faktor=2; faktor<=untergrenze; faktor++) {
         while(untergrenze%faktor==0) {
           untergrenze=untergrenze/faktor;
           IO.print(" " + faktor);
           }
           }


  }
}


So, habe nochmal ein wenig rumprobiert! Für eine Zahl funktioniert die Ausgabe soweit, allerdings nur für die Untergrenze des Intervalls.....
Alle Versuche, eine Schleife drumrum zu bauen, damit er die Zerlegung für alle Zahlen bis zur Obergrenze durchführt, haben eine Endlosschleife zur Folge.....
Wäre nicht schlecht, wenn ihr mir in der Hinsicht noch ein paar Tips geben könntet.....
Danke schonmal ;-)


----------



## SlaterB (17. Nov 2008)

wenn du diese Versuche nicht postest, kann man sie nicht korrigieren,

allgemein muss es etwa so wie in deinem ersten Code aussehen, mit der h-Variablen,
wie ich schon gesagt habe, darf sich dann der innere Code aber weder auf die Schleifengrenzen beziehen noch h modifizieren, sondern nur eine Kopie von h,

am einfachsten und schönsten ist es, wenn du dir eine Methode

public void zerlege(int x) {
...
}

+ Aufruf

for ( h ..) {
  zerlege(h);
}

definierst, so ist die Trennung automatisch gegeben, denn wenn du hier den Parameter x in zerlege() modfizierst, hat das auf das h des Aufrufers keine Auswirkungen,
x ist eine Kopie von h


----------



## XRayT1Raycer (17. Nov 2008)

Ich hatte mir sowas überlegt!


```
/****************************** Primfaktorzerlegung.java *******************/ 

import AlgoTools.IO; 

/** 
* @version 17.11.08 
* 

*/ 

public class Primfaktorzerlegung { 

public static void main(String argv[]) { 

int untergrenze, obergrenze, faktor, zahl; 

untergrenze=IO.readInt("Bitte die untere Intervallgrenze eingeben:"); 
obergrenze=IO.readInt("Bitte die obere Intervallgrenze eingeben:"); 

while (obergrenze<=untergrenze) { 
obergrenze=IO.readInt("Bitte die obere Intervallgrenze eingeben:"); 
} 

for(zahl=untergrenze; zahl<=obergrenze; zahl++){  
  for(faktor=2; faktor<=zahl; faktor++) { 
      while(zahl%faktor==0) { 
        zahl=zahl/faktor; 
           IO.print(" " + faktor); 
}
} 
} 


} 
}
```

Hilfsvariable zahl und dann ne for-Schleife drumrum, allerdings funzt das nit......
Wie genau meinst du das mit der Kopie? Da ich mein Studium gerade erst begonnen habe habe ich davon noch nie was gehört......Geht das auch irgendwie ohne diese Kopie?
Danke


----------



## SlaterB (17. Nov 2008)

nun habe ich schon zweimal geschrieben, dass du die Schleifenvariable nicht modifzieren sollst,
denn wie soll 'zahl' ordentlich von unteregrenze bis oberegrenze laufen, wenn du es in der Schleife bis auf 1 reduzierst?

und der Trick ist denkbar einfach:

```
for(int h=untergrenze; h<=obergrenze; h++){  
  zahl = h;
  for(faktor=2; faktor<=zahl; faktor++) { 
      while(zahl%faktor==0) { 
        zahl=zahl/faktor; 
           IO.print(" " + faktor); 
}
```
nur die Schleifenvariable kopieren,

bisschen nachdenken was ich so meinen könnte und auch einfach ausprobieren


----------



## XRayT1Raycer (17. Nov 2008)

ok, habs gecheckt, das programm läuft jetzt  jetzt bleibt nur noch das problem mit den *-zeichen:
die ausgabe sieht wie folgt aus, z.b.20
  20=2*2*5*

wie bekomme ich das überflüssige * weg?
danke


----------



## SlaterB (17. Nov 2008)

erstmal besteht die Frage, wie es überhaupt reinkommt,
dein Code enthält nichts davon,

eine elegante Methode wäre so, wie ein 'Gast' es in seinem Posting verraten hat,
schau mal den bisherigen Thread durch, gibt nur zwei 'Gast'-Postings


----------



## XRayT1Raycer (17. Nov 2008)

```
/******************************  Primfaktorzerlegung.java  *******************/

import AlgoTools.IO;

/**
 * @version 15.11.08
 *  

 */

public class Primfaktorzerlegung {

  public static void main(String argv[]) {
     
  int untergrenze, obergrenze, faktor, h, k;

  untergrenze=IO.readInt("Bitte die untere Intervallgrenze eingeben:");
  obergrenze=IO.readInt("Bitte die obere Intervallgrenze eingeben:");

    while (obergrenze<=untergrenze)
    {
     obergrenze=IO.readInt("Bitte die obere Intervallgrenze eingeben:");
    }

      for(h=untergrenze; h<=obergrenze; h++, IO.println()) 
      {
      k=h;
      IO.print(k + " = ");
        for(faktor=2; faktor<=k; faktor++)
       {
         while(k%faktor==0)
         {
          k=k/faktor;
           IO.print(" " + faktor + " *");
         }
       }
     }

  }
}
```

mein problem ist das hinter dem letzen faktor überflüssigerweise noch ein "*" ausgegeben wird....


----------



## SlaterB (17. Nov 2008)

hab ich mir schon gedacht und auch bereits beantwortet,
wenn die Suche nach dem 'Gast'-Posting + Verstehen des dort stehenden Quellcodes zu viel Arbeit ist,
dann kannst du die Aufgabe eben nicht völlig lösen,
ist ja auch so schon recht gut


----------



## Guest (17. Nov 2008)

is nich zu viel arbeit, wollte nur der kritik folgen und meinen quelltext nachreichen  ;-)
besten dank für die hilfe


----------



## Gast (17. Nov 2008)

meine frage besteht immer noch  

also eine Zahl in Primfaktoren zerlegen bedeutet dass du diese in "PRIMZAHLEN" zerlegst .. doch berechnest du in deinem Code die Primzahlen oder nimmste alle Natürlichen zahlen .. ??

ergibt es sich von alleine dass man durch Modulo = 0  nur Primzahlen als Multiplikatoren bekommt???


----------



## 2plus3 (17. Nov 2008)

noch ne anmerkung wenn du IO.print(); nur benutzt weils kürzer ist als  System.Out.Println(); .. dann geb ich dir ein tipp.. wenn du Eclipse benutz dann tipp einfach "syso" ein und drück STRG+LEER ;-)

IO macht mich nähmlich etwas nervös


----------



## XRayT1Raycer (17. Nov 2008)

IO bezieht sich auf ne Datei mit vorgefertigten Java-Methoden, die wir von der Uni bekommen haben....Von daher braucht dich das nicht nervös machen ;-)


----------



## SlaterB (17. Nov 2008)

> ergibt es sich von alleine dass man durch Modulo = 0 nur Primzahlen als Multiplikatoren bekommt???

nicht durch das Modulo = 0, sondern dadurch, dass man ganz vorne anfängt und nicht aufhört solange Teilbarkeit besteht,

für die Zahl 64 würde % 8 auch 0 ergeben,
aber vorher kommt ja die 2 und der Teiler 2 wird so oft ausgesaugt (herausmultipliziert) bis er nicht mehr drin ist,
daher können unmöglich andere Teile als Primzahlen entstehen


----------

