¿Alguien tiene un buen algoritmo para calcular la fecha del viernes santo cae sobre el año como una entrada? Preferiblemente en C#.

  • Para su INFORMACIÓN, Esto es difícil porque la Pascua (y por lo tanto el viernes santo) se basa en la luna, como era la Pascua antes.
  • Es difícil, por lo cual le pregunté 🙂
  • La pascua está basado en el de la luna; porque el calendario hebreo es lunar. La pascua siempre entran en la primera luna llena de la primavera.
  • Duplicado de stackoverflow.com/questions/2192533/… . A pesar del título, que explícitamente dice, «Realmente, realmente estoy buscando la fecha del viernes santo».
  • Muy interesante, yo no vi eso antes cuando he buscado (pero estaba buscando en contra de viernes santo, no de Pascua).
  • Si mal no recuerdo, una definición de la Pascua viene de una tabla (que termina en el 2022) del valor calculado por algún monje que hizo un error en algún momento. El resultado final para este caso es: sólo tiene que utilizar la tabla.

InformationsquelleAutor Bryan Denny | 2010-03-24

6 Comentarios

  1. 55

    He aquí un gran artículo que debería ayudarle a construir su algoritmo

    http://www.codeproject.com/KB/datetime/christianholidays.aspx

    Basándose en este ejemplo, usted debería ser capaz de escribir:

    DateTime goodFriday = EasterSunday(DateTime.Now.Year).AddDays(-2);

    Ejemplo Completo:

    public static DateTime EasterSunday(int year)
    {
        int day = 0;
        int month = 0;
    
        int g = year % 19;
        int c = year / 100;
        int h = (c - (int)(c / 4) - (int)((8 * c + 13) / 25) + 19 * g + 15) % 30;
        int i = h - (int)(h / 28) * (1 - (int)(h / 28) * (int)(29 / (h + 1)) * (int)((21 - g) / 11));
    
        day   = i - ((year + (int)(year / 4) + i + 2 - c + (int)(c / 4)) % 7) + 28;
        month = 3;
    
        if (day > 31)
        {
            month++;
            day -= 31;
        }
    
        return new DateTime(year, month, day);
    }
    • int h = h = ( ??? Es uno de los operadores de asignación de un error tipográfico?
    • No sé a qué te refieres a… j/k, me fijo
    • Yo no puedo creer lo complejo que es para algo aparentemente tan simple… me pregunto si se puede refactorizar que… (maravillas)
    • Usted puede refactorizar que se tengan los nombres de las variables…
    • Y, ¿qué sugiere usted para el año mod 19? int yearMod19?
    • Si usted ha hecho clic en el enlace en mi post verás que he utilizado el ejemplo de ese enlace
    • es más informativo que g!
    • Supongo que el punto es que es realmente sin sentido de todos modos. Creo que con los algoritmos de nombres significativos puede ser ignorado cuando no hay nombre significativo a dar. for(int incrementingInteger = 0; incrementingInteger < bla.Count(); incrementingInteger++) <= Si te veo escribir que voy a estar muy triste
    • para un bucle como el que, el int podría ser fácilmente un índice en algo, así que gooseIndex sería más apropiado. No se que hago esto, por lo general no i o j o lo que sea, pero yo tenía un profe que insistió en que no carece de sentido los nombres de las variables, incluso en los bucles…
    • La última línea ‘return new DateTime(mes, día, año);’ parece tener los argumentos en el orden equivocado. El constructor de DateTime ocupa el primer año, luego el mes, luego el día.
    • Se ha corregido la última línea que devuelve el DateTime.
    • g es la posición dentro de los 19 años de ciclo lunar, conocido como el número de oro. c es el siglo. h es el número de días entre el equinoccio y la próxima luna llena. Bastante seguro de que i es el número de días entre la luna llena después del equinoccio y el primer domingo después de la luna llena.
    • Sangrienta H*** Esto es hermoso, gracias!

  2. 7

    Don’t Repeat Yourself

    Pensar

    Darse cuenta de que el cálculo de la Pascua es lo que son realmente dependiente.

    Investigación

    Aquí es el oficial Observatorio Naval de la página para el cálculo de la Pascua.

    http://aa.usno.navy.mil/faq/docs/easter.php

    Ejecutar

    El uso de la fórmula para el cálculo de la Pascua, a continuación, turno para el viernes anterior (o restar 2 días, los detalles de usted).

    • Y, a continuación, darse cuenta de que no hay tanto una Ortodoxa y Católica de pascua-domingo (en una fecha diferente): Priceless
  3. 2

    Wikipedia sabe: http://en.wikipedia.org/wiki/Good_Friday#Calculating_the_date

    El viernes santo es el viernes antes de Pascua, que se calcula de forma diferente en la Cristiandad Oriental y Occidental, el Cristianismo (ver Computus para más detalles). La pascua cae el primer domingo después de la pascua de la Luna Llena, la luna llena en o después del 21 de Marzo, se toma la fecha del equinoccio de primavera. El Oeste de cálculo utiliza el calendario Gregoriano, mientras que el este cálculo utiliza el calendario Juliano, cuyo 21 de Marzo de ahora corresponde al calendario Gregoriano, del 3 de abril. Los cálculos para la identificación de la fecha de la luna llena también difieren. Pascua Método de Datación (Sociedad Astronómica de Australia del Sur).

    En el Cristianismo Oriental, la Pascua puede caer entre el 22 de Marzo y 25 de abril en el Calendario Juliano (así, entre el 4 de abril y 8 de Mayo en términos del calendario Gregoriano, durante el período de 1900 y 2099), así que el viernes santo se puede caer entre el 20 de Marzo y 23 de abril, ambos inclusive (o entre el 2 de abril y 6 de Mayo en términos del calendario Gregoriano). (Ver Pascua.)

    • véase también en.wikipedia.org/wiki/Computus (que puede o no puede estar enlazado desde que la entrada de la wikipedia). Un método que ha sido utilizado históricamente es la búsqueda de la tabla — no el descuento de este método (a menos que tu pregunta es para la tarea 🙂
    • Computus enlace está allí.
  4. 1

    Intente esto:

    //test code:
    Console.WriteLine(CalcGoodFri(2008));
    Console.WriteLine(CalcGoodFri(2009));
    Console.WriteLine(CalcGoodFri(2010));
    
    private static DateTime CalcGoodFri(int yr)
    {
     //int yr = 2010;  //The year for which to determine the date of Good Friday.
     int a = yr % 19;      
     int b = yr / 100;     
     int c = yr % 100;   
     int d = b / 4;
     int e = b % 4;      
     int i = c / 4;
     int k = c % 4;
     int g = (8 * b + 13) / 25;
     int h = ((19 * a) + b - d - g + 15) % 30;
     int l = ((2 * e) + (2 * i) - k + 32 - h) % 7;
     int m = (a + (11*h) + (19*l)) / 433;
     int days_to_good_friday = h + l - (7*m) - 2;  
     int mo = (days_to_good_friday + 90) / 25;
     int da = (days_to_good_friday + (33 * mo) + 19) % 32;
     return new DateTime ( yr, mo, da) ;    //Returns the date of Good Friday
    }

    Lógica portado desde aquí: http://www.kenhamady.com/form25.shtml

    • Su alentador ver que la calidad de un código como este nunca pasa de moda. Me gusta especialmente el uso de los significativos nombres de variable. Aunque, dicho esto, me pregunto sobre el uso de «days_to_good_friday» como un nombre de variable, cuando «o» hubiera sido más acorde con los estándares de codificación. También, es bueno ver que el «f» no se ha usado… que permitiría a los últimos tres variables w, t y f.
    • LOL! +1… Sinceramente, he intentado un refactorizar en esto, pero rápidamente se dio por vencido. La matemática es bastante peculiar que me han estado trabajando durante días para hacer básicamente toda una clase con muchos constante y el método privado para hacer de este legible… La frecuencia de la magia de los números de cada línea de código puede ser en realidad un récord mundial! (acerca de 2:1)
  5. 0

    Es posible el uso del hebreo o el árabe calendarios lunares para la conversión?
    por ejemplo:

     DateTime getEasterSunday(int year)
            {
                const int fourTeen = 14;
                DateTime Paschal = new DateTime(1900, 3, 20);
                var iCal = new HebrewCalendar();
                DateTime eFullMoon;
                var pDate = new DateTime(year, Paschal.Month, Paschal.Day);
                var LunarYear = iCal.GetYear(pDate);
                var LunarMonth = iCal.GetMonth(pDate);
                var LunarDay = iCal.GetDayOfMonth(pDate);
    
                if (LunarDay >= fourTeen) LunarMonth++;
    
                eFullMoon = iCal.ToDateTime(LunarYear, LunarMonth, fourTeen, 0, 0, 0, 0);
    
                return Enumerable.Range(0, 6).Select(x => eFullMoon.Date.AddDays(x)).Where(x => x.DayOfWeek == DayOfWeek.Sunday).First();
            }
  6. 0

    Necromancing.

    En realidad, depende de si es Ortodoxa o Católica Buen viernes 😉

    de
    https://mycodepad.wordpress.com/2013/04/28/c-calculating-orthodox-and-catholic-easter/

    (Nota: La Pascua = Domingo De Pascua)

    ///<summary>
    ///Get Orthodox easter for requested year
    ///</summary>
    ///<param name="year">Year of easter</param>
    ///<returns>DateTime of Orthodox Easter</returns>
    public static DateTime GetOrthodoxEaster( int year ) {
    int a = year % 19;
    int b = year % 7;
    int c = year % 4;
    int d = (19 * a + 16) % 30;
    int e = (2 * c + 4 * b + 6 * d) % 7;
    int f = (19 * a + 16) % 30;
    int key = f + e + 3;
    int month = (key > 30) ? 5 : 4;
    int day = (key > 30) ? key - 30 : key;
    return new DateTime( year, month, day );
    }
    ///<summary>
    ///Get Catholic easter for requested year
    ///</summary>
    ///<param name="year">Year of easter</param>
    ///<returns>DateTime of Catholic Easter</returns>
    public static DateTime GetCatholicEaster( int year ) {
    int month = 3;
    int G = year % 19 + 1;
    int C = year / 100 + 1;
    int X = (3 * C) / 4 - 12;
    int Y = (8 * C + 5) / 25 - 5;
    int Z = (5 * year) / 4 - X - 10;
    int E = (11 * G + 20 + Y - X) % 30;
    if (E == 24) { E++; }
    if ((E == 25) && (G > 11)) { E++; }
    int N = 44 - E;
    if (N < 21) { N = N + 30; }
    int P = (N + 7) - ((Z + N) % 7);
    if (P > 31) {
    P = P - 31;
    month = 4;
    }
    return new DateTime( year, month, P );
    }

    A continuación, usted todavía puede crear un resumen EasterBunny:

    private static void EasterBunnyTest()
    {
    AbstractEasterBunny WesternEuropeanBunny = new CatholicEasterBunny();
    AbstractEasterBunny EasternEuropeanBunny = new OrthodoxEasterBunny();
    AbstractEasterBunny LocalizedEasterBunny = AbstractEasterBunny.CreateInstance();
    System.DateTime dtRomeEaster = WesternEuropeanBunny.EasterSunday(2016);
    System.DateTime dtAthensEaster = EasternEuropeanBunny.EasterSunday(2016);
    System.DateTime dtLocalEaster = LocalizedEasterBunny.EasterSunday(2016);
    System.Console.WriteLine(dtRomeEaster);
    System.Console.WriteLine(dtAthensEaster);
    System.Console.WriteLine(dtLocalEaster);
    }

    Con este resumen bunny aquí:

    public abstract class AbstractEasterBunny
    {
    ///<summary>
    ///Gets the Orthodox easter sunday for the requested year
    ///</summary>
    ///<param name="year">The year you want to know the Orthodox Easter Sunday of</param>
    ///<returns>DateTime of Orthodox Easter Sunday</returns>
    public abstract System.DateTime EasterSunday(int year);
    public abstract System.DateTime GoodFriday(int year);
    public static AbstractEasterBunny CreateInstance()
    {
    System.Globalization.CultureInfo ci = System.Globalization.CultureInfo.CurrentCulture;
    System.Globalization.RegionInfo ri = new System.Globalization.RegionInfo(ci.LCID);
    //https://msdn.microsoft.com/en-us/library/windows/desktop/dd374073(v=vs.85).aspx
    System.Collections.Generic.List<int> lsOrthodox = new System.Collections.Generic.List<int>{
    0x10D //Serbia and Montenegro
    ,0x10E //Montenegro
    ,0x10F //Serbia
    ,0x19 //Bosnia and Herzegovina
    //,0x46 //Estonia
    //,0x4B //Czech Republic
    //,0x4D //Finland
    ,0x62 //Greece
    //,0x6D //Hungary
    ,0x79 //Iraq
    //,0x8C //Latvia
    //,0x8D //Lithuania
    //,0x8F //Slovakia
    //,0x98 //Moldova
    //,0xD4 //Slovenia
    ,0x4CA2 //Macedonia, Former Yugoslav Republic of
    ,0xEB //Turkey
    };
    //if(ci == WesternSlavonicOrthodox)
    if (lsOrthodox.Contains(ri.GeoId))
    return new OrthodoxEasterBunny();
    //TODO: Correct for Armenia/Georgia ? ? ? 
    //if(ri.GeoId == 0x7 || ri.GeoId == 0x58) //0x7: Armenia, 0x58: Georgia
    //return new CatholicEasterBunny();
    //if(ci == EasternSlavonic)
    string strMonthName = ci.DateTimeFormat.GetMonthName(8);
    if (System.Text.RegularExpressions.Regex.IsMatch(strMonthName, @"\p{IsCyrillic}"))
    {
    //there is at least one cyrillic character in the string
    return new OrthodoxEasterBunny();
    }
    return new CatholicEasterBunny();
    }
    }
    public class OrthodoxEasterBunny : AbstractEasterBunny
    {
    ///<summary>
    ///Gets the Orthodox easter sunday for the requested year
    ///</summary>
    ///<param name="year">The year you want to know the Orthodox Easter Sunday of</param>
    ///<returns>DateTime of Orthodox Easter Sunday</returns>
    public override System.DateTime EasterSunday(int year)
    {
    int a = year % 19;
    int b = year % 7;
    int c = year % 4;
    int d = (19 * a + 16) % 30;
    int e = (2 * c + 4 * b + 6 * d) % 7;
    int f = (19 * a + 16) % 30;
    int key = f + e + 3;
    int month = (key > 30) ? 5 : 4;
    int day = (key > 30) ? key - 30 : key;
    return new System.DateTime(year, month, day);
    }
    public override System.DateTime GoodFriday(int year)
    {
    return this.EasterSunday(year).AddDays(-2);
    }
    }
    public class CatholicEasterBunny : AbstractEasterBunny
    {
    ///<summary>
    ///Gets the Catholic easter sunday for the requested year
    ///</summary>
    ///<param name="year">The year you want to know the Catholic Easter Sunday of</param>
    ///<returns>DateTime of Catholic Easter Sunday</returns>
    public override System.DateTime EasterSunday(int year)
    {
    int day = 0;
    int month = 0;
    int g = year % 19;
    int c = year / 100;
    int h = (c - (int)(c / 4) - (int)((8 * c + 13) / 25) + 19 * g + 15) % 30;
    int i = h - (int)(h / 28) * (1 - (int)(h / 28) * (int)(29 / (h + 1)) * (int)((21 - g) / 11));
    day = i - ((year + (int)(year / 4) + i + 2 - c + (int)(c / 4)) % 7) + 28;
    month = 3;
    if (day > 31)
    {
    month++;
    day -= 31;
    }
    return new System.DateTime(year, month, day);
    }
    public override System.DateTime GoodFriday(int year)
    {
    return this.EasterSunday(year).AddDays(-2);
    }
    }

Dejar respuesta

Please enter your comment!
Please enter your name here