[HaBo]

[delphi]
program Project2;

{$APPTYPE CONSOLE}

var
  d, m: Byte;
  y, e: Word;
  w: Char;


const
  DayOfWeekStr: Array[0..6] of String = (
    'Monday',
    'Tuesday',
    'Wednesday',
    'Thursday',
    'Friday',
    'Saturday',
    'Sunday'
  );

function IsLeapYear(const Year: Word): Boolean;
begin
  Result := ( Year mod 4 ) = 0;
end;

function ElapsedDaysWithinAYear(const D, M: Byte; const Y: Word): Word;
var
  i: Integer;
  LeapYear: Boolean;
begin
  Result := 0;
  if not( D in [1..31] ) or not( M in [1..12] ) then
    Exit;
  LeapYear := IsLeapYear( Y );
  for i := 1 to M - 1 do
    if i mod 2 = 1 then
    begin
      if i < 8 then
        inc( Result, 31 )
      else
        inc( Result, 30 );
    end else
    if ( i = 2 ) then
    begin
      if LeapYear then
        inc( Result, 29 )
      else
        inc( Result, 28 );
    end else
      if i < 8 then
        inc( Result, 30 )
      else
        inc( Result, 31 );
  inc( Result, D );
end;

function ElapsedDays(const fromDay, fromMonth: Byte; const fromYear: Word;
  const toDay, toMonth: Byte; const toYear: Word): DWord;
var
  i: Integer;
begin
  Result := 0;
  if fromYear = toYear then
    Result := ElapsedDaysWithinAYear( toDay, toMonth, toYear ) -
      ElapsedDaysWithinAYear( fromDay, fromMonth, toYear )
  else
  begin
    for i := fromYear+1 to toYear-1 do
      inc( Result, ElapsedDaysWithinAYear( 31, 12, i ) );
    inc( Result, ElapsedDaysWithinAYear( 31, 12, fromYear ) -
      ElapsedDaysWithinAYear( fromDay, fromMonth, fromYear ) );
    inc( Result, ElapsedDaysWithinAYear( toDay, toMonth, toYear ) );
  end;
end;

function WeekCount(const Days: Word): Byte;
begin
  Result := Days div 7;
end;

function DayOfWeek(const D, M: Byte; const Y: Word): String;
var
  DaysPassedBySince1Jan1900: DWord;
begin
//  1 Jan 1900 was a Monday.
  DaysPassedBySince1Jan1900 := ElapsedDays( 1, 1, 1900, D, M, Y );
  Result := DayofWeekStr[(DaysPassedBySince1Jan1900-1) mod 7];
end;

begin
  repeat
    Writeln( 'Input: Day Month Year' );
    Readln( d, m, y );
    e := ElapsedDaysWithinAYear( d, m, y );
    if e <> 0 then
      Writeln( 'Elapsed days: ', e, ' (as weeks: ', DaysAsWeeks( e ), ')' )
    else
      Writeln( 'Error!' );
    Write( 'Again? [j/n] ' );
    Read( w );
    Writeln;
  until w <> 'j';
  readln;
end.
[/delphi]

Input: Day Month Year
18 02 2011
Elapsed days: 49 (as weeks: 7)
Again? [j/n]

package ch.slowy.days;

public class CalculateDays {
    private static int[] amountOfDaysPerMonth;

    static {
        // I am Lazy... declare in static block
        amountOfDaysPerMonth = new int[12];
        amountOfDaysPerMonth[0] = 31;
        amountOfDaysPerMonth[1] = 28;
        amountOfDaysPerMonth[2] = 31;
        amountOfDaysPerMonth[3] = 30;
        amountOfDaysPerMonth[4] = 31;
        amountOfDaysPerMonth[5] = 30;
        amountOfDaysPerMonth[6] = 31;
        amountOfDaysPerMonth[7] = 31;
        amountOfDaysPerMonth[8] = 30;
        amountOfDaysPerMonth[9] = 31;
        amountOfDaysPerMonth[10] = 30;
        amountOfDaysPerMonth[11] = 31;
    }

