Was macht der Schleifenzähler hier? (Modulo)

Guten Abend

Ich bin ein Programmieranfänger und versuche trotzdem das eine oder andere Programm zu schreiben.
Es geht um folgende Aufgabe: “Schreiben Sie ein Java-Programm, das eine positive ganze Zahl a einliest und die Anzahl ihrer verschiedenen Teiler ausgibt. Ein Teiler einer ganzen Zahl a ist eine ganze Zahl d zwischen 1 und a (je inklusive), die a ohne Rest teilt.

Meine Lösung sah vor, dass zwei integer a und b eingelesen werden und dann der Modulo a%b berechnet wird. Beide Variablen wurden dann inkrementiert um 1. Um die Anzahl zu bekommen, habe ich die Durchgänge gezählt mit einer while-if Schleife.
Ich habe meinen Ursprungscode nicht mehr, da ich den Code sofort anhand der Lösung umgeschrieben habe…
Meine Lösung die ich hatte, war falsch und habe dann in der Auflösung geschaut. In der Auflösung steht:

	/* Groesster Gemeinsamer Teiler  */ 
	public class a1 { 
	  public static void main(String[] args) { 

	  int a = 0;		/*Benutzereingabe*/
	 int d = 0;		/*Schleifenzaehler*/
	  int n = 0; 		/*zaehlt Anzahl der Teiler*/

	  /*Einlesen Eingabezahl*/
	  a  = Integer.parseInt
			  (JOptionPane.showInputDialog (null, "A = "));
	  
	  /*while-if Schleife, die durch alle Werte von a laeuft und fuer jeden Wert d ueberprueft,
	   * ob er ein Teiler von a ist*/
	   
	  d=1;		/*Schleifenzaehler initialisieren*/
	  while (d <=  a){		/*Schleifenbedingung*/
	    if (a % d ==0)		/*ist d Teiler von a?*/
	    		n++;		/*falls ja, mitaehlen*/
	    	d++;
	  }
	  JOptionPane.showMessageDialog(null, "Anzahl der Durchgaenge: " + d);
	  JOptionPane.showMessageDialog(null, "Anzahl der Teiler von A: " + n);
	  }
	  }

Mein Verständnis-Problem bezieht sich auf Zeile 7, 17, 18 und 19 . Zeile 23 ist ein Überbleibsel meiner Lösung.
Soweit vollziehe ich zwar die Lösung, jedoch verstehe ich nicht, wieso dem Schleifenzähler d die größte Arbeit auferlegt wird. Bei mir kam dieser nämlich garnicht vor.

Konkret: Wieso wird der Schleifenzähler hier für die Aufgabe gebraucht und was macht der Schleifenzähler grundsätzlich in einem Java-Programm?

Verzeiht mir meinen allerersten Post hier.

wie du in deinem Ansatz vielleicht auch hattest geht es doch darum, alle Zahlen zwischen 1 und a durchzuprobieren,

wie man das macht ist nicht festgelegt, aber eine Schleife mit irgendeinem Wert immer +1 erhöht ist schon ziemlich passender Weg,
ob man diese Variable dann Schleifenzähler oder sonstwie nennt, ist nebensächlich,
Hauptsache irgendwas ist 1, 2, …, a und wird jeweils geprüft

Moin,

ich habe den Code mal besser formatiert und ein wenig optimiert!

public class a1 
{
    public static void main(String[] args) 
    {
         int n = 0;     /* zaehlt Anzahl der Teiler */
     
         /* Einlesen der Benutzereingabe */
         int a  = Integer.parseInt( JOptionPane.showInputDialog(null, "A = ") );
         
         /* while-Schleife, die durch alle Werte von a laeuft und fuer jeden Wert d ueberprueft, ob er ein Teiler von a ist*/
         int d = 1;      /*Schleifenzaehler deklarieren und initialisieren */
	   
        while( d <= a ) /* Schleifenbedingung */
        {
             if( (a % d) == 0 )    /* ist d Teiler von a? */
             {
                  n++; /* falls ja, zaehlen */
             }
             d++;
        }
        JOptionPane.showMessageDialog(null, "Anzahl der Durchgaenge: " + d);
        JOptionPane.showMessageDialog(null, "Anzahl der Teiler von A: " + n);
     }
}

Du kannst bspw. die Deklaration einer Variable (int i) mit ihrer Initializierung (i = 0) zusammenlegen (int = 0)! Das macht es schon mal ein Stück übersichtlicher!
Dann würde ich Dir empfehlen, auch bei Codeteilen wie der IF-Abfrage IMMER Klammern zu verwenden (besonders, wenn der Code nicht so prickelnd formatiert ist ;P). Du verlierst sonst garantiert irgendwann den Überblick.
Der Wert ‘d’ garantiert hier die Schleifenbedingung (“solange d kleiner a”).
Alternativ könntest Du ja auch eine FOR-Schleife nutzen (for int i = 1; i <= a; i++ ) …

Wichtig ist, dass Du dir klar machst, was innerhalb der Schleife passiert!
Nimm’ ggf. einfach mal ein Blatt Papier und dann das Programm Schritt für Schritt durch und schreib’ dir die jeweiligen Werte auf!

Gruß Klaus

[HR][/HR][quote=Kazan;139737]. Beide Variablen wurden dann inkrementiert um 1.[/quote]Was wolltest Du damit erreichen?
Eine der Beiden eingelesenen Zahlen hätte doch die zu prüfende Zahl sein müssen, die sich wärend des Programmlaufs nicht verändern darf…

[HR][/HR][quote=Kazan;139737]Meine Lösung die ich hatte, war falsch[/quote]Sorry für die harten Worte, aber dass zeigt schon die Beschreibung Deines Ansatzes…

[HR][/HR][quote=Kazan;139737]Soweit vollziehe ich zwar die Lösung, jedoch verstehe ich nicht, wieso dem Schleifenzähler d die größte Arbeit auferlegt wird.[/quote]Die “Arbeit” steckt nicht in der Variablen, sondern in der Schleifenlogik.

Die Variable d zählt die Schleifendurchläufe, das bedeutet, das diese Variable in jedem Durchlauf der Schleife die Nummer des aktuellen Durchlaufs enthält.
Klar soweit?

Zurück zur Aufgabe:[quote=Kazan;139737]und die Anzahl ihrer verschiedenen Teiler ausgibt.[/quote]Teiler der eingelesenen Zahl müssen immer kleiner sein als die Zahl selbst (mit Ausnahme der Zahl selbst).
Um die Teiler zu ermitteln muss man nun alle Zahlen, die kleiner als die Zahl sind prüfen.
Dazu muss man all diese kleineren Zahlen irgendwie generieren.
Und hier kommt wieder die Schleifenvariable in’s Spiel, weil sie genau alle ganzen Zahlen kleiner als die zu untersuchende enthält und zwar in jedem Scheifendurchlauf genau eine davon.

bye
TT

Danke euch für das Erklären.
Ich werde weiterhin die Schleifen üben, üben, üben!!