6

尝试手动模拟 24 小时时钟的翻转（使用数学与使用时间跨度类）。递增部分很容易弄清楚如何从 23:00 翻转到 0:00 以及从 0:00 开始，但是让它走另一条路却变得非常令人困惑。这是我到目前为止所拥有的：

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);
}

我发现的问题是当倒退时，如果模数在数字之间，它不会正确递减。示例：现在是 12:00，减去 61 分钟，我们知道时间将是 10:59，因为从 12:00 到 11:59 小时应该回滚 1 小时，然后从 11:00 回滚到 10 点 59 分。不幸的是，我计算它的方式：在这种情况下，newMin % 60 只获取第一个小时的回滚，但是由于第二个回滚在技术上是 -1.0166 作为余数，并且由于 mod 只返回一个整数，所以它四舍五入。我确定我在这里错过了一些基本的数学，但有人可以帮助我吗？

编辑：我已经用多种方式写了这篇文章。有些比其他的更接近，但我知道这比看起来更简单。我知道这似乎有点“他在做什么”，但你应该能够基本上看到我想要做什么。增加时钟并将其从 23:59 翻转到 0:00 很容易。事实证明，倒退并不容易。

好的，这是带有翻转的 incrementMinute。简单的。但试着倒退。不工作。

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);
        }
4

5 回答 5

2

我会去做一些更简单的事情

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);
    }
}

示例用法：

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
于 2010-11-21T01:10:44.750 回答
1

您可以先尝试计算分钟和小时的增量，然后处理新分钟跨越小时边界的情况，如下所示：

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++;
}

编辑

我喜欢@Ben Voigts 的回答，但想知道性能是否会有所不同。我在下面运行控制台应用程序来为它们计时，结果有点惊讶。

  • 上面的代码需要 40 毫秒
  • 本的回答需要 2876 毫秒

这是在发布版本中完成的。其他人可以运行并确认吗？我在计时的方式上是否犯了任何错误？

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;
        }
    }
}
于 2010-11-21T00:55:11.153 回答
0

尝试

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

        min -= hourIncrement * 60;

基本问题是您想hourIncrement向下舍入，但整数除法向零舍入。它们与正数相同，但对于负数则不然...

编辑（摆脱无用的额外变量）：

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

EDIT2（避免浮点运算）：

    min += incr;
    int hourIncrement = min / 60;
    min -= hourIncrement * 60;
    if (min < 0) { min += 60; --hourIncrement; }
于 2010-11-21T00:59:59.210 回答
0

模数学只为整数定义。如果您试图将模运算与实数混合使用，您将不会成功。你需要找出一种不同的数学方法。

于 2010-11-21T00:34:54.227 回答
0

为什么要把事情复杂化

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)
    }
于 2012-02-21T18:09:16.003 回答