    public static int calculateDays(int[] splittedDate) {
        int amountOfDays = 0;
        for (int i = 0; i < splittedDate[1] - 1; i++) {
            amountOfDays += amountOfDaysPerMonth[i];
        }
        amountOfDays += splittedDate[0];
        if (isLeapYear(splittedDate[2])) {
            amountOfDays++;
        }
        return amountOfDays;
    }

    public static boolean isValidDate(String inDate) {
        return inDate
                .matches("(0[1-9]|1[0-9]|2[0-9]|3[01])\\.(0[0-9]|1[012])\\.\\d+");
    }

    public static int[] splitDate(String arg) {
        int[] returnValue = new int[3];

        boolean errorOccured = false;

        String[] splitted = arg.split("\\.");

        // the defined date pattern has three values
        if (splitted.length != 3) {
            errorOccured = true;
        } else {
            try {
                for (int i = 0; i < returnValue.length; i++) {
                    returnValue[i] = Integer.valueOf(splitted[i]);
                }
            } catch (NumberFormatException e) {
                errorOccured = true;
            }
        }

        if (errorOccured) {
            System.out.println("Unable to split argument " + arg);
            System.exit(1);
        }

        return returnValue;

    }

    public static boolean isLeapYear(int year) {
        return year % 400 == 0 || (year % 4 == 0 && year % 100 != 0);
    }
}

 package ch.slowy.days;

import junit.framework.TestCase;

public class TestCalculateDays extends TestCase {
    public void testIsLeapYear() {
        assertTrue(CalculateDays.isLeapYear(2000));
        assertFalse(CalculateDays.isLeapYear(2001));
        assertFalse(CalculateDays.isLeapYear(2002));
        assertFalse(CalculateDays.isLeapYear(2003));
        assertTrue(CalculateDays.isLeapYear(2004));
        assertFalse(CalculateDays.isLeapYear(2005));
        assertFalse(CalculateDays.isLeapYear(2006));

        assertTrue(CalculateDays.isLeapYear(2400));
        assertTrue(CalculateDays.isLeapYear(2800));
    }

    public void testIsValidDate() {
        assertTrue(CalculateDays.isValidDate("01.01.2010"));
        assertTrue(CalculateDays.isValidDate("02.01.2011"));
        assertTrue(CalculateDays.isValidDate("03.01.2012"));
        assertTrue(CalculateDays.isValidDate("04.01.1999"));
        assertTrue(CalculateDays.isValidDate("05.01.1322"));
        assertTrue(CalculateDays.isValidDate("06.01.1764"));
        assertTrue(CalculateDays.isValidDate("07.02.1955"));
        assertFalse(CalculateDays.isValidDate("32.01.1900"));
        assertFalse(CalculateDays.isValidDate("00.01.0199"));
    }
    
    public void testCalculateDays(){
        assertEquals(224, CalculateDays.calculateDays(CalculateDays.splitDate("12.08.2005")));
    }
}

#!/usr/bin/env ruby

day, month, year = ARGV[0].split(/\./)
day = day.to_i; month = month.to_i; year = year.to_i

(year % 4 == 0 && year % 100 != 0) || year % 400 == 0 ? is_leap_year = true : is_leap_year = false
months = [31,28,31,30,31,30,31,31,30,31,30,31]

begin
  raise if (day > months[month-1] && !(is_leap_year == true && month == 2 && day == months[month-1] + 1))
  raise if (day <= 0 || month > 12 || month <= 0 || year < 0) 
rescue
  puts "Kein korrektes Datum"
  exit
end

days = 0
(month-1).times { |i| days += months[i] }
days += day

days += 1 if is_leap_year == true && month > 2

puts "Anzahl Tage: #{days}"