Tage seit Jahresanfang berechnen

Wird vermutlich nicht ganz funktionieren, nur so ungefähr:

int tage_seit_jahresanfang(int tag, int monat, int jahr){


    int tage_pro_monat[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};


    int ret = 0;


    // Volle Monate
    for (int i = 1; i < monat; i++){
      ret += tage_pro_monat[i - 1];
    }


    // Tag des aktuellen Monats
    ret += tag;


    // Schaltjahr
    ret += (ist_schaltjahr(jahr) == true && monat > 2 ? 1 : 0);


    return ret;
}


bool ist_schaltjahr(int jahr){


    bool schaltjahr = false;


    if (jahr % 4 == 0) schaltjahr = true;
    if (jahr % 100 == 0) schaltjahr = false;
    if (jahr % 400 == 0) schaltjahr = true;


    return schaltjahr;
}

Zitat von Matt_informatic

Wie funktioniert das mit den Tagen den Monaten zuweisen?

Ich dachte eventuell, das ich 30 Tage als a, 31 Tage als b, 28 Tage als c definieren.

Ich verstehe nicht ganz was du meinst. Wenn du einfach die Variablen a = 31, b = 30 und c = 28 anlegst, dann fehlt dir die Zuordnung welches Monat nun wie viele Tage hat. Ich hab einfach ein Array mit 12 Einträgen gemacht, wo für jedes Monat gespeichert ist wie viele Tage es hat.

Natürlich gibt es noch andere Möglichkeiten.

Zitat von Matt_informatic

Ah, verstehe, muss dann erstmal 12 Variablen mit Werten belegen.
Im Struktogramm hätte ich dann erstmal 12 Aktionsfelder. Oder?
Also:
----------------------------
| Eingabe: Tag, Monat, Jahr |
----------------------------
| Monat[0] = 31 |
----------------------------
| Monat[1] = 28 |
----------------------------
| Monat[2] = 31 |
----------------------------
usw.

Alles anzeigen

Ja. Obwohl ich da stattdessen einfach nur ein Aktionsfeld machen und verbal reinschreiben würde dass das Array gefüllt wird.

Zitat von Matt_informatic

Nach der Datumseingabe mache ich dann erstmal die Prüfung, ob Schaltjahr.

Wie funktioniert, vom Prinzip (Struktogramm) das aufaddieren der Monate?

Ich schätze mal, das das in einer Schleife gemacht wird.

Wenn ich z.B. den 20.10.2007 eingebe, dann würde die Schleife von 1 bis 09 gehen.
Im nächsten Schritt noch die 20 Tage vom Oktober dazu addieren.

Genau.

Zitat von Matt_informatic

Aber diese Schleife an sich komme ich noch nicht klar.

Wieso? Du hast es eh richtig erklärt.

Zitat von Jensi

C

#include <stdio.h>
#include <time.h>


int main(int argc, char *argv[]) {
        struct tm *tptr;
        time_t    now;


        now = time(NULL);
        tptr = localtime(&now);


        printf("%i\n", tptr->tm_yday);


        return 0;
}

Alles anzeigen

... zum vergleich, in java würde das so ausschaun:

Calendar cal = Calendar.getInstance();
cal.set(Calendar.YEAR, 2007);
cal.set(Calendar.MONTH, 2);
cal.set(Calendar.DAY_OF_MONTH, 3);
int result = cal.get(Calendar.DAY_OF_YEAR);

Zitat von Matt_informatic

Hi,

ich stehe auf dem Schlauch.

Z.B. will ich berechenen, der wievielte Tag des Jahres ist der 3.2.07.
Klar, Januar hat 31 Tag + 2 Tage für den Februar.

Aber wie setze ich das in ein Struktogramm oder C/C++-Programm um?

Irgendwie muss ich ja erstmal definieren, auch wenn ich weiß wieviel Tage welcher Monat hat, welcher Monat wieviel Tage hat.

Auch muss ich das Schaltjahr berücksichtigen.

Wie mache ich das?

