Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

Ewiger Kalender (Unterprogramme)

Schreiben Sie ein Programm, das von einem gegebenen Datum im 21. Jahrhundert (vom 1. 1. 2001 bis 31. 12. 2100) den Wochentag bestimmt.
Dabei muss Folgendes beachtet werden:

  • Der 1. 1. 2001 war ein Montag.
  • Jedes durch 4 teilbare Jahr (in diesem Bereich) ist ein Schaltjahr mit 366 (statt 365) Tagen. Ausnahme: Das Jahr 2100 ist kein Schaltjahr!

Einfach zum Ziel kommen Sie, wenn Sie zunächst alle Jahre mit 365 Tagen, dann die Schalttage, weiter die Monate und zuletzt die Tage im Monat behandeln. Verwenden Sie die Subroutine aus Schaltjahre.

Zusatzaufgabe: Erweitern Sie das Programm so, dass es für alle Daten im Gregorianischen Kalender (ab 15. 10. 1582) funktioniert.

1 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

Kommentare (1)

hongkongfui 7. Mai 2020 10:53   reply report
der 29. 2. 2088 ist ein Sonntag

5 Lösung(en)

import java.util.Scanner;

/**
 * @author Philipp Gressly (phi@gressly.ch)
 */

public class Wochentag {
    public static void main(String[] args) {
        new Wochentag().start();
    }

    void start() {
        int j = einlesen("Jahr");
        int m = einlesen("Monat");
        int t = einlesen("Tag");
        int wotag = berechen(j, m, t);
        ausgabe(wotag);
    }

    /**
     * Berechne die Wochentagsnummer
     * 
     * @return 0: Montag, 1 Dienstag, ...
     */
    int berechen(int jahr, int monat, int tag) {
        int tagesNummer; // ab 1.1.2001
        int jahrAb2001 = jahr - 2001;
        tagesNummer = (jahrAb2001) * 365;
        // schalttage
        tagesNummer = tagesNummer + schalttage(jahrAb2001);
        if (jahrAb2001 >= 99) { // 2100 ist kein Schaltjahr
            tagesNummer = tagesNummer - 1;
        } 
        if (monat <= 2 && schaltjahr(jahr)) {
            tagesNummer = tagesNummer - 1;
        }
        tagesNummer = tagesNummer + tagImJahr(monat, tag) - 1;
        return tagesNummer % 7;
    }

    boolean schaltjahr(int jahr) {
        boolean schalt = false;
        if (0 == jahr % 4) {
            schalt = true;
        }
        if (0 == jahr % 100) {
            schalt = false;
        }
        if (0 == jahr % 400) {
            schalt = true;
        }
        return schalt;
    }

    /**
     * 1.1. = 1. Tag im Jahr
     */
    int tagImJahr(int monat, int tag) {
        int tageImMonat[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
        int monatsTage = 0;
        int aktMonatsIndex = 0; // januar
        while (aktMonatsIndex < monat - 1) {
            monatsTage = monatsTage + tageImMonat[aktMonatsIndex];
            aktMonatsIndex = aktMonatsIndex + 1;
        }
        return monatsTage + tag;
    }

    /**
     * Schalttage ab 2001
     */
    int schalttage(int jahrAb2001) {
        return (jahrAb2001 + 1) / 4;
    }

    /**
     * 0 = Montag, 1 = Dienstag, ...
     */
    void ausgabe(int wotag) {
        String tagesNamen[] = { "Montag", "Dienstag", "Mittwoch", "Donnerstag",
                "Freitag", "Samstag", "Sonntag" };

        System.out.println("Resultat: " + tagesNamen[wotag]);
    }

    int einlesen(String meldung) {
        Scanner sc = new Scanner(System.in);
        System.out.println("Geben Sie " + meldung + " ein: ");
        return sc.nextInt();
    }

} // end of class Wochentag                        
                
public class Main {

    int[] tageImMonat = { 31, 28, 31, 30, 31, 30,
                          31, 31, 30, 31, 30, 31 };
    String[] wochentage = { "Montag", "Dienstag", "Mittwoch",
                  "Donnerstag", "Freitag", "Samstag", "Sonntag" };

    public static void main(String[] args) {
        Main m = new Main( );

        String str = m.wochentag( 8, 10, 2009 );
        System.out.println( str );
    }

    public String wochentag( int tag, int monat, int jahr ) {
        int intervall;
        int deltaJahre, deltaMonate;

        if ( (monat > 12) || (tag > tageImMonat[monat-1]) ) {
            if ( !schaltjahr( jahr ) || (monat != 2) || (tag != 29) )
                return( "Ungültiges Datum" );
        }

        // Effekt der Jahre
        deltaJahre = jahr - 2001;
        intervall = deltaJahre * 365;
        intervall += deltaJahre / 4 - deltaJahre / 100 + deltaJahre / 400;
        // Negative tage bedeuten 'vor 2001', in welchem Fall wir
        // wegen vorangehender Zeile um einen Tag korrigieren müssen.
        if ( intervall < 0 )
            intervall--;

        // Effekt der Monate
        deltaMonate = monat - 1;
        for( int i = 0; i < deltaMonate; i++ )
            intervall += tageImMonat[i];
        if ( ( deltaMonate >= 2 ) && schaltjahr( jahr ) )
            intervall++;

        // Effekt der Tage
        intervall += tag - 1;

        // Etwas kompliziert formuliert, um intervall >= 0 zu garantieren
        intervall = ( (intervall%7) + 7 ) % 7;

        return wochentage[intervall];
    }
    
