# Zweimal Vollmond im Monate



## discere (15. Nov 2012)

Hallo, ich muss Planet "A", der sich genau wie die Erde ist. Tage, Monate, Schaltjahr sind genauso wie bei uns, die Kalender sind gleich. Aber ist der Mond schon etwas schneller und braucht exakt 29 Tage für einen Umlauf. Am 1.Januar 2013 sei dort Vollmond. N = ersten N Monate(in jeweils einer Zeile) ausigbt, in denen es 2x Vollmond gibt. 

Dies sollte das Ergebnis: 
Aufruf & Ausgabe:
$ java 2xFullMoon 2
2013, January
2014, March

ich habe versucht die tage jeweils getrennt fuer jahre, monate und den
mondzyklus zu zaehlen. man muss dabei auf schaltjahre bei den jahren
und beim monat februar achten. ich setze die tagesnummer wieder auf
1 zurueck, wenn der entsprechende zyklus um ist.

hierbei muss ich irgendwo fehler gemacht haben. Villeicht kann mir ja einer helfen, dankbar wäre ich jedenfalls dafür. 




```
public class 2xFullMoon {

public static boolean schaltjahr ( int jahr ) {
  if ( jahr % 4 == 0 ) {
    if ( (jahr % 100 == 0) && (jahr % 400 != 0) ) {
      return false;
    }
    return true;
  }

  return false;
}

public static void main ( String args [] ) {
  int num = 1;
  int jahr = 2013; 
  int d = 1; //day
  int dm = 1; //Tage Monate
  int vm = 0; //vollmond
  int mon = 1;  //Monate
  int m = 1; //
  int dy = 1; // tag-Jahr
  int n = 0;

  num = Integer.parseInt( args[ 0 ] );

  for ( d = 1 , m = 1, mon = 1, n = 0; true; d++, dm++, dy++ ) { //Schaltjahr
    if ( (dy > 1) && (dy % 365 == 1) && ! schaltjahr( jahr ) ) {
      jahr++;
      dy = 1;
    }

    if ( (dy > 1) && (dy % 366 == 1) && schaltjahr( jahr ) ) { //keine Schaltjahr
      jahr++;
      dy = 1;
    }

    if ( (dm > 1) && (dm % 31 == 1) ) {
      switch ( mon ) {
        case 1:     //January 31.
        case 3:     //March 31.
        case 5:     //May 31.
        case 7:     //July 31.
        case 8:     //August 31.
        case 10:    //October 31.
        case 12:    //December 31.
            mon++;
            break;
      }
    } 

    if ( (dm > 1) && (dm % 30 == 1) ) {
      switch ( mon ) {
        case 4:      //April 30.
        case 6:      //June 30.
        case 9:      //September 30.
        case 11:     //November 30.
          mon ++;
          break;
      }
    } 

    if ( (dm > 1) && (dm % 28 == 1) && (mon == 2) && ! schaltjahr( jahr ) ) {
      mon ++; //Schaltjahr
      
    } 

    if ( (dm > 1) && (dm % 29 == 1) && (mon == 2) && schaltjahr( jahr ) ) {
      mon ++; //keine Schaltjahr
  
    } 

    if ( d % 29 == 1 ) {
      vm ++;
      if ( m == mon ) {
        n ++;
        if ( n <= num ) {
          System.out.print( jahr );
          switch ( mon ) {
            case 1:
              System.out.println( ", Januar" );
              break;
            case 2:
              System.out.println( ", Februar" );
              break;
            case 3:
              System.out.println( ", Maerz" );
              break;
            case 4:
              System.out.println( ", April" );
              break;
            case 5:
              System.out.println( ", Mai" );
              break;
            case 6:
              System.out.println( ", Juni" );
              break;
            case 7:
              System.out.println( ", Juli" );
              break;
            case 8:
              System.out.println( ", August" );
              break;
            case 9:
              System.out.println( ", September" );
              break;
            case 10:
              System.out.println( ", Oktober" );
              break;
            case 11:
              System.out.println( ", November" );
              break;
            case 12:
              System.out.println( ", Dezember" );
              break;
            }
          } else {
         
            return;
           
          }
        }
      }
      m = mon;
    } // end for
  } // End of main

} // End of class
```


----------



## TR (15. Nov 2012)

Irgendwie alles etwas komisch.
Das ganze bekommt man mit 11 Zeilen Code hin.

Ist alles über java.util.Calendar machbar. Und das kümmert sich auch um Schaltjahre!


----------



## discere (15. Nov 2012)

ich habe versucht zu "import java.util.Calender.*;" hinzufügen.

ich soll 

```
public static boolean schaltjahr ( int jahr ) {
  if ( jahr % 4 == 0 ) {
    if ( (jahr % 100 == 0) && (jahr % 400 != 0) ) {
      return false;
    }
    return true;
  }

  return false;
}
```

weglasssen.. aber das program funktioniert sich nicht. :rtfm:


