Найти ближайшее время к текущему времени

Таким образом, проблема в том, что вы сидите на круге и хотите узнать, короче ли расстояние от d1 до d2 направо (оставаясь на той же неделе) или налево (одно значение до следующего по воскресенье).

Сначала вы должны преобразовать дату в значение с формулой минута + час * 60 + день недели * 60 * 24. Это даст вам минуту на неделе.

#include <stdlib.h>
int minOfWeek (int d, int h, int m) {
return d*60*24+h*60+m;
}

Далее найдите минимальное расстояние:

const int minutesInWeek=60*24*7;
int bestDistance (int minutes1, int minutes2) {
int d=abs (minutes1-minutes2);
int dNext=minutesInWeek-d;
return d<dNext?d:dNext;
}

Итак, рассчитайте из вашего фактического времени minOfWeek, скормите его всеми своими 3 раза в неделю на bestDistance и возьмите наименьшее число …

Стандартная библиотека C ++ позволяет решить эту проблему довольно элегантно, перенеся «волшебство» сравнения дат в функтор и используя std::sort перегрузка, которая принимает пользовательский компаратор.

Вот как вы можете сделать это с помощью всего лишь нескольких строк кода (ссылка на быстрый тест на ideone):

class ClosestTo {
int minute_now;
int abs_minute(const SYSTEMTIME& t) const {
return 60 * (24 * t.wDayOfWeek + t.wHour) + t.wMinute;
}
int diff_to_now(const SYSTEMTIME& t) const {
int res = abs_minute(t) - minute_now;
// Has the date passed this week?
if (res < 0) {
// Yes, the date has passed - move to next week:
res += 7*24*60;
}
return res;
}
public:
ClosestTo(const SYSTEMTIME& now)
:   minute_now(abs_minute(now)) {
}
// This is the operator the std::sort is going to call to determine ordering
bool operator() (const SYSTEMTIME& lhs, const SYSTEMTIME& rhs) const {
// Pick the date implying the shortest difference to minute_now
return diff_to_now(lhs) < diff_to_now(rhs);
}
};

Вот и все, правда! С этим компаратором в руке вы можете отсортировать три даты следующим образом:

ClosestTo cmp(cTime);
sort(m_MatchTime, m_MatchTime+3, cmp);

Теперь ближайшая дата находится в нулевом индексе:

SYSTEMTIME &nearest = m_MatchTime[0];

Я пришел с алгоритмом для решения, я знаю, что это далеко не самый профессиональный способ сделать это, но пока он безупречен.

int main()
{
SYSTEMTIME m_MatchTime[3];// Monday: 00:00
m_MatchTime[0].wDayOfWeek = 1;
m_MatchTime[0].wHour = 22;
m_MatchTime[0].wMinute = 4;

// Sunday: 01:00
m_MatchTime[1].wDayOfWeek = 4;
m_MatchTime[1].wHour = 1;
m_MatchTime[1].wMinute = 0;

// Wednesday: 15:30
m_MatchTime[2].wDayOfWeek = 6;
m_MatchTime[2].wHour = 15;
m_MatchTime[2].wMinute = 30;

// Sunday 23:00
SYSTEMTIME cTime;
cTime.wDayOfWeek = 3;
cTime.wHour = 14;
cTime.wMinute = 5;

/*  std::cout << timediff_2(cTime, m_MatchTime[0]) << "\n";
std::cout << timediff_2(cTime, m_MatchTime[1]) << "\n";
std::cout << timediff_2(cTime, m_MatchTime[2]) << "\n";*/

vector<size_t>m_Time;
if( cTime.wDayOfWeek == 0 )
{
for( int i =0; i<3; i++ )
{
if( cTime.wDayOfWeek >= m_MatchTime[i].wDayOfWeek )
m_Time.push_back( timediff_2(cTime, m_MatchTime[i]) );
}

if( m_Time.size() == 0 ) //trim right
{
for( int i =0; i<3; i++ )
{
if( cTime.wDayOfWeek <= m_MatchTime[i].wDayOfWeek )
m_Time.push_back( timediff_2(cTime, m_MatchTime[i]) );
}
}
}
else
{
for( int i =0; i<3; i++ )
{
if( cTime.wDayOfWeek <= m_MatchTime[i].wDayOfWeek )
m_Time.push_back( timediff_2(cTime, m_MatchTime[i]) );
}

if( m_Time.size() == 0 ) //trim right
{
for( int i =0; i<3; i++ )
{
if( cTime.wDayOfWeek >= m_MatchTime[i].wDayOfWeek )
m_Time.push_back( timediff_2(cTime, m_MatchTime[i]) );
}
}
}std::sort( m_Time.begin(), m_Time.end() );

SYSTEMTIME nearest;
if( m_Time.size() > 0 )
{
for( int l=0; l<3; l++ )
{
if( timediff_2( cTime, m_MatchTime[l] ) == m_Time.at(0) )
{
nearest = m_MatchTime[l];
break;
}
}
}

unsigned int manydaysleft = howmanydaysuntil(  nearest.wDayOfWeek , cTime.wDayOfWeek );
unsigned int manyhoursleft = howmanyhoursuntil(  nearest.wHour, cTime.wHour );
if( nearest.wHour < cTime.wHour ) //manydaysleft will always be > 0
manydaysleft--;
unsigned int manyminutesleft = howmanyminutesuntil( nearest.wMinute, cTime.wMinute );
if( nearest.wMinute < cTime.wMinute )
manyhoursleft--;/*cout
<< manydaysleft << endl
<< manyhoursleft << endl
<< manyminutesleft << endl;*/

cout << "CurrentTime\n"<< "Day:" << cTime.wDayOfWeek
<< "Hour:" << cTime.wHour
<< "Min:" << cTime.wMinute

<< "\nDay:" << nearest.wDayOfWeek
<< "Hour:" << nearest.wHour
<< "Min:" << nearest.wMinute

<< "\nDay:" << manydaysleft
<< "Hour:" << manyhoursleft
<< "Min:" << manyminutesleft;

return 0;
}

const unsigned n=3; //replace with actual array size

auto packtime = [](const SYSTEMTIME& t)->unsigned
{
return t.wDayOfWeek*24*60 + t.wHour*60 + t.wMinute;
};
auto unpacktime = [](unsigned total)->SYSTEMTIME
{
SYSTEMTIME ret;

ret.wDayOfWeek = total/(60*24);
total %= (60*24);
ret.wHour = total/60;
ret.wMinute = total%60;

return ret;
};

unsigned const wraptime = 7*24*60;
unsigned targettime = packtime(cTime);

unsigned mintimedif = wraptime + 1;
unsigned mindifidx;
unsigned timedif;

for(unsigned i=0; i<n; ++i)
{
timedif = packtime(m_MatchTime[i]);

if(timedif < targettime)
timedif = targettime - timedif;
else
timedif = wraptime - timedif + targettime;

if(timedif < mintimedif)
{
mintimedif = timedif;
mindifidx = i;
}
}

SYSTEMTIME dif = unpacktime(mintimedif);

std::cout<<"Today: Day "<<cTime.wDayOfWeek<<" Hour "<<cTime.wHour<<" Minute "<<cTime.wMinute<<std::endl;
std::cout<<"Nearest day: Day "<<m_MatchTime[mindifidx].wDayOfWeek<<" Hour "<<m_MatchTime[mindifidx].wHour<<" Minute "<<m_MatchTime[mindifidx].wMinute<<std::endl;
std::cout<<"Difference: "<<dif.wDayOfWeek<<" days "<<dif.wHour<<" hours "<<dif.wMinute<<" minutes"<<std::endl;</code>