    private boolean schaltjahr( int jahr ) {
        return( ( jahr%4 == 0 ) && ( ( jahr%100 != 0 ) || ( jahr%400 == 0 ) ) );
    }

}

                
tage_monat = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
wochentage = [ "Montag", "Dienstag", "Mittwoch","Donnerstag", "Freitag", "Samstag", "Sonntag" ]

def schaltjahr(jahr):
    schalt = False
    if (jahr%4 == 0):
        schalt = True
        if (jahr%100 == 0):
            schalt = False
            if (jahr%400 == 0):
                schalt = True
    return schalt

def naechsterTag(datum):
     if datum[0] < tage_monat[datum[1]-1]:
         datum[0] +=1
     else:
        if (datum[0]==28 and datum[1]==2 and schaltjahr(datum[2])):
            datum[0] +=1
        else:
            if datum[1] < 12:
                datum[1] +=1
                datum[0] =1
            else:
                datum[2] +=1
                datum[1] =1
                datum[0] =1
     return datum


def wochenTag(tag,monat,jahr):
    if ( (monat > 12) or (tag > tage_monat[monat-1]) ):
        if ( not schaltjahr( jahr ) or (monat != 2) or (tag != 29) ):
            return "Ungueltiges Datum"
# Gregorianischer Kalender Freitag 15. Oktober 1582
    count =0
    # folglich war der 18 Oktober der erste Montag im neuen Kalender
    datum =[18,10,1582]
    datumend = [tag,monat,jahr]
    while (datum[2] < jahr or datum[1] < monat or datum[0] < tag):
        datum = naechsterTag(datum)
        count +=1  
    w = count % 7
    return w


print 'der 20.9.1583 war ein ' + str(wochentage[wochenTag(20,9,1583)])
print 'der 29.2.2004 war ein ' + str(wochentage[wochenTag(29,2,2004)])
print 'der 25.5.2007 war ein ' + str(wochentage[wochenTag(25,5,2007)])
print 'der 25.5.2525 wird ein ' + str(wochentage[wochenTag(25,5,2525)])

                
# Wer im Kopf den Ewigen Kalender rechnen will, braucht sich
# lediglich die folgede Tabelle auswendig zu lernen ...:
               #jan, feb, mar, apr, mai, jun, jul, aug, sep, okt, nov, dez
$monatsReste = [  5,   1,   1,   4,   6,   3,   4,   0,   3,   5,   1,   3]
# ... und danach die siebnerreste zusammenzuzählen


def schaltjahr(jahr) 
  if(0 == jahr % 400)                    then return true  end
  if((0 == jahr % 100) && (jahr > 1582)) then return false end
  0 == jahr % 4
end

# 0 = Montag, 1=Dienstag, ...
# jahr monat tag von 1.1.2001 - 31. 12. 2100
def wochentag(jahr, monat, tag)
  # Jahr:
  siebnerrest  =  (jahr - 2000)
  #2100 (jahrhundertkorrektur)
  siebnerrest = siebnerrest - (jahr / 100 - 20)

  # Schaltjahre: 
  siebnerrest += ((jahr - 2000) / 4 ) 
  # Schaltjahrkorrektur Januar, Februar
  if(schaltjahr(jahr))
    if(monat < 3) 
      siebnerrest = siebnerrest + 6
    end
  end

  # Monat:
  siebnerrest += $monatsReste[monat - 1] # jan = 0 in list   

  # Tag: 
  siebnerrest += tag

  return siebnerrest % 7
end

                

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

monate = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
wochentag = {0: "Montag", 1: "Dienstag", 2: "Mittwoch", 3: "Donnerstag", 4: "Freitag", 5: "Samstag", 6: "Sonntag"}

while True:
    eingabe = input("Geben Sie ein Datum [TT.MM.JJJJ] ein: ")
    datum = eingabe.split('.')
    tag = int(datum[0])
    monat = int(datum[1])
    jahr = int(datum[2])
    if jahr < 1582 or (monat < 10 and jahr == 1582) or (tag < 15 and monat == 10 and jahr == 1582):
        print("Ungültiges Datum!")
    else:
        break


def schaltjahr(jahr):
    if (jahr % 400) == 0 or ((jahr % 4) == 0 and (jahr % 100) != 0):
        return 1
    else:
        return 0


def summeTageGregor(datum):
    summe = 0
    for i in range(1582, jahr):
        summe += 365 + schaltjahr(i)
    for i in range(0, monat - 1):
        summe += monate[i]
    summe += tag - 1
    if monat > 2:
        summe += schaltjahr(jahr)
    return summe


rest = (summeTageGregor(datum) + 4) % 7     # +4 für Anpassung auf Wochentag(Freitag) von Startdatum 15.10.1582
print("Der", eingabe, "ist/war ein", wochentag[rest])
                

Lösung von: Peter Pan (Home Office)

Verifikation/Checksumme:

  • 1. 1. 2001: Montag
  • 31. 12. 2001: Montag
  • 10. 12. 2037: Donnerstag
  • 29. 2. 2088: Dienstag
  • 1. 3. 2100: Montag

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit: 2
Schwierigkeit: k.A.
Webcode: m2g9-636g
Autor: Stefan Dürrenberger (IDM Studios GmbH)

Download PDF

Download ZIP

Zu Aufgabenblatt hinzufügen