----------



## discere (15. Nov 2012)

discere hat gesagt.:


> ich habe versucht zu "import java.util.Calender.*;" hinzufügen.
> 
> ich soll
> 
> ...




Ich denke es soll besser bleiben... ohne import...


----------



## TR (15. Nov 2012)

so könnte man das machen:


```
import java.text.SimpleDateFormat;
import java.util.Calendar;

public class TestMond {
	public static void main(String[] args) {
		Calendar cal = Calendar.getInstance();
		cal.set(2013, 0, 1);
		SimpleDateFormat format = new SimpleDateFormat("yyyy, MMMMM");		
		while((cal.get(Calendar.YEAR)) < 2020){
			int today = cal.get(Calendar.DATE);
			int maxmonth =  cal.getActualMaximum(Calendar.DAY_OF_MONTH);
			if (maxmonth - today - 29 >=0){
				System.out.println(format.format(cal.getTime()));
			}
//					System.out.println("today: " + today + "  maxmonth: " + maxmonth + "\t  " + cal.getTime());
			cal.add(Calendar.DAY_OF_MONTH, +29);
		}
	}
}
```

geht vom 1.1.2013 bis 31.12.2019 (2020) durch!

achso, nur weil man ein "import java.util.Calender.*;"  einfügt, macht dein programm nicht deswegen  was anderes.


----------



## SlaterB (15. Nov 2012)

schau dir doch ganz simpel an, was in jeder Zeile passiert, welche Werte berechnet werden, 
ob das dem entspricht was passieren soll usw.,

ich habe es jetzt gemacht und es juckt mir gar schon, die Erkenntnisse zu posaunen  , besser wäre aber wenn du selber drauf kommst

> if ( n <= num ) 

n ist ohne Kommentar anscheinend die Anzahl Vollmonde in einem Monat, das geht zur Grenze 2, aber nicht zu num, denn N Vorkommen dieses Ereignisses,
n wird bei dir nie zurückgesetzt, was bisschen Richtum num spricht, aber du vergleichst m mit mon, was doch wieder nach Anzahl Vollmonde im Monate aussieht

