using System; using System.Collections.Generic; using System.Text;namespace Reclosing { class Program { static void Main(string[] args) { for (int h = 0; h < 120; h += 5) { for (int m = 0; m < 60; m++) { for (int s = 0; s < 60; s++) { if (((h >= 60) ? h - 60 : h) == m && m == s) Console.WriteLine(h / 5 + ":" + m + ":" + s); } } } Console.Read(); } } }
http://lakeinmoon.bokee.com/6159214.html
http://www.simpleness.com.cn/view/23/1.aspx
List<double> Timeslap(double wf, double ws) { var n = (int)(24 * 3600 * wf / 360); var times = new List<double>(n); for (int k = 0; k < n - 1; k++) { var t = 360 * (k - (int)(k * ws / wf)) / (wf - ws); if (times.Count == 0 || times[times.Count - 1] != t) times.Add(t); } return times; } 时针和分针相遇22次
这是一个推理题目设计小时为A 分钟为B 他们都在围着圈跑 a 跑一圈（12小时） B 要跑12圈 则一个起跑点开跑，A跑一圈 b将追上a 11次又回到原点 A 再跑一圈为上一次的重复 算上起点重合一共12次 由于A B 是匀速的，则B 追上A 的位置必然均分在这个圈上 就是将这个圈12等分分钟和秒 B 为分钟 C 为秒 我们发现 同样 B 跑一圈（1小时） C 同样要跑60圈 则一个起跑点开跑，B跑一圈 c将追上B 59次又回到原点 A 再跑一圈为上一次的重复 算上起点重合一共60次 由于B C 是匀速的，则C 追上A 的位置必然均分在这个圈上 就是将这个圈60等分12等分与60等分一个圈 起点相同必须重合12下则一天有24次重合由于 00：00：00做为一天的开始 那么24：00：00就不能做为一天的结束，只能做为下一天的开始 那么一共23次
这是一个推理题目设计小时为A 分钟为B 他们都在围着圈跑 a 跑一圈（12小时） B 要跑12圈 则一个起跑点开跑，A跑一圈 b将追上a 11次又回到原点 A 再跑一圈为上一次的重复 算上起点重合一共12次（这里不能算）11次只能是 由于A B 是匀速的，则B 追上A 的位置必然均分在这个圈上 就是将这个圈11等分分钟和秒 B 为分钟 C 为秒 我们发现 同样 B 跑一圈（1小时） C 同样要跑60圈 则一个起跑点开跑，B跑一圈 c将追上B 59次又回到原点 A 再跑一圈为上一次的重复 算上起点重合一共60次（不能算 只能是59） 由于B C 是匀速的，则C 追上A 的位置必然均分在这个圈上 就是将这个圈59等分则起点相同一个11等分和圈子和一个59等分的圈子 必然只有起点重合晕 答案是一次
这要看什么叫做“重合”？我写的程序：using System; using System.Linq;namespace ConsoleApplication1 { class Program { static void Main(string[] args) { int 精度 = 120; int i = 0; (from sec in Enumerable.Range(0, 24 * 60 * 60 - 1) let harc = (sec / 12 / 3600.0 - (int)(sec / 12 / 3600.0)) * 精度 let marc = (sec / 3600.0 - (int)(sec / 3600.0)) * 精度 where Math.Abs(harc - marc) <= 1 let sarc = (sec / 60.0 - (int)(sec / 60.0)) * 精度 where Math.Abs(marc - sarc) <= 1 select new TimeSpan(0, 0, sec)) .ToList() .ForEach(t => { Console.WriteLine("{0}\t{1}", ++i, t); }); Console.ReadKey(); } } } 调整你的“精度”来看看（或者这里的精度还有其它控制方法？）
using System;
using System.Collections.Generic;
using System.Text;namespace Reclosing
{
class Program
{
static void Main(string[] args)
{
for (int h = 0; h < 120; h += 5)
{
for (int m = 0; m < 60; m++)
{
for (int s = 0; s < 60; s++)
{
if (((h >= 60) ? h - 60 : h) == m && m == s)
Console.WriteLine(h / 5 + ":" + m + ":" + s);
}
}
}
Console.Read(); }
}
}
{
var n = (int)(24 * 3600 * wf / 360);
var times = new List<double>(n);
for (int k = 0; k < n - 1; k++)
{
var t = 360 * (k - (int)(k * ws / wf)) / (wf - ws);
if (times.Count == 0 || times[times.Count - 1] != t) times.Add(t);
}
return times;
}
时针和分针相遇22次
当然这些都是不取整的时候，精确到小数点后面N位吧
如果对time.ss取整后又如何
这23次中到底有哪个秒是整数这就的我们程序人员去找方法处理了吧
算上起点重合一共12次
由于A B 是匀速的，则B 追上A 的位置必然均分在这个圈上 就是将这个圈12等分分钟和秒 B 为分钟 C 为秒 我们发现 同样 B 跑一圈（1小时） C 同样要跑60圈
则一个起跑点开跑，B跑一圈 c将追上B 59次又回到原点 A 再跑一圈为上一次的重复
算上起点重合一共60次
由于B C 是匀速的，则C 追上A 的位置必然均分在这个圈上 就是将这个圈60等分12等分与60等分一个圈 起点相同必须重合12下则一天有24次重合由于 00：00：00做为一天的开始 那么24：00：00就不能做为一天的结束，只能做为下一天的开始
那么一共23次
算上起点重合一共12次（这里不能算）11次只能是
由于A B 是匀速的，则B 追上A 的位置必然均分在这个圈上 就是将这个圈11等分分钟和秒 B 为分钟 C 为秒 我们发现 同样 B 跑一圈（1小时） C 同样要跑60圈
则一个起跑点开跑，B跑一圈 c将追上B 59次又回到原点 A 再跑一圈为上一次的重复
算上起点重合一共60次（不能算 只能是59）
由于B C 是匀速的，则C 追上A 的位置必然均分在这个圈上 就是将这个圈59等分则起点相同一个11等分和圈子和一个59等分的圈子
必然只有起点重合晕 答案是一次
using System.Linq;namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
int 精度 = 120;
int i = 0;
(from sec in Enumerable.Range(0, 24 * 60 * 60 - 1)
let harc = (sec / 12 / 3600.0 - (int)(sec / 12 / 3600.0)) * 精度
let marc = (sec / 3600.0 - (int)(sec / 3600.0)) * 精度
where Math.Abs(harc - marc) <= 1
let sarc = (sec / 60.0 - (int)(sec / 60.0)) * 精度
where Math.Abs(marc - sarc) <= 1
select new TimeSpan(0, 0, sec))
.ToList()
.ForEach(t => { Console.WriteLine("{0}\t{1}", ++i, t); });
Console.ReadKey();
}
}
}
调整你的“精度”来看看（或者这里的精度还有其它控制方法？）
思路就是 1天24小时，从起点开始，每过1小时（不到2小时），分钟与时钟重叠一次（瞬间重叠也算）。
这样 （0+1）×24 = 24 次。
如果要求只计算在某个刻点上的重叠，那么justfortemp的第二个答案计算方法。不过得考虑起点，这样就是2次重叠。即0点和12点。
分针：w2= 360 / 3600 = 0.1 d/s
秒针：w3 = 360 / 60 = 6 d/s
大师这样的计算也是不无道理
那我在后面都乘以60s*60m*12h/360°*(24/12)
那结果是不是
时针：2圈
分针:12*2圈
秒针:60*12*2圈
所以这样的表达只能用于计算了
呵呵看不出实际的……当然我们都知道它重叠了24圈（其中包括00:00:00）
只是重合时秒位的数值是否为正整数或零
这也是我们输出结果的关键
一个圆周长3600*12 米
h m S 三人赛跑
三人都跑一周，则三人的速度为时钟费时12小时 12*3600秒 分钟费时一小时 3600秒 秒钟费时一分钟 60秒
时钟速度 3600*12/(3600*12)=1米每秒
分钟速度 3600*12/3600=12米每秒
秒钟速度 3600*12/60=720米每秒 h m S 三人赛跑三人同一起点一起跑12小时后回到起点
-------------------
来看分钟和时钟的赛跑
h跑1圈要12小时 m跑一圈要一小时
一天：h跑24小时2圈 m跑24小时 24圈
则从起点开始（追上次数为0）m 每追上 h一次就比h多跑一圈
m一共比h多跑22圈 则m追上h次数为22次
24小时两人同时回到起点
则 设起点时间为0 设m 第一次追上h的时间为X1 追上时他们跑的距离一样
设员的周长为L=3600*12
则 X1*1 +L = X1*12;
X1=L/11
则在3600*12/11秒的时候 h m 离开起点后第一次相遇
此时他们重合国，则下一个X1秒后 h m又将再一次相遇
则时钟和分钟重合的时间分别为
0， 3600*12*1/11 ,3600*12*2/11..... 3600*12*11/11 （24小时内，则到3600*12*22/11)
--------------------------------------------------
再来看分钟和秒钟的赛跑
s跑1圈要一分钟 1/60小时 m跑一圈要一小时
一天：S跑24小时 24*60=1440圈 m跑24小时 24圈
则从起点开始（追上次数为0）m 每追上 h一次就比h多跑一圈
m一共比h多跑1416圈 则m追上h次数为1416次
24小时后两人又回到起点
则 设起点时间为0 设s 第一次追上m的时间为X1 追上时他们跑的距离一样
设员的周长为L=3600*12
则 X1*12 +L = X1*720;
X1=L/708
则在3600*12/708=3600/59秒的时候 s m 离开起点后第一次相遇
此时他们重合，则下一个X1秒后 s m又将再一次相遇
则秒和分钟重合的时间分别为
0， 3600*1/59 ,3600*2/59..... （24小时内，则到3600*1416/59)则要想三针重合 时钟与分钟相遇的时间要与 秒钟与分钟相遇的时间相同
由于 59与11互相为质数
则要重置分子分母比较
0，3600*12*1*59/(11*59)，.....3600*12*22*59/(11*59)
0, 3600*1*11/(11*59), ....3600*1416*11/(59*11)
即比较
0，12*1*59，。12*22*59---》》》0，708*1，708*2.708*22
0，1*11， 1416*11 ---》》》0，11*1，11*2，11*1416
所以重合时间点为
0， 708*11 708*22
0 11*354 11*1416
加上舍去的分子分母和3600
对应的真实重合时间为
0 秒重合，
3600 *708*11/(11*59)=43200秒=3600*12=12小时 重合
24小时重合一天24小时 0秒重合算当天 24小时重合算下一天，则一共重合两次
楼上的鼓励下
加油
相信你ganggang的~
其次是一天运行的次数：24（小时）*60（分）*60（秒）-1
再次是：每运行一秒：秒针转360/60度，分针转360/60度，时针转360/12度
接现就是if了，运行了N秒：秒针所在度数：(N*6)模360 分针度数：（N/60*6）模360 时针度数（N/3600*30)模360
三者完全相等就是重合一次，完毕。
设w为时针的角速度，（每小时为30度），w1为时针的角速度（每小时为360度）
w=30度/小时=(1/120)度/秒
w1=360度/小时=（12/120）度/秒
假设他们在零时零分零秒汇合后！开始出发，用了t秒分针和秒针重合
则有 w1*t-w*t=360*k(k=1，2，3，4，5，........)
数字带入以后得
11/120*t=360*k
t=](120*360)/11]*k（秒）
由于时间的单位只能是单位秒，就是t为整数！
/**不知道t必须为整数的人，可以不用看了，你的智商不会看的懂得**/
由此可知 k必须为11的倍数
当k=11时
t=120*360=60*60*12(秒)
t=12(小时)
k=22时
t=24（小时）
所以一天时针和分针的重合时间分别为0：0：0 和12：0：0 和0：0：0
下面考虑秒针，当时针和分针在上述时间重合时 秒针正好指向12点 而时针 分针也分别指向12点
故 在24小时内时针 分针 秒针 重和的时间为0：0：0 和12：0：0 和0：0：0
由于一天中 刚到0：0：0时是一天的开始 一天的最后一秒是24：59：59--0：0：0之间的这一秒
因此一天中重合次数只能为两次
正确答案为 2次
设w为时针的角速度，（每小时为30度），w1为分针的角速度（每小时为360度）
w=30度/小时=(1/120)度/秒
w1=360度/小时=（12/120）度/秒
假设他们在零时零分零秒汇合后！开始出发，用了t秒分针和时针重合
则有 w1*t-w*t=360*k(k=1，2，3，4，5，........)
数字带入以后得
11/120*t=360*k
t=[(120*360)/11]*k（秒）
由于时间的单位只能是单位秒，就是t为整数！
/**不知道t必须为整数的人，可以不用看了，你的智商不会看的懂得**/
由此可知 k必须为11的倍数
当k=11时
t=120*360=60*60*12(秒)
t=12(小时)
k=22时
t=24（小时）
所以一天时针和分针的重合时间分别为0：0：0 和12：0：0 和0：0：0
下面考虑秒针，当时针和分针在上述时间重合时 秒针正好指向12点 而时针 分针也分别指向12点
故 在24小时内时针 分针 秒针 重和的时间为0：0：0 和12：0：0 和0：0：0
由于一天中 刚到0：0：0时是一天的开始 一天的最后一秒是24：59：59--0：0：0之间的这一秒
因此一天中重合次数只能为两次
正确答案为 2次
#include<stdio.h>void main()
{
int c=0;
int t;
int pai=360*600;//钟的周长36o度，扩大600倍for(t=0;t>=0&&t<(24*60*60);t++) //一天中需要走24*60*60秒
{
//秒针的角速度为每秒走3600度
//分针为60度
//时针为5度
//他们的速度比是1：12：720
//3600*t,60*t，5*t分别表示当前秒，分，时针走的角度
if(((3600*t%pai)==(60*t%pai))&&((60*t%pai)==(5*t%pai)))//对周长360*600度取余后，相等则表示重叠
{
printf("%d秒\n",t);//输出重叠时花的时间
c+=1;//累计次数
}}
printf("重叠%d次",c);
}
/code]
上面的解法结果是：
0秒
43200秒
重叠2次也就是开始的那一刻和12点的时候。
#include<stdio.h>void main()
{
int c=0;
int t;
int pai=360*600;//钟的周长36o度，扩大600倍for(t=0;t>=0&&t<(24*60*60);t++) //一天中需要走24*60*60秒
{
//秒针的角速度为每秒走3600度
//分针为60度
//时针为5度
//他们的速度比是1：12：720
//3600*t,60*t，5*t分别表示当前秒，分，时针走的角度
if(((3600*t%pai)==(60*t%pai))&&((60*t%pai)==(5*t%pai)))//对周长360*600度取余后，相等则表示重叠
{
printf("%d秒\n",t);//输出重叠时花的时间
c+=1;//累计次数
}}
printf("重叠%d次",c);
}
重贴代码