C#: Decrementando um relógio usando o Modulus Math

Question

Tentando imitar a rolagem de um relógio de 24 horas à mão (com matemática versus uso das classes de tempo). A parte incrementadora foi fácil de descobrir como rolar das 23:00 às 0:00 e de, mas fazer com que ele vá para o outro lado está se tornando realmente confuso. Aqui está o que tenho até agora:

static void IncrementMinute(int min, int incr)
{
    int newMin = min + incr,
                hourIncrement = newMin / 60;

    //increment or decrement the hour
    if((double)newMin % 60 < 0 && (double)newMin % 60 > -1)
        hourIncrement = -1;

    Console.WriteLine("Hour increment is {0}: ", hourIncrement);
}

O problema que estou descobrindo é quando voltar para trás, se o módulo de IS entre os números, ele não diminuirá corretamente. Exemplo: São 12:00 e você subtraia 61 minutos, sabemos que o tempo seria 10:59, pois a hora deve voltar 1 hora para passar das 12:00 às 11:59, depois de volta por ir a partir das 11:00 a 10:59. Infelizmente, a maneira como estou calculando -o: Newmin % 60 neste caso, pega apenas a primeira hora, mas como a segunda reversão é tecnicamente -1,0166 como um restante e, como o MOD retorna apenas um número inteiro, está arredondando. Tenho certeza de que estou perdendo alguma matemática básica aqui, mas alguém poderia me ajudar?

EDIT: Eu escrevi isso de várias maneiras longas e curtas. Alguns estão mais próximos que outros, mas eu sei que isso é mais simples do que parece. Eu sei que esse parece "o que ele estava fazendo", mas você deve poder ver basicamente o que estou tentando fazer. É fácil incrementar um relógio e fazer uma rolagem de 23:59 às 0:00. Voltar para trás provou não ser tão fácil.

Ok, aqui está o minuto incremento com a rolagem. Simples. Mas tente voltar para trás. Não funciona.

static void IncrementMinute(int min, int incr)

        {
            int newMin = min + incr,
                hourIncrement = newMin / 60;

            min = newMin % 60;

            Console.WriteLine("The new minute is {0} and the hour has incremented by {1}", min, hourIncrement);
        }

Answer 1

Eu iria para algo um pouco mais simples

public class Clock
{
    public const int HourPerDay = 24;
    public const int MinutesPerHour = 60;
    public const int MinutesPerDay = MinutesPerHour * HourPerDay;

    private int totalMinutes;

    public int Minute
    {
        get { return this.totalMinutes % MinutesPerHour; }
    }

    public int Hour
    {
        get { return this.totalMinutes / MinutesPerHour; }
    }

    public void AddMinutes(int minutes)
    {
        this.totalMinutes += minutes;
        this.totalMinutes %= MinutesPerDay;
        if (this.totalMinutes < 0)
            this.totalMinutes += MinutesPerDay;
    }

    public void AddHours(int hours)
    {
        this.AddMinutes(hours * MinutesPerHour);
    }

    public override string ToString()
    {
        return string.Format("{0:00}:{1:00}", this.Hour, this.Minute);
    }
}

Uso de amostra:

new Clock().AddMinutes(-1);    // 23:59
new Clock().AddMinutes(-61);   // 22:59
new Clock().AddMinutes(-1441); // 23:59
new Clock().AddMinutes(1);     // 00:01
new Clock().AddMinutes(61);    // 01:01
new Clock().AddMinutes(1441);  // 00:01

Answer 2

Você pode tentar calcular os incrementos de minuto e hora primeiro e depois lidar com casos em que os novos minutos passam por uma hora, algo assim:

int hourIncrement = incr / 60;
int minIncrement = incr % 60;

int newMin = min + minIncrement;

if (newMin < 0)
{
    newMin += 60;
    hourIncrement--;
}
else if (newMin > 60)
{
    newMin -= 60;
    hourIncrement++;
}

Editar

Eu gosto da resposta @Ben Voigts, mas queria saber se haveria alguma diferença no desempenho. Eu executei o aplicativo de console abaixo para cronometrar os dois e fiquei um pouco surpreso com os resultados.

• 40 ms para o código acima
• 2876 ms para a resposta de Ben

Isso foi feito em uma versão de lançamento. Alguém mais pode executar isso e confirmar? Estou cometendo erros na maneira como eu os cronometrar?

using System;
using System.Diagnostics;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Stopwatch sw = new Stopwatch();

            int max = 100000000;

            sw.Start();
            for (int i = 0; i < max; i++)
                IncrementMinute1(0, -61);
            sw.Stop();

            Console.WriteLine("IncrementMinute1: {0} ms", sw.ElapsedMilliseconds);

            sw.Reset();

            sw.Start();
            for (int i = 0; i < max; i++)
                IncrementMinute2(0, -61);
            sw.Stop();

            Console.WriteLine("IncrementMinute2: {0} ms", sw.ElapsedMilliseconds);

            Console.ReadLine();
        }

        static void IncrementMinute1(int min, int incr)
        {
            int hourIncrement = incr / 60;
            int minIncrement = incr % 60;

            int newMin = min + minIncrement;

            if (newMin < 0)
            {
                newMin += 60;
                hourIncrement--;
            }
            else if (newMin > 60)
            {
                newMin -= 60;
                hourIncrement++;
            }
        }

        static void IncrementMinute2(int min, int incr)
        {
            min += incr;
            int hourIncrement = (int)Math.Floor(min / 60.0);
            min -= hourIncrement * 60;
        }
    }
}

Answer 3

A matemática modular é definida apenas para os números inteiros. Se você estiver tentando misturar aritmética modular com números reais, não terá sucesso. Você precisa descobrir uma abordagem matemática diferente.

Answer 4

Tentar

        int newMin = min + incr,
            hourIncrement = (int)Math.Floor(newMin / 60.0);

        min -= hourIncrement * 60;

O problema essencial era que você quer hourIncrement Para completar, mas a divisão inteira rodadas em direção a zero. Eles são iguais com números positivos, mas não para negativos ...

Editar (livrar -se da variável extra inútil):

    min += incr;
    int hourIncrement = (int)Math.Floor(min / 60.0);
    min -= hourIncrement * 60;

Edit2 (Evite aritmética de ponto flutuante):

    min += incr;
    int hourIncrement = min / 60;
    min -= hourIncrement * 60;
    if (min < 0) { min += 60; --hourIncrement; }

Answer 5

Por que complicar coisas

public System.Timers.Timer timer = new System.Timers.Timer(1000);
public DateTime d;

public void init()
{
timer.Elapsed += new System.Timers.ElapsedEventHandler(timer_Elapsed);

d = new DateTime(2011, 11, 11, 23, 59, 50);
d=d.AddHours(1);
Console.Writeline(d);
d=d.AddHours(-2);
Console.Writeline(d);
timer.Enabled = true;
}
   void timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
    {
        this.Dispatcher.Invoke(DispatcherPriority.Normal, (Action)(() =>
        {
            MoveClockHands();
            d=d.AddSeconds(1);
            Console.WriteLine(d);

        }));
    }

    void MoveClockHands()  //12 hours clock
    (
       s=d.Second * 6;
       m=d.Minute * 6;
       h=0.5 * ((d.Hour % 12) * 60 + d.Minute)
    }