Programa para calcular el Día del Juicio Final para un año

Doomsday puede referirse a un evento hipotético según el cual el final de la vida humana es la máxima posibilidad. Hay muchos algoritmos escritos para calcular qué día de la semana en un año tiene la mayor posibilidad de que el día del juicio final caiga en ese día.
Todas las declaraciones son con respecto al Calendario Gregoriano. Como el calendario gregoriano se repite cada 400 años, se decide un conjunto de reglas solo para los primeros 400 años. Los algoritmos se derivan de los cálculos de John Conway, Lewis Carroll y muchos otros matemáticos de la historia que trabajaron en el cálculo del Día del Juicio Final.
Para calcular el Día del Juicio Final de un año en particular, se utiliza el siguiente algoritmo: –

• Extrae los dos últimos dígitos del año. (Que sea y)
• Dividir por 12 toma el piso del valor.
• Luego suma el resto de dividir y por 12.
• Calcula el resultado cuando el resto de y dividido por 12 se divide por 4.
• Tome el piso del valor anterior y luego agregue.
• Tome el resto después de dividir con 7 (mod 7).
• Agregue el valor del día ancla de la semana a partir del domingo (considerando el domingo como 0)

La fórmula se convierte en –

Aquí [ ] es la función de entero más grande.
El día del ancla cambia después de 100 años y se repite cada 400 años de la siguiente manera:

0-99 yrs --> Tuesday
100-199 yrs --> Sunday
200-299 yrs --> Friday
300-399 yr --> Wednesday

Después de esto, los días ancla anteriores se repiten como se mencionó al principio del artículo.
Ejemplos:

Input :  2005
Output : Doomsday in the year 2005 = Monday

Input : 1800
Output : Doomsday in the year 1800 = Friday

A continuación se muestra la implementación.

#include<bits/stdc++.h>
using namespace std;
 
string dooms_day(int year)
{
     
    // map to store days value of
    // anchor day can be known
    map<int, string> dict_day;
    dict_day[0] = "Sunday";
    dict_day[1] = "Monday";
    dict_day[2] = "Tuesday";
    dict_day[3] = "Wednesday";
    dict_day[4] = "Thursday";
    dict_day[5] = "Friday";
    dict_day[6] = "Saturday";
     
    // Gregorian calendar repeats
    // every 400 years
    int k = year % 400;
     
    int anchor;
     
    // Decide the anchor day
    if(k >= 0 && k < 100)
        anchor = 2;
         
    else if(k >= 100 && k < 200)
        anchor = 0;
         
    else if(k >= 200 && k < 300)
        anchor = 5;
         
    else
        anchor = 3;
         
    int y = year % 100;
     
    // Dooms day formula by Conway
    int doomsday = ((y / 12 + y % 12 +
                    (y % 12) / 4) % 7 + anchor) % 7;
     
    return dict_day[doomsday];
}
 
// Driver code
int main()
{
    int year = 1966;
     
    cout << "Doomsday in the year "
         << year << " = " << dooms_day(year);
     
    return 0;
}
 
// This code is contributed by yatinagg

import java.util.*;
 
class GFG{
     
public static String dooms_day(int year)
{
     
    // map to store days value of 
    // anchor day can be known 
    HashMap<Integer, String> dict_day = new HashMap<>();
    dict_day.put(0, "Sunday");
    dict_day.put(1, "Monday");
    dict_day.put(2, "Tuesday");
    dict_day.put(3, "Wednesday");
    dict_day.put(4, "Thursday");
    dict_day.put(5, "Friday");
    dict_day.put(6, "Saturday");
       
    // Gregorian calendar repeats 
    // every 400 years 
    int k = year % 400;
       
    int anchor;
       
    // Decide the anchor day 
    if (k >= 0 && k < 100)
        anchor = 2;
           
    else if (k >= 100 && k < 200)
        anchor = 0;
           
    else if (k >= 200 && k < 300)
        anchor = 5;
           
    else
        anchor = 3;
           
    int y = year % 100;
       
    // Dooms day formula by Conway 
    int doomsday = ((y / 12 + y % 12 + 
                   (y % 12) / 4) % 7 +
                    anchor) % 7;
       
    return dict_day.get(doomsday);
}
 
// Driver code
public static void main(String[] args)
{
    int year = 1966;
     
    System.out.println("Doomsday in the year " +
                        year + " = " +
                        dooms_day(year));
}
}
 
