Programmieren lernen

/**
 * Freitag der 13
 * 
 * @author Philipp Gressly (phi@gressly.ch)
 */
/*
 * History: first Implementation: Jan 5, 2010
 */
public class Freitag13 {

    // Java Starter
    public static void main(String[] args) {
        new Freitag13().top();
    }

    // 0 = montag, 1 = dienstag, ..., 6 = sonntag
    int[] dreizehnte  = new int[7]; 

    int aktTagImMonat      =    1;   // end: 31
    int aktMonat           =    1;   // end: 12
    int aktJahr            = 1600;   // end: 1999
    
    int aktuellerWochentag =    5;   // 5: Samstag 1. 1. 1600

    void top() {
        if (!sind400JahreDurchSiebenteilbar()) {
            System.out.println("Leider nicht mit dieser Methode berechenbar!");
            return;
        }
        System.out.println("Durch 7 teilbar, also weiter...");
        while (!endDatumErreicht()) {
            if (13 == aktTagImMonat) {
                dreizehnte[aktuellerWochentag]++;
            }
            erhoeheDatumUmEinenTag();
            erhoeheAktuellenWochentag();
        }
        ausgabeAlleDreizehnte();
    }

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

    void erhoeheAktuellenWochentag() {
        aktuellerWochentag = aktuellerWochentag + 1;
        if (7 == aktuellerWochentag) {
            aktuellerWochentag = 0;
        }
    }

    void ausgabeAlleDreizehnte() {
        String[] woTagsNamen = { "Montag", "Dienstag", "Mittwoch",
                "Donnerstag", "Freitag", "Samstag", "Sonntag" };
        for (int i = 0; i < 7; i++) {
            System.out.println(this.dreizehnte[i] + " mal fällt der "
                    + woTagsNamen[i] + " auf den 13. des Monats.");
        }

    }

    void erhoeheDatumUmEinenTag() {
        aktTagImMonat = aktTagImMonat + 1;
        if (aktTagImMonat > letzteTagNummerImAktuellenMonat()) {
            aktTagImMonat = 1;
            aktMonat = aktMonat + 1;
        }
        if (13 == aktMonat) {
            aktJahr = aktJahr + 1;
            aktMonat = 1;
        }
    }

    int letzteTagNummerImAktuellenMonat() {
        // Monate ab 1 nummeriert.
        int[] TAGE_IM_MONAT = { 0, 31, 28, 31, 30, 31, 30, 31,
                31, 30, 31, 30, 31 };
        if (2 != aktMonat) {
            return TAGE_IM_MONAT[aktMonat];
        }
        int schalttag = 0;
        if (this.schaltjahr(aktJahr)) {
            schalttag = 1;
        }
        return TAGE_IM_MONAT[2] + schalttag;
    }

    boolean endDatumErreicht() {
        return 1999 == aktJahr  &&
               12   == aktMonat &&
               31   == aktTagImMonat;
    }

    // Vergehen vom 1.1.1600 bis zum 1.1.2000 eine durch 7 teilbare Anzahl Tage?
    boolean sind400JahreDurchSiebenteilbar() {
        int totalTage = 365 * 400;
        totalTage = totalTage + (400 / 4); // Schaltjahre
        totalTage = totalTage - 3; // 100ter sind Keine Schaltjahre
        System.out.println("Total " + totalTage + " sind in 400 Jahren.");
        return totalTage / 7 * 7 == totalTage;
    }

} // end of class Freitag13
                

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 vierhundertJahrePruefen(aktJahr):
    sum =0
    for i in range(400):
        if (schaltjahr(aktJahr+i)):
            sum=sum+366
        else:
            sum=sum+365
    return (0 == sum % 7)

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


def freitageZaehlen(tag,monat,jahr):
    if not vierhundertJahrePruefen(jahr):
        print ''
        return False

    #End Datum berechen
    if tag == 1:
        if monat ==1:
            endtag = 31
            endmonat = 12
            endjahr = jahr + 399
        else:
            endtag = tage_monat[monat-1]
            enmonat = monat-1
            endjahr = jahr + 400
    else:
        endtag = tag-1
        endmonat = monat
        endjahr = jahr+400

    f =[0]*7
    datum=[tag,monat,jahr]
    enddate =[endtag,endmonat,endjahr]
    # Wochentag des Start berechen
    wtag = wochenTag(tag,monat,jahr)
    
    while (datum[2]<enddate[2] or datum[1]<enddate[1] or datum[0] < enddate[0]): 
        if datum[0] == 13:
            f[wtag] +=1
        wtag +=1
        wtag = wtag % 7
        datum = naechsterTag(datum)

    print 'Freitag der 13. kommt in 400 Jahren wie folgt vor:'
    for w in range (7):
        if (len(wochentage[w])<8):
               tab = '\t\t'
        else:
               tab = '\t'
        print wochentage[w]+tab+str(f[w])+' Mal'



freitageZaehlen(1,1,1600)

                

/*------------------------------------*\
|* eine enttäuschung für jeden        *|
|* kalenderberechnungsfetischisten,   *|
|* dafür hab ich den nachmittag frei. *|
\*------------------------------------*/

let days = [0, 0, 0, 0, 0, 0, 0];

for (let y = 1600; y <= 1999; y++)
  for (let m = 0; m <= 11; m++)
    days[new Date(y, m, 13).getDay()]++;

// ausgabe
console.log(`Montag, der 13.: ....... ${days[1]}`);
console.log(`Dienstag, der 13.: ..... ${days[2]}`);
console.log(`Mittwoch, der 13.: ..... ${days[3]}`);
console.log(`Donnerstag, der 13.: ... ${days[4]}`);
console.log(`Freitag, der 13.: ...... ${days[5]}`);
console.log(`Samstag, der 13.: ...... ${days[6]}`);
console.log(`Sonntag, der 13.: ...... ${days[0]}`);

                

Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)

// NET Core 3.x

using System;
using System.Linq;

namespace CS_Aufgabe_Freitag_13
{
    class Program
    {
        static void Main(string[] args)
        {
            var arr = new int[Enum.GetValues(typeof(DayOfWeek)).Length];
            var start = new DateTime(1600, 1, 13);
            var end = new DateTime(1999, 12, 13);

            while (start <= end)
            {
                arr[(int)start.DayOfWeek]++;
                start = start.AddMonths(1);
            }

            foreach (int v in Enum.GetValues(typeof(DayOfWeek)))
                Console.WriteLine($"{ Enum.GetName(typeof(DayOfWeek), v), -10 }: { arr[v] }");

            Console.WriteLine($"\nMaximum: { Enum.GetName(typeof(DayOfWeek), arr.ToList().IndexOf(arr.Max())) }");
        } 
    } 
}
                

Lösung von: Jens Kelm (@JKooP)