Come calcolare il numero di anni bisestili tra due anni in C#

Question

Esiste un modo migliore per calcolare il numero di anni bisestili tra due anni. Supponendo che io abbia data di inizio e data di fine.

Ho il mio codice, ma penso che ci dovrebbe essere un modo più elegante.

codice chiamando:

var numberOfLeapYears = NumberOfLeapYears(startDate.Year + 1, endDate.Year - 1); 

stessa funzione:

private static int NumberOfLeapYears(int startYear, int endYear) 
    { 
     var counter = 0; 

     for (var year = startYear; year <= endYear; year++) 
      counter += DateTime.IsLeapYear(year) ? 1 : 0; 

     return counter; 
    } 

Quindi, se ho startDate = "2006/10/16" e endDate = "2004/04/18" Dovrei solo avere 1 anno bisestile (2000) nel risultato. Altre parole: l'anno di inizio anno e l'anno di fine anno non dovrebbero essere calcolati, solo tra anni.

Grazie in anticipo per il vostro aiuto.

Answer 1

È possibile contarlo utilizzando l'approccio analitico. Un anno è un anno bisestile se può essere diviso per 4, ma non può essere diviso per 100, salvo il caso in cui può essere diviso per 400. Supponendo di poter contare tale numero seguendo il codice:

 static int LeapYearsBetween(int start, int end) 
     { 
      System.Diagnostics.Debug.Assert(start < end); 
      return LeapYearsBefore(end) - LeapYearsBefore(start + 1); 
     } 

     static int LeapYearsBefore(int year) 
     { 
      System.Diagnostics.Debug.Assert(year > 0); 
      year--; 
      return (year/4) - (year/100) + (year/400); 
     } 

Una specie di magia matematica. È una soluzione molto efficace rispetto all'uso di LINQ.

Answer 2

È possibile farlo con LINQ semplicemente come muggito:

var leepYears = Enumerable.Range(startYear, endYear - startYear + 1) 
           .Count(x => DateTime.IsLeapYear(x)); 

Answer 3

Questo dovrebbe svolgere molto meglio per grandi luci di tempo:

public int LeapYearsBetween(int year1, int year2) 
{ 
    var y1 = new DateTime(year1, 1, 1); 
    var y2 = new DateTime(year2, 1, 1); 
    var nonLeapDays = 365 * (y2.Year - y1.Year); 
    var leapDays = (y2 - y1).Days - nonLeapDays; 
    return leapDays; 
} 

Si noti che questo conta l'anno prima, se si tratta di un anno bisestile, ma non l'anno successivo. Dovrai modificare la funzione se hai bisogno di un comportamento diverso.

Answer 4

Non potresti semplicemente testare i primi 4 anni e trovare il primo anno bisestile e sottrarlo dagli anni complessivi e dal mod 4?

fondamentalmente:

anno_fine - mod first_leap_year_found 4.

non sarei sorpreso se ci sono un paio di modifiche in là per spiegare il fatto che sia specificato l'intero data, non solo l'anno , ma anche quelle modifiche dovrebbero essere semplici.

Si finisce per usare solo l'istruzione DateTime.IsLeapYear (anno) al massimo 4 volte, e dopo è semplice matematica.

Answer 5

Un'altra Linq :-)

int start = 1980; 
int end = 2000; 
var count = Enumerable.Range(start, end - start + 1) 
         .Aggregate(0, (a, b) => DateTime.IsLeapYear(b) ? a + 1 : a); 

Answer 6

Solo un altro codice con tipi primitivi

public static int CountLeapYears(int startYear, int endYear) 
    { 
     int acc = 0; 

     while (true) 
     { 
      if ((startYear % 4 == 0 && startYear % 100 != 0) || startYear % 400 == 0) 
       acc++; 
      if (startYear + 1 == endYear) break; 
      startYear++; 
     } 

     return acc; 
    } 

Answer 7

On tuoi calcoli (divisibile per 100 non sono anni bisestili meno che non siano anche divisibile per 400) questo vorrebbe dire 1900 non era un anno bisestile? errato

Ciò significa che il seguente è corretto: Non potresti semplicemente testare i primi 4 anni e trovare il primo anno bisestile e sottrarlo dal totale degli anni e del mod 4? in fondo: end_year - first_leap_year_found mod 4 = 0 è un anno bisestile