wenn 
> if ( m == mon ) {
erfüllt ist musst du n erhöhen, richtig, anderenfalls aber auf 1 setzen, sonst zählst du immer weiter munter fort

> m = mon;
ist problematisch, damit wird jeder Vollmonat, der nicht als erster eines Monats gilt, die Bedingunge 
>  if ( m == mon ) {
erfüllen, das ist falsch, du willst nicht zwischen ersten und sonstigen Tagen unterscheiden 
sondern ob schon ein Vollmond in diesem Monat war oder nicht,
nur wenn Vollmond ist, darf und muss 'm = mon;' ausgeführt werden

erst mit return; abzubrechen wenn n > num ist unnötig, wozu noch ein drittes Vorkommen suchen wenn dich nur die ersten beiden Monate mit 2 Vollmonden interessieren,
führe die Ausgabe immer aus und nur wenn danach geprüft n == num ist, dann return;


edit:
vielleicht brauchst und planst du aber auch gar keine Variable für die Anzahl Vollmonde in einem Monat,
allein m == mon dürfte reichen, setze das nur wenn Vollmond, und falls schon gesetzt, dann n erhöhen, richtig

der Fehler wäre dann nur noch 'm = mon;' in das if für den Vollmond hineinzunehmen

------

so, das klingt schon so anstrengend, da hast du allein mit der Auswertung Arbeit genug, oder einfach selber analysieren,
Grundfrage: was passiert wann, welcher Plan dahinter, klappt der auch?
du kannst ruhig mit System.out.println() jeden einzelnen Durchlauf/ Tag loggen, d, vm, n, m, mon usw. ausgeben

ein genereller Tipp:
Untermethoden verwenden:

```
if ( n <= num ) {
         printAusgabe(jahr, mon);
      } else {
          return;
      }
```
ist leserlicher als 100 Zeilen verschieden verschachtelter Code

ein Klassename 2xFullMoon ist übrigens gar nicht erlaubt, kannst du dein Programm ausführen?
nicht mit Ziffern beginnen


----------



## discere (15. Nov 2012)

Hallo, ich bin ???:L 


Ich habe mit diesen Untermethoden verwenden:

```
if ( n <= num ) {
         printAusgabe(jahr, mon);
      } else {
          return;
      }
```

Das Programm geht nicht raus. ERROR. hmmm

Ja stimmt.. 2xFullMoon... ich benutze aber andere Name..
Es klingt schon so anstrengend, da ich allein mit der Auswertung Arbeit genug habe.  Ich komme nicht klar...


----------



## SlaterB (15. Nov 2012)

ja, du müsstest schon ne entsprechende Untermethode programmieren, sonst Fehler..
mit schaltjahr() klappte das doch auch, aber muss ja auch nicht sein

entsprechend der Rest meiner Ausführungen wohl auch zu hoch..,
also Zeile 124 vom ersten Code vor Zeile 123 schieben, dann dort besser,

beginne m mit 0, sonst der Januar am Anfang gleich verdächtig,
aus der for-Schleife die wiederholte Deklaration [c]for ( d = 1 , m = 1, mon = 1, n = 0[/c] entfernen bzw. auch anpassen, m mit 0 beginnen,

------------

an wirklich vielen Stellen musst du auf die Werte achten:

```
if ( (dm > 1) && (dm % 29 == 1) && (mon == 2) && schaltjahr( jahr ) ) {
      mon ++; //keine Schaltjahr
  
    }
```
hier musst du dm wieder auf 1 setzen, neue Zählung beginnen, % 29 kannst du dir dann sparen und genau auf 29 schauen,
dm immer weiter hochzuzählen und dann zu versuchen aus 29+31 = 60 den nächsten Monatswechsel zu erkennen, das wird nicht klappen

bei anderen Monatserhöhungen auch, bei Jahreswechsel den dy auf 1 usw., oh das hast du ja sogar schon 


```
if ( (dm > 1) && (dm % 31 == 1) ) {
      switch ( mon ) {
        case 1:     //January 31.
        case 3:     //March 31.
        case 5:     //May 31.
        case 7:     //July 31.
        case 8:     //August 31.
        case 10:    //October 31.
        case 12:    //December 31.
            mon++;
            break;
      }
    }
```
nach Dezember wird Monat auf 13 erhöht, das muss 1 werden

wie gesagt: ganz einfach loggen, welchen Wert haben d, dm, dy, mon, jahr vor bestimmten Tagen wie 31. Dezember und welche danach,
wenn sie nicht stimmen, wenn etwa Monat auf 13 hochgeht statt auf 1, dann genau schauen welcher Code dafür verantwortlich ist


----------



## discere (15. Nov 2012)

Stimmt,


```
if ( (dm > 1) && (dm % 31 == 1) ) {
      switch ( mon ) {
        case 1:
        case 3:
        case 5:
        case 7:
        case 8:
        case 10:
          ++ mon;
         
          break;
        case 12:
          mon = 1;
         
          break;
```

Nun besser?


----------



## SlaterB (15. Nov 2012)

allein in diesem Code fehlt bereits (immer noch), dm jeweils auf 1 zu setzen,
insgesamt also sicher jede Menge weiter zu tun,

allein gegen Monat 13 aber erfolgreich, ja
schön wäre es wahrlich, wenn du das selber testen/ nachprüfen würdest..


------

alle Bedingungen mit % sind wie gesagt unnötig kompliziert
> if ( (dm > 1) && (dm % 31 == 1) ) {

-> 

if ( dm == 32 ) {


----------



## discere (15. Nov 2012)

ja, wie kann ich selbst überprüfen??? :rtfm:


----------



## SlaterB (15. Nov 2012)

siehe auch edit zuvor,

> ja, wie kann ich selbst überprüfen???

einfach System.out.println() mit allen wichtigen Variablen an einer oder mehreren Stellen der Schleife,
schaue dir an, wie sich mon und alle anderen Variablen von Tag zu Tag ändert

über mehrere Jahre 500 Ausgaben und mehr erschlagen vielleicht, 
wenn du aber sauber anordnest, etwa mit Tag d am Anfang, dann eine saubere Liste, die man gut durchscrollen kann


----------



## discere (15. Nov 2012)

SlaterB hat gesagt.:


> alle Bedingungen mit % sind wie gesagt unnötig kompliziert
> > if ( (dm > 1) && (dm % 31 == 1) ) {
> 
> ->
> ...



eigentlich if (dm == 31)


----------



## SlaterB (15. Nov 2012)

je nachdem wie man es haben will, [c]dm % 31 == 1[/c] schlägt ja auch nur bei 32 an,
der 31. ist durchaus noch ein valider Tag im Dezember, erst wenn in der nächsten Runde auf 32 erhöht wird erfolgt Monatswechsel (+ nicht vergessen Tag auf 1 setzen)

darf man vermuten dass das soweit nicht dein Code ist?


----------



## discere (15. Nov 2012)

Ja, bin einfach verwirttet. Ich bin neu Anfänger. Die Aufgabe ist mir zu schwer...  Ich überlege... Was habe ich mein Fehler gemacht???


----------



## SlaterB (15. Nov 2012)

wer spricht von einem Fehler?
dass du bei Monatswechsel den Tag auf 1 setzen musst habe ich ja nun schon einige Male widerholen dürfen, danke,
dass du es bisher nicht machst kann man Fehler nennen, aber nun ran und nicht nur Fragezeichen produzieren,


----------



## discere (15. Nov 2012)

Das Programm geht nicht zu Ende!!!! Jahr wird nicht erhöht!
2013, Januar
2013, Maerz

Das Programm soll: 
2013, Januar
2014, Maerz




```
public class Doublemoon {

public static boolean schaltjahr ( int jahr ) {
  if ( jahr % 4 == 0 ) {
    if ( (jahr % 100 == 0) && (jahr % 400 != 0) ) {
      return false;
    }
    return true;
  }

  return false;
}

public static void main ( String args [] ) {
  int num;
  int jahr = 2013; 
  int d; //day
  int dm = 1; //Tage Monate
  int vm = 0; //vollmond
  int mon;  //Monate
  int m; //
  int dy = 1; // tag-Jahr
  int n; //Anzahl der Vollmonde in einem Monat
  

  num = 2;

  for ( d = 1 , m = 0, mon = 1, n = 0; true; d++, dm++, dy++) { //Schaltjahr
    if ( (dy > 1) && (dy % 365 == 1) && ! schaltjahr( jahr ) ) {
      jahr++;
      dy = 1;
    }

    if ( (dy > 1) && (dy % 366 == 1) && schaltjahr( jahr ) ) { //keine Schaltjahr
      jahr++;
 
      dy = 1;
    }

    if ( (dm > 1) && (dm == 32) ) {
      switch ( mon ) {
        case 1:     //January 31.
        case 3:     //March 31.
        case 5:     //May 31.
        case 7:     //July 31.
        case 8:     //August 31.
        case 10:    //October 31.
         mon ++;
            break;
        case 12:    //December 31. 
         mon = 1;
         dm =1;
          break;
       
      }
    } 

    if ( (dm > 1) && (dm == 32) ) {
        
      }
      switch ( mon ) {
          
        case 4:      //April 30.
        case 6:      //June 30.
        case 9:      //September 30.
        case 11:     //November 30.
          mon ++;
          dm =1;   
          break;
         
    } 

    if ( (dm > 1) && (dm % 28 == 1) && (mon == 2) && ! schaltjahr( jahr ) ) {
      mon ++; //Schaltjahr
      
    } 

    if ( (dm > 1) && (dm % 29 == 1) && (mon == 2) && schaltjahr( jahr ) ) {
      mon ++; //keine Schaltjahr
  
    } 

    if ( d % 29 == 1 ) {
      vm ++;
      if ( m == mon ) {
        n ++;
        if ( n <= num ) {
          System.out.print( jahr );
          switch ( mon ) {
            case 1:
              System.out.println( ", Januar" );
              break;
            case 2:
              System.out.println( ", Februar" );
              break;
            case 3:
              System.out.println( ", Maerz" );
              break;
            case 4:
              System.out.println( ", April" );
              break;
            case 5:
              System.out.println( ", Mai" );
              break;
            case 6:
              System.out.println( ", Juni" );
              break;
            case 7:
              System.out.println( ", Juli" );
              break;
            case 8:
              System.out.println( ", August" );
              break;
            case 9:
              System.out.println( ", September" );
              break;
            case 10:
              System.out.println( ", Oktober" );
              break;
            case 11:
              System.out.println( ", November" );
              break;
            case 12:
              System.out.println( ", Dezember" );
              break;
            }
          } 
        }
      
      m = mon;
    } // end for
  } // End of main

} // End of class 
}
```


----------



## SlaterB (15. Nov 2012)

```
if ( (dm > 1) && (dm == 32) ) {
      switch ( mon ) {
        case 1:     //January 31.
        case 3:     //March 31.
        case 5:     //May 31.
        case 7:     //July 31.
        case 8:     //August 31.
        case 10:    //October 31.
         mon ++;
            break;
        case 12:    //December 31. 
         mon = 1;
         dm =1;
          break;
       
      }
    } 

[..]

            if ((dm > 1) && (dm % 28 == 1) && (mon == 2) && !schaltjahr(jahr))
            {
                mon++; // Schaltjahr

            }
```
bei allen case außer 12 wird auch der Monat geändert aber dm bleibt wie es ist, genauso bei den späteren ifs,
dm = 1 muss an viele Stellen, nicht nur an eine!
bisschen mitdenken wäre nicht schlecht, fällt das so schwer?

hier

```
if ((dy > 1) && (dy % 365 == 1) && !schaltjahr(jahr))
            {
                jahr++;
                dy = 1;
            }

            if ((dy > 1) && (dy % 366 == 1) && schaltjahr(jahr))
            { // keine Schaltjahr
                jahr++;

                dy = 1;
            }
```
steht das 'dy = 1' doch auch in BEIDEN Fällen und nicht nur in einem...

--------


```
if ( (dm > 1) && (dm == 32) ) {
        
      }
      switch ( mon ) {
          
        case 4:      //April 30.
        case 6:      //June 30.
        case 9:      //September 30.
        case 11:     //November 30.
          mon ++;
          dm =1;   
          break;
         
    }
```
das switch steht außerhalb des ifs, wird für jeden Tag ausgeführt

und eine Bedingung 'if ( (dm > 1) && (dm == 32) ) {' ist doch offensichtlich zum Teil sinnlos,
wenn dm genau 32 sein muss, dann kannst du dir das > 1 sparen


bei den beiden switches hast du im Moment übrigens dieselbe Bedingung, 
> if ( (dm > 1) && (dm == 32) ) {
> if ( (dm > 1) && (dm == 32) ) {

während es früher Unterschiede waren:
> if ( (dm > 1) && (dm % 31 == 1) ) {
> if ( (dm > 1) && (dm % 30 == 1) ) {

wenn dir sowas nicht auffällt, wenn du das nicht überprüfst, ständig im Blick hast usw., dann nimm lieber das frühere mit % wie im ersten Posting,
das war zumindest bei den Bedingungen überall richtig, wie auch immer das geschafft wurde,

ich habe inzwischen gelernt und werde sicher keine weiteren derartigen Umformungen mehr vorschlagen..

-------

in der Hoffnung dass folgendes eher hilft als noch mehr verwirrt und kaputtmacht,
hier nun auch ein Tipp zur Ausgabe:

```
System.out.println("d: " + d + ", " + dm + ", " + dy + ", Monat: " + mon + ", " + jahr);
```
als erste Code-Zeile in die Schleife

Ausgabe dann z.B.

```
d: 1, 1, 1, Monat: 1, 2013
d: 2, 2, 2, Monat: 1, 2013
d: 3, 3, 3, Monat: 1, 2013
d: 4, 4, 4, Monat: 1, 2013
d: 5, 5, 5, Monat: 1, 2013
d: 6, 6, 6, Monat: 1, 2013
[..]
d: 25, 25, 25, Monat: 1, 2013
d: 26, 26, 26, Monat: 1, 2013
d: 27, 27, 27, Monat: 1, 2013
d: 28, 28, 28, Monat: 1, 2013
d: 29, 29, 29, Monat: 1, 2013
d: 30, 30, 30, Monat: 1, 2013
2013, Januar
d: 31, 31, 31, Monat: 1, 2013
d: 32, 32, 32, Monat: 1, 2013
d: 33, 33, 33, Monat: 2, 2013
d: 34, 34, 34, Monat: 2, 2013
d: 35, 35, 35, Monat: 2, 2013
d: 36, 36, 36, Monat: 2, 2013
```
da sieht man zumindest so ungefähr, dass nach mehr oder weniger 31 Tagen auf Monat 2 umgeschaltet wird, nicht schlecht,
in diesem Fall läuft noch dm weiter auf 32, 33, 34 usw., das müsste wieder 1, 2, 3 zählen

um zu wissen, wie die Ausgabe besser aussehen sollte braucht es natürlich einen Kopf der mitdenkt,
zuerst musst du wissen, was du an Ergebnissen erwartest,

aber wenn du mitdenken solltest, dann wäre diese Ausgabe eben ein gutes Mittel zu überprüfen, ob dm wieder mit 1, 2, 3 startet,
das ist wichtig!, versuche mal damit zurechtzukommen


----------



## discere (15. Nov 2012)

Hallo SlaterB,

Der Fall läuft gut noch dm weiter auf 32, 33, 34 usw.., danach wieder 1,2,3,... zählen. 
Genau wie:


> d: 1, 1, 1, Monat: 1, 2013
> d: 2, 2, 2, Monat: 1, 2013
> d: 3, 3, 3, Monat: 1, 2013
> d: 4, 4, 4, Monat: 1, 2013
> ...



Aber, For-Schleife zählt nicht weiter, nur bis 2013 mit Monate angeben... 
2014, 2015 ohne Monate angeben. 
Soll ich neu For-Schleife hinzufügen. Erfolglos!

Erste Code : 





> steht das 'dy = 1' doch auch in BEIDEN Fällen und nicht nur in einem...


Ich komme nicht weiter.. ich verstehe nicht was meinst du damit..


----------



## discere (15. Nov 2012)

```
public class Doublemoon {

public static boolean schaltjahr ( int jahr ) {
  if ( jahr % 4 == 0 ) {
    if ( (jahr % 100 == 0) && (jahr % 400 != 0) ) {
      return false;
    }
    return true;
  }

  return false;
}

public static void main ( String args [] ) {
  int num;
  int jahr = 2013; 
  int d; //day
  int dm = 1; //Tage Monate
  int vm = 0; //vollmond
  int mon;  //Monate
  int m; //
  int dy =1; // tag-Jahr
  int n; //Anzahl der Vollmonde in einem Monat
  

    num = 3;
  
  for(int i = 1;i < num; i++) {
      
  for ( d = 1 , m = 0, mon = 1, n = 0; true; d++, dm++, dy++) 
  { //Schaltjahr 
    if ( (dy > 1) && (dy % 365 == 1) && ! schaltjahr( jahr ) ) 
    {
      jahr++;
 
      System.out.println(+jahr);
      break;
    }

    if ( (dy > 1) && (dy % 366 == 1) && schaltjahr( jahr ) ) 
    { //keine Schaltjahr
      jahr++;
      
      //dy =1;
      System.out.println(+jahr);
      break;
    }

    if ( (dm > 1) && (dm % 31 == 1) ) { // dm == 32
      switch ( mon ) {
        case 1:     //January 31.
        case 3:     //March 31.
        case 5:     //May 31.
        case 7:     //July 31.
        case 8:     //August 31.
        case 10:    //October 31.
         mon ++;
         
         dm =1;
         //System.out.println(+mon);
            break;
        case 12:    //December 31. 
         mon = 1;
         dm =1;
         //System.out.println(+mon);
            break;
       
      }
    } 

    if ( (dm > 1) && (dm % 30 == 1) ) {
      switch ( mon ) {
          
        case 4:      //April 30.
        case 6:      //June 30.
        case 9:      //September 30.
        case 11:     //November 30.
          mon ++;
          dm =1;   
          break;
      }  
    } 

    if ( (dm > 1) && (dm % 28 == 1) && (mon == 2) && ! schaltjahr( jahr ) ) 
    {
      mon ++;
      dm ++; //Schaltjahr
      
      
    } 

    if ( (dm > 1) && (dm % 29 == 1) && (mon == 2) && schaltjahr( jahr ) ) 
    {
      mon ++; //keine Schaltjahr
      dm ++;
      
    } 

    if ( d % 29 == 1 ) {
      vm ++;
      if ( m == mon ) {
        n ++;
        if ( n <= num ) {
        
          System.out.print( jahr );
          switch ( mon ) {
            case 1:
              System.out.println( ", Januar" );
              break;
            case 2:
              System.out.println( ", Februar" );
              break;
            case 3:
              System.out.println( ", Maerz" );
              break;
            case 4:
              System.out.println( ", April" );
              break;
            case 5:
              System.out.println( ", Mai" );
              break;
            case 6:
              System.out.println( ", Juni" );
              break;
            case 7:
              System.out.println( ", Juli" );
              break;
            case 8:
              System.out.println( ", August" );
              break;
            case 9:
              System.out.println( ", September" );
              break;
            case 10:
              System.out.println( ", Oktober" );
              break;
            case 11:
              System.out.println( ", November" );
              break;
            case 12:
              System.out.println( ", Dezember" );
              break;
            }
          } 
        }
      
      m = mon;
      //dy++;
      
    } // end for
    
    //System.out.println("d: " + d + ", " + dm + ", " + dy + ", Monat: " + mon + ", " + jahr);
  } // End of main

  }
} // End of class 

}
```


----------



## SlaterB (15. Nov 2012)

puh, das ist ja inzwischen recht anders geworden, willst du das zwingend verfolgen?
ich gebe mal zunächst Tipps für die Variante ohne die neue äußere Schleife, die wieder weg

bei den Jahren fand ich es GUT, dass dort 'dy = 1' stand 
bitte wieder hin

dm veränderst du nun auch in allen Fällen in denen der Monat geändert wird, 
aber an zwei Stellen steht nur dm++; statt dm auf 1 zu setzen, 
welche ungünstigen Folgen das hat dürfte eigentlich klar sein, spätestens mit Log zu verfolgen, aber ich habe schon aufgegeben..

den Abbruch im else zu ' if ( n <= num ) {' hast du entfernt, und keinen neuen eingebaut,
dann läuft es ewig, baue dort wieder das else mit return; wie am Anfang rein

oder z.B. 
if (n >= num) break;
an fast schon beliebiger Stelle innerhalb der Schleife


----------



## discere (18. Nov 2012)

Hallo, 

Oh, habe ich hier schon geschrieben. Mein Beitrag wurde selbst nicht gespeichert.  

Ok, 

"den Abbruch im else zu ' if ( n <= num ) {' hast du entfernt, und keinen neuen eingebaut," habe ich nicht entfernt.. Aber welche Zeile???? Ich habe schon überprüft.. Kannst du Code zeigen. 


"if (n >= num) break;
an fast schon beliebiger Stelle innerhalb der Schleife " 
Das Program funktioniert nicht. Klappt nicht..


----------



## pappawinni (18. Nov 2012)

discere hat gesagt.:


> "if (n >= num) break;
> an fast schon beliebiger Stelle innerhalb der Schleife "
> Das Program funktioniert nicht. Klappt nicht..



Das sieht so aus, als wüsstest du nicht, was du da überhaupt machst.
Hast du dir mal in Pseudocode notiert, wie das Programm arbeiten soll?
Ein Struktogramm oder sowas ? Irgendwas..
Oder probierst du nur wild herum und hoffst irgendwann ein funktionierendes Programm zu haben?


----------



## SlaterB (18. Nov 2012)

discere hat gesagt.:


> "den Abbruch im else zu ' if ( n <= num ) {' hast du entfernt, und keinen neuen eingebaut," habe ich nicht entfernt.. Aber welche Zeile???? Ich habe schon überprüft.. Kannst du Code zeigen.


im ersten Posting war es Zeile 119-123,
im letzten Code kein return; mehr irgendwo in der main



> "if (n >= num) break;
> an fast schon beliebiger Stelle innerhalb der Schleife "
> Das Program funktioniert nicht. Klappt nicht..


zeige neuesten Code,
kannst du irgendwas selber zur Untersuchung beitragen, Ausgaben im Programm?


----------



## discere (18. Nov 2012)

Sieh unten:


----------



## discere (18. Nov 2012)

```
public class DDdoublemoon {

 
public static boolean schaltjahr ( int jahr ) {
  if ( jahr % 4 == 0 ) {
    if ( (jahr % 100 == 0) && (jahr % 400 != 0) ) {
      return false;
    }
    return true;
  }
 
  return false;
}
 
public static void main ( String args [] ) {
  int num;
  int jahr = 2013; 
  int d; //day
  int dm = 1; //Tage Monate
  int vm = 0; //vollmond
  int mon;  //Monate
  int m; //
  int dy =1; // tag-Jahr
  int n; //Anzahl der Vollmonde in einem Monat
  
 
    num = 4; //Integer.parseInt(args []);
  
 //for(int i = 1;i < num; i++) {

  
  for ( d = 1 , m = 0, mon = 1, n = 0; true; d++, dm++, dy++) 
  { //Schaltjahr 
    if ( (dy > 1) && (dy % 365 == 1) && ! schaltjahr( jahr ) ) 
    {
      jahr++;
      //dy++; 
     dy =1; //aaaaa
      //System.out.println(+jahr);
      //break;
    }
 
    if ( (dy > 1) && (dy % 366 == 1) && schaltjahr( jahr ) ) 
    { //keine Schaltjahr
      jahr++;
      dy =1; //aaaaaa
      //dy++; 
   
      //System.out.println(+jahr);
      //break;
    }

    if ( (dm > 1) && (dm % 31 == 1) ) { // dm == 32
      switch ( mon ) {
        case 1:     //January 31.
        case 3:     //March 31.
        case 5:     //May 31.
        case 7:     //July 31.
        case 8:     //August 31.
        case 10:    //October 31.
         mon ++;
         
         dm =1;
         //System.out.println(+mon);
            break;
        case 12:    //December 31. 
         mon = 1;
         dm =1;
         //System.out.println(+mon);
            break;
       
      }
    } 
 
    if ( (dm > 1) && (dm % 30 == 1) ) {
      switch ( mon ) {
          
        case 4:      //April 30.
        case 6:      //June 30.
        case 9:      //September 30.
        case 11:     //November 30.
          mon ++;
          dm =1;   
          break;
      }  
    } 
 
    if ( (dm > 1) && (dm % 28 == 1) && (mon == 2) && ! schaltjahr( jahr ) ) 
    {
      mon ++;
      dm ++; //Schaltjahr
      
      
    } 
 
    if ( (dm > 1) && (dm % 29 == 1) && (mon == 2) && schaltjahr( jahr ) ) 
    {
      mon ++; //keine Schaltjahr
      dm ++;
      
    } 
 
    if ( d % 29 == 1 ) {
      vm ++;
      if ( m == mon ) {
        n ++;
        if ( n <= num ) {
        
          System.out.print( jahr );
          switch ( mon ) {
            case 1:
              System.out.println( ", Januar" );
              break;
            case 2:
              System.out.println( ", Februar" );
              break;
            case 3:
              System.out.println( ", Maerz" );
              break;
            case 4:
              System.out.println( ", April" );
              break;
            case 5:
              System.out.println( ", Mai" );
              break;
            case 6:
              System.out.println( ", Juni" );
              break;
            case 7:
              System.out.println( ", Juli" );
              break;
            case 8:
              System.out.println( ", August" );
              break;
            case 9:
              System.out.println( ", September" );
              break;
            case 10:
              System.out.println( ", Oktober" );
              break;
            case 11:
              System.out.println( ", November" );
              break;
            case 12:
              System.out.println( ", Dezember" );
              break;
            }
          } else {
            return;
            
            }
        }
      
         m = mon;
         //dy++;
    } // end for
    
   
    //System.out.println("d: " + d + ", " + dm + ", " + dy + ", Monat: " + mon + ", " + jahr);
  } // End of main
 
  }
} // End of class 
 
//}
```

Das Ergebis kommt raus:

Januar 2013
September 2014
Mai 2016
Januar 2018
Oktober 2019


----------



## discere (18. Nov 2012)

System.out.println("d: " + d + ", " + dm + ", " + dy + ", Monat: " + mon + ", " + jahr)

Ich habe herausgefunden... 

d: 1067, 28, 9, Monat: 2, 2016
d: 1068, 29, 10, Monat: 2, 2016
d: 1069, 31, 11, Monat: 3, 2016
d: 1070, 1, 12, Monat: 4, 2016
d: 1071, 2, 13, Monat: 4, 2016

Maerz wurde einfach abgebrochen.. Warum? Andere Monate scheinen gut... ???:L


----------



## pappawinni (18. Nov 2012)

Deine Ergebnisse sind IMHO falsch.
Ich hab mal versucht zu verstehen, was du da machst und das dann auch mal bearbeitet.
Meine Lösung für Parameter 5:
2013, Januar
2014, Oktober
2016, Juni
2018, Januar
2018, Maerz


```
public class TwiceFullMoon {
	 
public static boolean schaltjahr ( int jahr ) {
  if ( jahr % 4 == 0 ) {
    if ( (jahr % 100 == 0) && (jahr % 400 != 0) ) {
      return false;
    }
    return true;
  }
 
  return false;
}
 
public static void main ( String args [] ) {
  int num = 1;     // geforderte Anzahl Monate wo der Vollmond seit Anfangspunkt 2mal eintritt
  int jahr = 2013; // aktuelles Jahr, Anfangspunkt 2013 
  int d = 1;       // altueller Tag seit Anfangsjahr
  int dm = 1;      // aktueller Tag des Monats
  int vm = 0;      // aktuelle Anzahl aufgetretene Vollmonde seit Anfangspunkt (unnötig)
  int mon = 1;     // aktueller Monat 
  int m = 0;       // vorangeganener Monat mit Vollmond
  int dy = 1;      // aktueller Tag des Jahres (unnötigt)
  int n = 0;       // aktuelle Anzahl an Monaten mit 2mal Vollmond seit Anfangspunkt
  boolean weitersuchen = true; 
 
  num = Integer.parseInt( args[ 0 ] );
 
  for ( d = 1 ; weitersuchen; d++, dm++, dy++) { 
	    if ( dm == 32 ) {
	        switch ( mon ) {
	          case 1:     //Tag nach January 31.
	          case 3:     //Tag nach March 31.
	          case 5:     //Tag nach May 31.
	          case 7:     //Tag nach July 31.
	          case 8:     //Tag nach August 31.
	          case 10:    //Tag nach October 31.
	              mon++;  // neuer Monat
	              dm = 1; // erster Tag des Monats
	              break;
	          case 12:    //Tag nach December 31.
	              jahr ++; // neues Jahr
	              dy = 1;  // erster Tag des Jahres (unnötig)
	              mon= 1;  // Januar
	              dm = 1; // erster Tag des Monats
	              break;
	        }
	    } 
	    if ( dm == 31 ) {
	        switch ( mon ) {
	          case 4:      //Tag nach April 30.
	          case 6:      //Tag nach June 30.
	          case 9:      //Tag nach September 30.
	          case 11:     //Tag nach November 30.
	            mon ++;    // neuer Monat
	            dm = 1;    // erster Tag des Monats
	            break;
	        }
	    } 
	    if ( dm == 30 && mon == 2 && schaltjahr( jahr ) ) {
	        // Tag nach 29.Februar und Schaltjahr 
	        mon ++; // neuer Monat
	        dm = 1; // erster Tag des Monats
	    } 
	    if ( dm == 29 && mon == 2 && ! schaltjahr( jahr ) ) {
	        // Tag nach 28.Februar aber kein Schaltjahr 
	        mon ++; // neuer Monat
	        dm = 1; // erster Tag des Monats
	    } 

	    if ( d % 29 == 1 ) {
	        vm ++; // unnötig
	        if ( m == mon ) {
	      	// das 2te mal Vollmond in diesem Monat
	          n ++;
	          if ( n <= num ) {
	            System.out.print( jahr );
	            switch ( mon ) {
	              case 1:
	                System.out.println( ", Januar" );
	                break;
	              case 2:
	                System.out.println( ", Februar" );
	                break;
	              case 3:
	                System.out.println( ", Maerz" );
	                break;
	              case 4:
	                System.out.println( ", April" );
	                break;
	              case 5:
	                System.out.println( ", Mai" );
	                break;
	              case 6:
	                System.out.println( ", Juni" );
	                break;
	              case 7:
	                System.out.println( ", Juli" );
	                break;
	              case 8:
	                System.out.println( ", August" );
	                break;
	              case 9:
	                System.out.println( ", September" );
	                break;
	              case 10:
	                System.out.println( ", Oktober" );
	                break;
	              case 11:
	                System.out.println( ", November" );
	                break;
	              case 12:
	                System.out.println( ", Dezember" );
	                break;
	            }
	          } else {
	              // geforderte Anzahl erreicht
	              weitersuchen = false;           
	          }
	        }
	        // Vollmond ist eingetreten, Monat merken
	        m = mon; // Monat des letzten Vollmonds = aktueller Monat
	    }
  

    } // end for
    
  } // End of main
 
} // End of class
```


----------

