Comment calculer le numéro de semaine donné une date?
Si j'ai une date, comment puis-je calculer le numéro de semaine pour cette date dans cette année?
Par exemple, en 2008, du 1er au 6 janvier correspond à la semaine 1 et du 7 au 13 janvier à la semaine 2, donc si ma date était le 10 janvier 2008, mon numéro de semaine serait 2.
Un algorithme serait très utile pour commencer et un exemple de code aiderait également - je développe en C++ sous Windows.
En relation:
Obtenir le numéro de semaine d'une date dans MS SQL Server 2005?
Pseudocode:
int julian = getDayOfYear(myDate) // Jan 1 = 1, Jan 2 = 2, etc...
int dow = getDayOfWeek(myDate) // Sun = 0, Mon = 1, etc...
int dowJan1 = getDayOfWeek("1/1/" + thisYear) // find out first of year's day
// int badWeekNum = (julian / 7) + 1 // Get our week# (wrong! Don't use this)
int weekNum = ((julian + 6) / 7) // probably better. CHECK THIS LINE. (See comments.)
if (dow < dowJan1) // adjust for being after Saturday of week #1
++weekNum;
return (weekNum)
Pour clarifier, cet algorithme suppose que vous numérotiez vos semaines de la manière suivante:
S M T W R F S
1 2 3 <-- week #1
4 5 6 7 8 9 10 <-- week #2
[etc.]
getDayOfWeek () et getDayOfYear () sont des opérations standard date-object dans la plupart des langages. Si le vôtre ne les a pas, vous pouvez compter à partir d'une date connue (le 1er janvier 1970 est une date courante), après avoir levé les yeux pour voir quel jour de la semaine il s'agissait.
Si vous voulez mettre en place vos propres routines de comptage de dates, rappelez-vous que les années divisibles par 100 sont PAS années bissextiles, à moins qu'elles ne soient également divisibles par 400. Donc 1900 n'était pas une année bissextile, mais 2000 était. Si vous allez travailler très loin dans le temps, vous devez déconner avec les calendriers Grégorien vs Julian, etc., voir Wikipedia pour de nombreuses informations à ce sujet.
Ce lien parle plus en détail des fonctions de date/heure dans Windows/C++.
Sachez que bien que votre définition denthsemaine de l’année soit valable, elle n’est pas non plus «standard».
L'ISO 8601 définit une norme pour la représentation des dates, des heures et des fuseaux horaires. Il définit les semaines qui commencent le lundi. Il indique également que la semaine 1 de l'année est celle qui contient au moins 4 jours de l'année donnée. Par conséquent, les 29, 30 et 31 décembre 20xx pourraient être dans la semaine 1 de 20xy (où xy = xx + 1), et les 1er, 2 et 3 janvier 20xy pourraient tous être dans la dernière semaine de 20xx. De plus, il peut y avoir une semaine 53.
[ Ajouté : notez que le standard C et la fonction `strftime () prévoient des semaines commençant le dimanche ainsi que des semaines commençant le lundi. Il n’est pas clair que la norme C indique le nombre d’années de la semaine 0 pour les semaines du dimanche. Voir aussi la réponse d'Emerick Rogul.]
Vient ensuite la phase d’essai intéressante: quand aurez-vous la semaine 53? Une réponse sera le vendredi 1er janvier 2010, soit en 2009-W53 (comme, en effet, le dimanche 3 janvier 2010). De même, le samedi 1er janvier 2005 est en 2004-2005, alors que le dimanche 1er janvier 2006 est en 200552.
Il s'agit d'un extrait d'un commentaire dans le code suivant, qui est en fait dans Informix SPL (Stored Procedure Language), mais qui est lisible - bien que probablement non accessible en écriture - sans beaucoup d'explications supplémentaires. Le '||' L'opérateur est l'opération de concaténation de chaînes SQL, et le dimanche est le jour 0, le lundi est le jour 1, ... le samedi est le jour 6 de la semaine. Les commentaires contiennent de nombreuses notes, notamment le texte pertinent de la norme. Les commentaires d'une ligne commencent '--'; éventuellement, les commentaires multilignes commencent par '{' et se terminent au prochain '}'.
-- @(#)$Id: iso8601_weekday.spl,v 1.1 2001/04/03 19:34:43 jleffler Exp $
--
-- Calculate ISO 8601 Week Number for given date
-- Defines procedure: iso8601_weekday().
-- Uses procedure: iso8601_weeknum().
{
According to a summary of the ISO 8601:1988 standard "Data Elements and
Interchange Formats -- Information Interchange -- Representation of
dates and times":
The week notation can also be extended by a number indicating the
day of the week. For example the day 1996-12-31 which is the
Tuesday (day 2) of the first week of 1997 can also be written as
1997-W01-2 or 1997W012
for applications like industrial planning where many things like
shift rotations are organized per week and knowing the week number
and the day of the week is more handy than knowing the day of the
month.
This procedure uses iso8601_weeknum() to format the YYYY-Www part of the
date, and appends '-d' to the result, allowing for Informix's coding of
Sunday as day 0 rather than day 7 as required by ISO 8601.
}
CREATE PROCEDURE iso8601_weekday(dateval DATE DEFAULT TODAY) RETURNING CHAR(10);
DEFINE rv CHAR(10);
DEFINE dw CHAR(4);
LET dw = WEEKDAY(dateval);
IF dw = 0 THEN
LET dw = 7;
END IF;
RETURN iso8601_weeknum(dateval) || '-' || dw;
END PROCEDURE;
-- @(#)$Id: iso8601_weeknum.spl,v 1.1 2001/02/27 20:36:25 jleffler Exp $
--
-- Calculate ISO 8601 Week Number for given date
-- Defines procedures: day_one_week_one() and iso8601_weeknum().
{
According to a summary of the ISO 8601:1988 standard "Data Elements and
Interchange Formats -- Information Interchange -- Representation of
dates and times":
In commercial and industrial applications (delivery times,
production plans, etc.), especially in Europe, it is often required
to refer to a week of a year. Week 01 of a year is per definition
the first week which has the Thursday in this year, which is
equivalent to the week which contains the fourth day of January. In
other words, the first week of a new year is the week which has the
majority of its days in the new year. Week 01 might also contain
days from the previous year and the week before week 01 of a year is
the last week (52 or 53) of the previous year even if it contains
days from the new year. A week starts with Monday (day 1) and ends
with Sunday (day 7). For example, the first week of the year 1997
lasts from 1996-12-30 to 1997-01-05 and can be written in standard
notation as
1997-W01 or 1997W01
The week notation can also be extended by a number indicating the
day of the week. For example the day 1996-12-31 which is the
Tuesday (day 2) of the first week of 1997 can also be written as
1997-W01-2 or 1997W012
for applications like industrial planning where many things like
shift rotations are organized per week and knowing the week number
and the day of the week is more handy than knowing the day of the
month.
Referring to the standard itself, section 3.17 defines a calendar week:
week, calendar: A seven day period within a calendar year, starting
on a Monday and identified by its ordinal number within the year;
the first calendar week of the year is the one that includes the
first Thursday of that year. In the Gregorian calendar, this is
equivalent to the week which includes 4 January.
Section 5.2.3 "Date identified by Calendar week and day numbers" states:
Calendar week is represented by two numeric digits. The first
calendar week of a year shall be identified as 01 [...]
Day of the week is represented by one decimal digit. Monday
shall be identified as day 1 of any calendar week [...]
Section 5.2.3.1 "Complete representation" states:
When the application clearly identifies the need for a complete
representation of a date identified by calendar week and day
numbers, it shall be one of the alphanumeric representations as
follows, where CCYY represents a calendar year, W is the week
designator, ww represents the ordinal number of a calendar week
within the year, and D represents the ordinal number within the
calendar week.
Basic format: CCYYWwwD
Example: 1985W155
Extended format: CCYY-Www-D
Example: 1985-W15-5
Both the summary and the formal definition are intuitively clear, but it
is not obvious how to translate it into an algorithm. However, we can
deal with the problem by exhaustively enumerating the seven options for
the day of the week on which 1st January falls (with actual year values
for concreteness):
1st January 2001 is Monday => Week 1 starts on 2001-01-01
1st January 2002 is Tuesday => Week 1 starts on 2001-12-31
1st January 2003 is Wednesday => Week 1 starts on 2002-12-30
1st January 2004 is Thursday => Week 1 starts on 2003-12-29
1st January 2010 is Friday => Week 1 starts on 2010-01-04
1st January 2005 is Saturday => Week 1 starts on 2005-01-03
1st January 2006 is Sunday => Week 1 starts on 2006-01-02
(Cross-check: 1st January 1997 was a Wednesday; the summary notes state
that week 1 of 1997 started on 1996-12-30, which is consistent with the
table derived for dates in the first decade of the third millennium
above).
When working with the Informix DATE types, bear in mind that Informix
uses WEEKDAY values 0 = Sunday, 1 = Monday, 6 = Saturday. When the
weekday of the first of January has the value in the LH column, you need
to add the value in the RH column to the 1st of January to obtain the
date of the first day of the first week of the year.
Weekday Offset to
1st January 1st day of week 1
0 +1
1 0
2 -1
3 -2
4 -3
5 +3
6 +2
This can be written as MOD(11-w,7)-3 where w is the (Informix encoding
of the) weekday of 1st January and the value 11 is used to ensure that
no negative values are presented to the MOD operator. Hence, the
expression for the date corresponding to the 1st day (Monday) of the 1st
week of a given year, yyyy, is:
d1w1 = MDY(1, 1, yyyy) + MOD(11 - WEEKDAY(MDY(1,1,yyyy)), 7) - 3
This expression is encapsulated in stored procedure day_one_week_one:
}
CREATE PROCEDURE day_one_week_one(yyyy INTEGER) RETURNING DATE;
DEFINE jan1 DATE;
LET jan1 = MDY(1, 1, yyyy);
RETURN jan1 + MOD(11 - WEEKDAY(jan1), 7) - 3;
END PROCEDURE;
{
Given this date d1w1, we can calculate the week number of any other date
in the same year as:
TRUNC((dateval - d1w1) / 7) + 1
The residual issues are ensuring that the wraparounds are correct. If
the given date is earlier than the start of the first week of the year
that contains it, then the date belongs to the last week of the previous
year. If the given date is on or after the start of the first week of
the next year, then the date belongs to the first week of the next year.
Given these observations, we can write iso8601_weeknum as shown below.
(Beware: iso8601_week_number() is too long for servers with the
18-character limit; so is day_one_of_week_one()).
Then comes the interesting testing phase -- when do you get week 53?
One answer is on Friday 1st January 2010, which is in 2009-W53 (as,
indeed, is Sunday 3rd January 2010). Similarly, Saturday 1st January
2005 is in 2004-W53, but Sunday 1st January 2006 is in 2005-W52.
}
CREATE PROCEDURE iso8601_weeknum(dateval DATE DEFAULT TODAY) RETURNING CHAR(8);
DEFINE rv CHAR(8);
DEFINE yyyy CHAR(4);
DEFINE ww CHAR(2);
DEFINE d1w1 DATE;
DEFINE tv DATE;
DEFINE wn INTEGER;
DEFINE yn INTEGER;
-- Calculate year and week number.
LET yn = YEAR(dateval);
LET d1w1 = day_one_week_one(yn);
IF dateval < d1w1 THEN
-- Date is in early January and is in last week of prior year
LET yn = yn - 1;
LET d1w1 = day_one_week_one(yn);
ELSE
LET tv = day_one_week_one(yn + 1);
IF dateval >= tv THEN
-- Date is in late December and is in the first week of next year
LET yn = yn + 1;
LET d1w1 = tv;
END IF;
END IF;
LET wn = TRUNC((dateval - d1w1) / 7) + 1;
-- Calculation complete: yn is year number and wn is week number.
-- Format result.
LET yyyy = yn;
IF wn < 10 THEN
LET ww = '0' || wn;
ELSE
LET ww = wn;
END IF
LET rv = yyyy || '-W' || ww;
RETURN rv;
END PROCEDURE;
Pour être complet, la fonction inverse est également facile à écrire avec la fonction day_one_week_one() ci-dessus:
-- @(#)$Id: ywd_date.spl,v 1.1 2012/12/29 05:13:27 jleffler Exp $
-- @(#)Create ywd_date() and ywdstr_date() stored procedures
-- Convert a date in format year, week, day (ISO 8601) to DATE.
-- Two variants:
-- ywd_date(yyyy SMALLINT, ww SMALLINT, dd SMALLINT) RETURNING DATE;
-- ywdstr_date(ywd CHAR(10)) RETURNING DATE;
-- NB: If week 53 is supplied, there is no check that the year had week
-- 53 (GIGO).
-- NB: If year yyyy is a leap year and yyyy-01-01 falls on Wed (3) or
-- Thu (4), there are 53 weeks in the year.
-- NB: If year yyyy is not a leap year and yyyy-01-01 falls on Thu (4),
-- there are 53 weeks in the year.
CREATE PROCEDURE ywd_date(yyyy SMALLINT, ww SMALLINT, dd SMALLINT) RETURNING DATE AS date;
DEFINE d DATE;
-- Check ranges
IF yyyy < 1 OR yyyy > 9999 OR ww < 1 OR ww > 53 OR dd < 1 OR dd > 7 THEN
RETURN NULL;
END IF;
LET d = day_one_week_one(yyyy);
LET d = d + (ww - 1) * 7 + (dd - 1);
RETURN d;
END PROCEDURE;
-- Input: 2012-W52-5
CREATE PROCEDURE ywdstr_date(ywd CHAR(10)) RETURNING DATE AS date;
DEFINE yyyy SMALLINT;
DEFINE ww SMALLINT;
DEFINE dd SMALLINT;
LET yyyy = SUBSTR(ywd, 1, 4);
LET ww = SUBSTR(ywd, 7, 2);
LET dd = SUBSTR(ywd, 10, 1);
RETURN ywd_date(yyyy, ww, dd);
END PROCEDURE;
CREATE TEMP TABLE test_dates(d DATE);
INSERT INTO test_dates VALUES('2011-12-28');
INSERT INTO test_dates VALUES('2011-12-29');
INSERT INTO test_dates VALUES('2011-12-30');
INSERT INTO test_dates VALUES('2011-12-31');
INSERT INTO test_dates VALUES('2012-01-01');
INSERT INTO test_dates VALUES('2012-01-02');
INSERT INTO test_dates VALUES('2012-01-03');
INSERT INTO test_dates VALUES('2012-01-04');
INSERT INTO test_dates VALUES('2012-01-05');
INSERT INTO test_dates VALUES('2012-01-06');
INSERT INTO test_dates VALUES('2012-01-07');
SELECT d, iso8601_weeknum(d), iso8601_weekday(d), ywdstr_date(iso8601_weekday(d))
FROM test_dates
ORDER BY d;
Comme indiqué dans les commentaires, le code acceptera une date à 53 semaines même si l'année n'accepte que 52 semaines.
Je recommande fortement d'utiliser les fonctions horaires de la bibliothèque standard C pour calculer le nombre de semaines. Spécifiquement, la fonction strftime a des spécificateurs pour imprimer le numéro de semaine (parmi beaucoup d'autres valeurs) à partir d'une date donnée au format décomposé (struct tm). Voici un petit exemple de programme illustrant ceci:
#include <stdio.h>
#include <string.h>
#include <time.h>
int
main(void)
{
struct tm tm;
char timebuf[64];
// Zero out struct tm
memset(&tm, 0, sizeof tm);
// November 4, 2008 11:00 pm
tm.tm_sec = 0;
tm.tm_min = 0;
tm.tm_hour = 23;
tm.tm_mday = 4;
tm.tm_mon = 10;
tm.tm_year = 108;
tm.tm_isdst = -1;
// Call mktime to recompute tm.tm_wday and tm.tm_yday
mktime(&tm);
if (strftime(timebuf, sizeof timebuf, "%W", &tm) != 0) {
printf("Week number is: %s\n", timebuf);
}
return 0;
}
La sortie de ce programme (compilé avec GCC sous Linux et Microsoft Visual Studio 2005 SP1 sous Windows) est:
Week number is: 44
Vous pouvez en apprendre plus sur strftime ici .
Désolé, je suis nouveau ici et je ne peux pas commenter la réponse elle-même, mais le pseudo-code de la réponse coché n'est pas obligatoirement correct.
Pseudocode:
int julian = getDayOfYear(myDate) // Jan 1 = 1, Jan 2 = 2, etc...
int dow = getDayOfWeek(myDate) // Sun = 0, Mon = 1, etc...
int dowJan1 = getDayOfWeek("1/1/" + thisYear) // find out first of year's day
int weekNum = (julian / 7) + 1 // Get our week#
if (dow < dowJan1) // adjust for being after Saturday of week #1
++weekNum;
return (weekNum)
vous ne devriez pas chercher le "premier jour de l'année", mais le dernier jour de l'année dernière.
getDayOfWeek("12/31/" + thisYear-1)
serait correct au lieu de
getDayOfWeek("1/1/" + thisYear)
Si vous ne le faites pas, le dernier jour de semaine de l'année dernière (comme lundi) aura toujours une semaine d'avance.
Pour convertir dans les deux sens, voir ici: Article Wikipedia sur les dates de la semaine ISO
struct tm est utilisé pour représenter le "temps d'indisponibilité" et comporte au moins les champs suivants:
int tm_sec Secondes [0,60]. int tm_min Minutes [0,59]. int tm_hour Hour [0,23]. int tm_mday Jour du mois [1,31]. int tm_mon Mois de l'année [0,11]. int tm_year Années depuis 1900. int tm_wday Jour de la semaine [0,6] (dimanche = 0). int tm_yday Jour de l'année [0,365]. int tm_isdst Indicateur d'heure avancée.
Vous pouvez créer une struct tm à partir de time_t avec la fonction localtime ().
Vous pouvez créer un time_t à partir d'un struct tm avec la fonction mktime ().
La meilleure partie de struct tm est que vous pouvez faire des choses comme ajouter 24 au membre du mois de l’année et quand vous appelez mktime (), vous obtiendrez un time_t thats 2 ans dans le futur (cela fonctionne avec l’un de ses membres, donc vous pouvez, par exemple, incrémenter l’heure de 1 000 puis obtenir un délai de 41 jours dans le futur) ...
En utilisant iso_week.h de howardhinnant.github.io/iso_week.html c'est facilement réalisable:
#include <iostream>
#include "iso_week.h"
int main() {
using namespace iso_week;
using namespace std::chrono;
// Get the current time_point and floor to convert to the sys_days:
auto today = floor<days>(system_clock::now());
// Convert from sys_days to iso_week::year_weeknum_weekday format
auto yww = year_weeknum_weekday{today};
// Print current week number of the year
std::cout << "The current week of " << yww.year() << " is: "
<< yww.weeknum() << std::endl;
// Set any day
auto any_day = 2014_y/9/28;
// Get week of `any_day`
std::cout << "The week of " << any_day.year() << " on `any day` was: "
<< any_day.weeknum() << std::endl;
}
et le résultat est:
The current week of 2019 is: W18
The week in 2014 on `any day` was: W09
Ma définition qui est non-ISO 8601 (assez bon pour mes besoins et rapide):
// week number of the year
// (Monday as the first day of the week) as a decimal number [00,53].
// All days in a new year preceding the first Monday are considered to be in week 0.
int GetWeek(const struct tm& ts)
{
return (ts.tm_yday + 7 - (ts.tm_wday ? (ts.tm_wday - 1) : 6)) / 7;
}
Mon hypothèse était que la première semaine de l'année puisse contenir jusqu'à 7 jours, comme illustré dans la réponse d'Olie . Le code ne gère pas les cultures où la semaine commence un autre jour que le dimanche et qui couvre une grande partie du monde. .
tm t = ... //the date on which to find week of year
int wy = -1;
struct tm t1;
t1.tm_year = t.tm_year;
t1.tm_mday = t1.tm_mon = 1; //set to 1st of January
time_t tt = mktime(&t1); //compute tm
//remove days for 1st week
int yd = t.tm_yday - (7 - t1.tm_wday);
if(yd <= 0 ) //first week is now negative
wy = 0;
else
wy = (int)std::ceil( (double) ( yd/7) ); //second week will be 1
C'est ma solution mais ce n'est pas en C++
NoOfDays = (CurrentDate - YearStartDate)+1
IF NoOfDays MOD 7 = 0 Then
WeekNo = INT(NoOfDays/7)
ELSE
WeekNo = INT(NoOfDays/7)+1
END
public int GetWeekOfYear(DateTime todayDate)
{
int days = todayDate.DayOfYear;
float result = days / 7;
result=result+1;
Response.Write(result.ToString());
return Convert.ToInt32(result);
}
Il suffit de passer la date actuelle comme paramètre de cette fonction . Vous obtiendrez alors le numéro de la semaine en cours . J'espère que cela résoudra votre problème. Toutes les suggestions sont les bienvenues.
time_t t = time(NULL);
tm* timePtr = localtime(&t);
double day_of_year=timePtr->tm_yday +1 ; // 1-365
int week_of_year =(int) ceill(day_of_year/7.0);
Boost fournit gregorian :: date :: week_number () Voir http://www.boost.org/doc/libs/1_38_0/doc/html/boost/gregorian/date.html et http://www.boost.org/doc/libs/1_38_0/boost/date_time/gregorian/greg_date.hpp .
Cependant, je ne vois pas comment obtenir le numéro d'année qui correspond au numéro de semaine (qui peut être différent de l'année civile pour cette date).
Utilisez gmtime ou localtime pour calculer les jours depuis le dimanche (c'est-à-dire le jour de la semaine) et les jours depuis le 1er janvier (notez que le 1er janvier est "0" dans ce dernier).
Le bit arbitraire consiste à décider du jour de l’année sur lequel commence la semaine 1: cela dépend généralement du jour de la semaine du 1 er janvier, que vous pouvez bien entendu calculer à partir des deux informations de gmtime. Utilisez ensuite une table pour rechercher les 7 possibilités. C’est probablement plus facile que de coder les règles.
Par exemple, je pense que Outlook utilise la norme selon laquelle la semaine 1 est la première semaine contenant un jeudi. Donc, si le 1er janvier est un dimanche, le premier jour de la semaine 1 est le 1er janvier ou le jour 0. Les possibilités restantes sont le lundi, -1; Mardi, -2; Mercredi, -3; Jeudi, -4; Vendredi 2; Samedi 1.
Notez les nombres négatifs: "Le dimanche de la semaine 1" n'existe pas réellement dans 4 cas sur 7, mais si nous prétendons que c'était un jour l'année précédente, nous obtiendrons la bonne réponse.
Une fois que vous avez cela, le nombre de jours entre celle-ci et votre date vous indique le nombre de semaines: divisez par 7 et ajoutez 1.
Cela dit, j’imagine qu’il existe une API Windows quelque part qui vous donnera le même numéro de semaine que celui utilisé par Outlook. Je ne sais tout simplement pas ce que c'est, et bien sûr, si vos règles de la semaine 1 sont différentes de celles d'Outlook, cela n'aura probablement pas une grande utilité.
Code non testé:
int firstdays[7] = { 0, -1, -2, -3, -4, 2, 1 }; // or some other Week 1 rule
struct tm breakdown;
time_t target = time_you_care_about();
_gmtime_s(&breakdown,&target);
int dayofweek = breakdown.tm_wday;
int dayofyear = breakdown.tm_yday;
int jan1wday = (dayofweek - dayofyear) % 7;
if (jan1wday < 0) jan1wday += 7;
int week1first = firstdays[jan1wday];
if (dayofyear < week1first) return 0;
return ((dayofyear - week1first)/7) + 1;
Quelque chose comme ça, en tout cas.