Eine Zahl solange teilen bis es nicht möglich ist und die Ergebnisse ausgeben

Hey Jungs und Mädels!

Ich habe eine Auf gabe bei der ich nicht mehr weiter komme. Sie lautet:
Herr Becker möchte seine Klasse von 18 Schülern in Gruppen aufteilen. Schreibe ein Programm, das ausgibt, welche Möglichkeiten es für die Gruppengröße gibt und lass sie ausgeben.

Soooo....Diese Aufgabe MUSS mit while-Schleifen gelöst werden. Ich hatte die Idee, dass man das testen lässt in dem man solange durch eine ganze Zahl teilt bis ein Rest herauskommt also es beginnt bei 1 und er zieht es solange durch bis ein Rest rauskommt. Aber ich habe keine Ahnung wie man das umsetzten kann.

Mit freundlichen Grüßen
Nils von Bismarck
 
Dass man hier teilen muss bzw. herausfinden muss, ob bei der Division ein Rest entsteht, hast du ja schon richtig erkannt.
Was wir hier ja prinzipiell wollen, ist herauszufinden, welche ganzzahligen Teiler die Anzahl der in (gleich große) Gruppen einzuteilenden Schüler hat.
Also: 18 = 2 * 9 = 3 * 6
Du kannst also einfach den Rest-Operator (%) in Java hierfür verwenden.
 
Soll es sich um Gruppen mit gleicher Anzahl von Schülern handeln?

Dann musst du einfach alle Fälle von 1 bis zur maximalen Anzahl der Schüler ausprobieren, ob sie sich ohne Rest teilen lassen. Die beiden Extremfälle sind demnach 18/18 = 1 Gruppe mit 18 Schülern und 18/1 = 18 Gruppen mit einem Schüler. Diese beiden Fälle kannst du aber vermutlich weglassen.
 
Mir ist schon klar das ich mathematisch gesehen das machen muss und den Operator % hätte ich auch genommen aber ich muss das ja in eine while-Schleife einbauen. Und da hört es dann bei mir auf.
 
Naja, verwende eine while-Schleife einfach als andere Form einer for-Schleife (über die Zahlen 1..N, wobei N die Anzahl der Schüler ist).
Dabei kannst du ja folgende Äquivalenz zwischen for- und while-Schleife ausnutzen:
Java:
for (initialization; condition; increment) {
  body
}

initialization;
while (condition) {
  body
  increment
}
 
Nein man soll alle möglichen Gruppen herausfinden, die bei 18 Schülern möglich sind und Ja die Schüleranzahl in den Gruppen soll gleich sei wie z.B. 9 Schüler in 2 Gruppen oder 3 Schüler in 6 Gruppen.
 
Der Modulo Operator wird dir nicht viel helfen, da es Gruppengrößen mit zum Beispiel je 1,8 Schülern pro Gruppe geben könnte.
D. h. ... zum Beispiel die Hälfte der Gruppen haben einen Schüler und ein paar Gruppen haben zwei Schülern.
Ich würd einfach zählen.
 
Der Modulo Operator wird dir nicht viel helfen, da es Gruppengrößen mit zum Beispiel je 1,8 Schülern pro Gruppe geben könnte.
Deswegen würde man bei einer korrekten Verwendung des Rest-Operators (nicht Modulo-Operator) auch prüfen, ob die Division ohne Rest aufgeht. Dann können nur Gruppen mit einer ganzzahligen Größe entstehen.
Oder anders gesagt: Wenn die Schüleranzahl eine Primzahl ist, wird es nur eine Gruppe geben.
 
Was meinst du mit "solche"?
@NilsVonBismarck hat bereits klar geschrieben, dass die Anzahl der Schüler in den Gruppen gleich sein soll.
Und selbstverständlich ist die Anzahl der Personen pro Gruppe ganzzahlig.
 
@abc66 Das ist mir schon klar mir ging es aber darum wie man das mit einer while Schleife lösen kann und dann einfach immer wieder eine andere Schüleranzahl eingibt wie z.B. 24 und das Programm berechnet dann die verschiedenen Gruppengrößen, die möglich sind.
 
Ich hatte die Idee, dass man das testen lässt in dem man solange durch eine ganze Zahl teilt bis ein Rest herauskommt also es beginnt bei 1 und er zieht es solange durch bis ein Rest rauskommt. Aber ich habe keine Ahnung wie man das umsetzten kann.
Da Du Dir schon die Mühe gemacht hast, etwas wie einen Algorithmus zu beschrieben und es Dir nur um die Kodierung geht, kann man Dir sogar ein wenig weiter helfen.

Bleiben wir erstmal bei Deinem Algorithmus. Den muss man etwas präziser formulieren. Ich verstehe Dich so, dass Du einen ganzzahligen Teiler verwenden willst, der zu Beginn auf 1 gesetzt wird. So lange, bis beim Teilen der Gruppengröße durch diesen Teiler ein Rest entsteht, willst Du die nächst größere ganze Zahl als Teiler verwenden, also den Teiler um 1 erhöhen.

Etwas schöner aufgeschrieben (n sei die Gruppengröße):
Code:
teiler := 1
wiederhole, bis n mod teiler > 0
    teiler := teiler + 1
Die Formulierung "wiederhole, bis" entspricht nicht einer while-Schleife, lässt sich aber problemlos zu einer solchen umformen. Aus "wiederhole, bis Bedingung x gilt" wird einfach "wiederhole, so lange Bedingung x nicht gilt".

Im konkreten Fall erhält man also
Code:
teiler := 1
wiederhole, so lange n mod teiler = 0
    teiler := teiler + 1
Das lässt sich nun 1:1 in Code umsetzen:
Java:
int teiler = 1;
while ((n % teiler) == 0) {
    teiler++;
}
Der Vollständigkeit halber sei erwähnt, dass das nicht die Lösung der Aufgabe ist: Dein Algorithmus würde für n == 18 bei teiler == 5 aufhören, obwohl es noch weitere Teiler (6) gibt. :)
 
Ich fand etwas heraus, was keiner mehr lesen kann:
Java:
void printGruppengroessen(int anzahlDerSchueler) {
	boolean deformiert = false;
	if (anzahlDerSchueler % 2 == 1) {
		deformiert = true;
		anzahlDerSchueler++;
	}
	for (int anzahlDerGruppen = 2; anzahlDerGruppen <= anzahlDerSchueler; anzahlDerGruppen++) {
		if (anzahlDerSchueler % anzahlDerGruppen == 0) {
			System.out.println(anzahlDerGruppen + " : ");
			for (int i = 1; i <= anzahlDerGruppen; i++) {
				if (deformiert && i == anzahlDerGruppen) {
					if (((anzahlDerSchueler / anzahlDerGruppen) - 1) > 0) {
						System.out.print(((anzahlDerSchueler / anzahlDerGruppen) - 1) + " ");
					}
				} else {
					System.out.print((anzahlDerSchueler / anzahlDerGruppen) + " ");
				}
			}
			System.out.println("");
		}
	}
}
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben