Programmieren lernen

// NET 6.0 | C# 10.x | VS 2022

for (int y = 2001; y < 2023; y++) {
    var c = y.ToString().OrderBy(x => x);
    var s = new DateTime(y, 1, 1);
    while (s < new DateTime(y, 12, 31)) {
        if (c.SequenceEqual(s.ToShortDateString().Replace(".", "")[..4].OrderBy(x => x)))
            Console.WriteLine(s.ToShortDateString());
        s = s.AddDays(1);
    }
}
                

Lösung von: Jens Kelm (@JKooP)

function permute(arr) {
  var length = arr.length,
      result = [arr.slice()],
      c = new Array(length).fill(0),
      i = 1, k, p;
  while (i < length) {
    if (c[i] < i) {
      k = i % 2 && c[i];
      p = arr[i];
      arr[i] = arr[k];
      arr[k] = p;
      ++c[i];
      i = 1;
      result.push(arr.slice());
    } else {
      c[i] = 0;
      ++i;
    }
  }
  return result;
}

function isPlausibleDate(y, m, d) {
  let p = new Date(y, m, d);
  if (
    p.getFullYear() == y &&
    p.getMonth() == m &&
    p.getDate() == d
  ) return true;
  return false;
}

function getWeddingDates(year) {
  let dates = permute(year.toString().split('')),
      out = [];
  for (let x = 0; x < dates.length; x++) dates[x] = dates[x].join('');
  dates = new Set(dates);
  dates.forEach(function(value) {
    let m = value.substr(0,2),
        d = value.substr(2);
    if (isPlausibleDate(year, m, d)) out.push(new Date(year, m, d));
  });
  return out;
}

// main
let result = [];
for (let i = 2001; i <= 2013; i++) result.push(getWeddingDates(i));
console.log(result);

                

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

' VBA-Funktion

Function GetArrayFromString(ByVal s As String)
    Dim arr()
    Dim i As Integer
    
    For i = 1 To Len(s)
        ReDim Preserve arr(i - 1)
        arr(i - 1) = Mid(s, i, 1)
    Next
    
    GetArrayFromString = arr
    
End Function

Function GetSortedArray(arr As Variant)
    Dim i As Long, k As Long
    Dim tmp As Variant
    
    For i = LBound(arr) To UBound(arr) - 1
        For k = i + 1 To UBound(arr)
            If UCase(arr(i)) > UCase(arr(k)) Then
                tmp = arr(k)
                arr(k) = arr(i)
                arr(i) = tmp
            End If
        Next k
    Next i
    
    GetSortedArray = arr
    
End Function

Function GetArrayComparision(left As Variant, right As Variant)
    Dim cmp As Boolean
    Dim i As Integer
    
    cmp = True
    If UBound(left) <> UBound(right) Then
        cmp = False
        Exit Function
    End If
    
    For i = LBound(left) To UBound(left)
        If left(i) <> right(i) Then
            cmp = False
            Exit For
        End If
    Next
    
    GetArrayComparision = cmp
    
End Function

Function GetWeddingDates(yr_begin As Integer, yr_end As Integer)
    Dim arr, srt, rpl_arr, rpl_srt, res()
    Dim dat As Date
    Dim rpl As String
    Dim yr As Integer, k As Integer
    k = -1
    
    For yr = yr_begin To yr_end
        arr = GetArrayFromString(CStr(yr))
        srt = GetSortedArray(arr)
        dat = CDate("1.1." & yr)
        
        Do While dat < CDate("31.12." & yr)
            rpl = left(Replace(dat, ".", ""), 4)
            rpl_arr = GetArrayFromString(rpl)
            rpl_srt = GetSortedArray(rpl_arr)
            If GetArrayComparision(srt, rpl_srt) Then
                k = k + 1
                ReDim Preserve res(k)
                res(k) = dat
            End If
            dat = dat + 1
        Loop
        
    Next
    
    GetWeddingDates = res
    
End Function

Sub Main()
    wd = GetWeddingDates(2001, 2022)
    For i = LBound(wd) To UBound(wd)
        Debug.Print wd(i)
    Next
End Sub
                

Lösung von: Jens Kelm (@JKooP)

// C++ 17
#include <iostream>
#include <vector>
#include <boost/date_time/gregorian/gregorian.hpp>
using namespace boost::gregorian;

struct yearspan { int begin; int end; };

std::vector<date> get_wedding_dates(yearspan span) {
    std::vector<date>dates{};
    days add_one{ 1 };

    const auto get_leading_zero{ [](auto i) { std::stringstream ss; ss << 0 << i;
    return ss.str().substr(ss.str().length() - 2); } };

    for (int yr{ span.begin }; yr <= span.end; ++yr) {
        auto yr_str{ std::to_string(yr) };
        std::sort(yr_str.begin(), yr_str.end());
        const auto yr_type{ static_cast<date::year_type>(yr) };
        date yr_begin { yr_type, 1, 1 };
        const date yr_end{ yr_type, 12, 31 };

        while (yr_begin < yr_end) {
            const auto day_str{ get_leading_zero(yr_begin.day()) };
            const auto mon_str{ get_leading_zero(yr_begin.month().as_number()) };
            std::stringstream ss;
            ss << day_str << mon_str;
            auto rev_str{ ss.str() };
            std::sort(rev_str.begin(), rev_str.end());
            if (rev_str == yr_str)
                dates.push_back(yr_begin);
            yr_begin += add_one;
        }
    }
    return dates;
}

int main() {
    const auto p{ get_wedding_dates({ 2001, 2022 }) };
    date_facet* f(new date_facet("%d.%m.%Y"));
    std::cout.imbue(std::locale(std::cout.getloc(), f));
    for (const auto& i : p)
        std::cout << i << "\n";
}
                

Lösung von: Jens Kelm (@JKooP)

// C++ 20 | VS-2022

#include <iostream>
#include <chrono>
#include <vector>
#include <algorithm>
#include <format>

using namespace std::chrono;
using namespace std::string_literals;
using ymd = year_month_day;

struct span {
    int begin, end;
};

constexpr auto get_wedding_dates(const span& span_) {
    std::vector<ymd>dates;

    constexpr auto get_leading_zero{ [](const auto& i) {
        const auto z{ "0"s + std::to_string(i) };
        return z.substr(z.length() - 2); } };

    for (auto yr{ span_.begin }; yr <= span_.end; ++yr) {
        auto yr_str{ std::to_string(yr) };
        std::sort(yr_str.begin(), yr_str.end());
        ymd yr_begin{ year{yr} / January / day{1} };
        const ymd yr_end{ year{yr} / December / day{31} };

        while (yr_begin <= yr_end) {
            const auto day_str{ get_leading_zero(unsigned(yr_begin.day())) };
            const auto mon_str{ get_leading_zero(unsigned(yr_begin.month())) };
            std::string day_mon_str{ day_str + mon_str };
            std::sort(day_mon_str.begin(), day_mon_str.end());
            if (day_mon_str == yr_str) 
                dates.push_back(yr_begin);
            yr_begin = sys_days{ yr_begin } + days{ 1 };
        } 
    }
    return dates;
}

std::ostream& operator<<(std::ostream& os_, const ymd& ymd_) {
    os_ << std::format("{}.{:02}.{}\n", ymd_.day(), unsigned(ymd_.month()), ymd_.year());
    return os_;
}

int main() {
    const auto wd{ get_wedding_dates({ 2001, 2020 }) };
    for (const auto& d : wd)
        std::cout << d;
}
                

Lösung von: Jens Kelm (@JKooP)