Wie fange ich an?

Ich weiß noch nicht, wie ich das umsetzen kann.

Danke für Tipps und Infos.

Gruß
Matt_informatic

Alles anzeigen

Am einfachsten loest man ein schwieriges Problem, indem man es in mehrere einfache Probleme aufteilt. Ein guter Weg das zu tun ist die sogenannte "Top-Down" Methode: Du loest das Problem erstmal ganz oberflaechlich und kuemmerst Dich dann erst um die Details.

In deinem Fall gibt es z.B. einiges zu beachten, und du hast ja auch eingies aufgezaehlt. Wieviele Tage hat ein Monat? Wie behandele ich ein Schaltjahr?

Aber wenn Du die ganzen Details erstmal weglaesst, dann ist das Problem gar nicht mehr so schwer:

Programm: berechne_tage_im_jahr
Input: monat, tage, jahr


Ergebnis: tage_bis_zum_monat(monat) + tage

Das war einfach. Wenn Du daraus ein Struktogramm machst, dann besteht das nur aus einem oder zwei Kaestchen und fertig. Und das Programm ist auch voellig korrekt, es fehlen halt nur noch ein paar Details.

Schauen wir das naechste Problem an: Gegeben ist ein Monat, und wir wollen wissen, wie viele Tage bis dahin vergangen sind:

Programm: tage_bis_zum_monat
Input: monat


tage = 0
ein_frueherer_monat = 1
solange ein_frueherer_monat < monat:
		tage = tage + tage_des_monats(monat)
		ein_frueherer_monat = ein_frueherer_monat + 1


Ergebnis: tage

So, das waehre auch geschafft. Ein Program, das die tage bis zu einem bestimmten Monat berechnet. Bastel daraus wieder ein Struktogramm. Das schaut ein wenig komplizierter aus als das Erste, ist aber immer noch recht einfach zu verstehen.

Dein Professor ist jetzt aber vermutlich noch nicht gluecklich, denn wir haben bis jetzt einfach angenommen, das es ein Programm 'tage_des_monats' gibt, das als Input einen Monat bekommt und als Ergebnis die Anzahl der Tage ausgibt.

Also lass uns dieses Programm einfach mal schreiben:

Programm: tage_des_monats
Input: monat


wenn monat = 1 dann Ergebnis: 31
wenn monat = 2 dann Ergebnis: ?
wenn monat = 3 dann Ergebnis: 31
wenn monat = 4 dann ....

Moment: Was machen wir mit dem Februar? Da war ja noch die Sache mit dem Schaltjahr... Um das Schaltjahr zu berechnen, brauchen wir wohl das Jahr, in dem wir uns gerade befinden. Das Jahr hatten wir ja in unserem Programm 'berechne_tage_im_jahr' mal als Input bekommen. Aber bis jetzt haben wir es niemals gebraucht. Jetzt brauchen wir es aber doch, also aendern wir unsere bisherigen Programme von oben so, das jeweils auch das Jahr als input mitgegeben wird:

Programm: berechne_tage_im_jahr
Input: monat, tage, jahr


Ergebnis: tage_bis_zum_monat(monat[B], jahr[/B]) + tage

Programm: tage_bis_zum_monat
Input: monat[B], jahr[/B]


tage = 0
ein_frueherer_monat = 1
solange ein_frueherer_monat < monat:
		tage = tage + tage_des_monats(monat[B], jahr[/B])
		ein_frueherer_monat = ein_frueherer_monat + 1


Ergebnis: tage

Jetzt koennen wir auch die Tage fuer den Monat Februar berechnen:

Programm: tage_des_monats
Input: monat, jahr


wenn monat = 1 dann Ergebnis: 31
wenn monat = 2 dann Ergebnis: tage_im_februar(jahr)
wenn monat = 3 dann Ergebnis: 31
...

Programm: tage_im_februar
Input: jahr
 wenn ist_ein_schaltjahr(jahr) = WAHR dann 
 	  Ergebnis: 29
 sonst:
	  Ergebnis: 28