// This code is contributed divyeshrabadiya07

def dooms_day(year):
     
    # dictionary to store days
    # value of anchor day can be known
    dict_day ={ 0 : "Sunday",
               1 : "Monday",
               2 : "Tuesday",
               3 : "Wednesday",
               4 : "Thursday",
               5 : "Friday",
               6 : "Saturday" }
     
    # gregorian calendar repeats
    # every 400 years
    k = year % 400
     
    # decide the anchor day
    if(k >= 0 and k < 100):
        anchor = 2
         
    elif(k >= 100 and k < 200):
        anchor = 0
         
    elif(k >= 200 and k < 300):
        anchor = 5
         
    else:
        anchor = 3
         
    y = year % 100
     
    # dooms day formula by Conway
    doomsday = ((y//12 + y % 12 + (y % 12)//4)% 7 + anchor) % 7
     
    return dict_day[doomsday]
 
# Driver code
year = 1966
print("Doomsday in the year % s = % s"%(year,
                                        dooms_day(year)))

using System;
using System.Collections.Generic;  
class GFG
{  
    static String dooms_day(int year)
    {
          
        // map to store days value of 
        // anchor day can be known 
        Dictionary<int, string> dict_day =  
                       new Dictionary<int, string>(); 
        dict_day.Add(0, "Sunday");
        dict_day.Add(1, "Monday");
        dict_day.Add(2, "Tuesday");
        dict_day.Add(3, "Wednesday");
        dict_day.Add(4, "Thursday");
        dict_day.Add(5, "Friday");
        dict_day.Add(6, "Saturday");
            
        // Gregorian calendar repeats 
        // every 400 years 
        int k = year % 400;
            
        int anchor;
            
        // Decide the anchor day 
        if (k >= 0 && k < 100)
            anchor = 2;
                
        else if (k >= 100 && k < 200)
            anchor = 0;
                
        else if (k >= 200 && k < 300)
            anchor = 5;
                
        else
            anchor = 3;
                
        int y = year % 100;
            
        // Dooms day formula by Conway 
        int doomsday = ((y / 12 + y % 12 + 
                       (y % 12) / 4) % 7 +
                        anchor) % 7;
            
        return dict_day[doomsday];
    }
   
  // Driver code
  static void Main()
  {
        int year = 1966;
      
        Console.WriteLine("Doomsday in the year " +
                            year + " = " +
                            dooms_day(year));
  }
}
 
// This code is contributed by divyesh072019

<script>
      function dooms_day(year) {
 
        // map to store days value of
        // anchor day can be known
        var dict_day = new Map();
        dict_day.set(0, "Sunday");
        dict_day.set(1, "Monday");
        dict_day.set(2, "Tuesday");
        dict_day.set(3, "Wednesday");
        dict_day.set(4, "Thursday");
        dict_day.set(5, "Friday");
        dict_day.set(6, "Saturday");
 
        // Gregorian calendar repeats
        // every 400 years
        var k = year % 400;
 
        var anchor;
 
        // Decide the anchor day
        if (k >= 0 && k < 100)
            anchor = 2;
 
        else if (k >= 100 && k < 200)
            anchor = 0;
 
        else if (k >= 200 && k < 300)
            anchor = 5;
 
        else
            anchor = 3;
 
        var y = parseInt(year % 100);
 
        // Dooms day formula by Conway
        var doomsday = parseInt(parseInt(parseInt(y / 12) + y % 12 + parseInt((y % 12) / 4)) % 7 + anchor) % 7;
 
        return dict_day.get(doomsday);
    }
 
    // Driver code
        var year = 1966;
        document.write("Doomsday in the year " + year + " = " + dooms_day(year));
 
// This code is contributed by gauravrajput1
</script>

Doomsday in the year 1966 = Monday

Complejidad Temporal: – O (1)

Complejidad espacial: – O (1)