Juhu, fast geschafft! Jetzt fehlt nur noch ein einziges, letztes Programm:

Programm: ist_ein_schaltjahr
Input: jahr


schaltjahr = FALSCH


wenn zahl_teilbar_durch(jahr, 4) dann schaltjahr = WAHR
wenn zahl_teilbar_durch(jahr, 100) dann schaltjahr = FALSCH
wenn zahl_teilbar_durch(jahr, 400) dann schaltjahr = WAHR


Ergebnis: schaltjahr

Natuerlich koenntest Du jetzt auch noch ein Programm 'zahl_teilbar_durch' schreiben, darin wieder ein Programm aufrufen, und so weiter und so fort. Tatsaechlich geht das fast beliebig weit. Aber fuer die Aufgabenstellung sollte das jetzt ersteinmal genug sein.

Anstatt also ein einziges, kompliziertes Programm zu schreiben, haben wir 5 einfache Probleme geloest. Diese 5 einfachen Programme sind fuer sich viel besser zu verstehen, noch dazu koenntest Du ein Programm wie z.B. 'tage_des_monats' auch in einer anderen Aufgabenstellung wiederverwenden.

Du kannst die 5 Programme entweder als 5 Struktogramme aufmahlen, und alle gemeinsam abgeben (das wuerde man in der Praxis so machen), oder, wenn Deine Aufgabe lautet, dass Du nur ein einziges Struktogramm abgeben darfst, dann kannst Du auch die einzelnen Programme zu einem einzigen zusammenfuegen. Dazu musst du nur die Programmaufrufe in den Struktogrammen durch die Struktogramme selbst ersetzen.

Wie schon zu Beginn gesagt: Diese Art und Weise an ein Programm heranzugehen, nennt man Top-Down Strategie, weil man das Programm erst wie aus der Vogelperspektive betrachtet, und dann schrittweise naeher ins Detail hinabsteigt. Das Aufteilen des Problems in viele kleine, moeglichst unabhaengige Teile, nennt man modulares Programmieren, und der Ueberbegriff fuer all diese Konzepte ist Abstraktion.

Zitat von Jensi

C

#include <stdio.h>
#include <time.h>


int main(int argc, char *argv[]) {
        struct tm *tptr;
        time_t    now;


        now = time(NULL);
        tptr = localtime(&now);


        printf("%i\n", tptr->tm_yday);


        return 0;
}

Alles anzeigen

Zitat von concealer

... zum vergleich, in java würde das so ausschaun:

Code

Calendar cal = Calendar.getInstance();
cal.set(Calendar.YEAR, 2007);
cal.set(Calendar.MONTH, 2);
cal.set(Calendar.DAY_OF_MONTH, 3);
int result = cal.get(Calendar.DAY_OF_YEAR);

Weil wir ja jetzt mit Implementierungen um uns werfen (wieso eigentlich?): So schaut's in Ruby aus:

Time.mktime(jahr, monat, tag).yday

Zitat von concealer

... zum vergleich, in java würde das so ausschaun:

Code

Calendar cal = Calendar.getInstance();
cal.set(Calendar.YEAR, 2007);
cal.set(Calendar.MONTH, 2);
cal.set(Calendar.DAY_OF_MONTH, 3);
int result = cal.get(Calendar.DAY_OF_YEAR);

Nein.

Zitat von Matt_informatic

christof R.
[quote]
Wieso? Du hast es eh richtig erklärt.
[\quote]
Jensi und concealer
Danke für den Code, aber den verstehe ich noch nicht. Dazu komme ich erst noch.
Aber irgendwie entdecke ich da keine Schleife. *seufz*

Alles anzeigen

die beispiele haben standardfunktionen von c++ bzw. java verwendet, die das, was du selbst programmieren willst, schon können. hilft dir in dem fall nix weil dus ja selbst implementieren willst, aber es schadet auch nix hab schon oft genug selber unnötige sachen geschrieben die eh irgendwelche standard libaries viel besser können...