python小练习（027）：计算时钟上时针走一圈有多少次与分针重叠

jerryxjr1220

python小练习（026）用python求解喝汽水问题，传送门

今天的小练习我们来计算一下时钟上时针走一圈（12小时），有多少次与分针重叠，重叠时分别是几点几分几秒？（精确到+/-1秒）
注：时钟为机械式时针，时针和分针会缓慢随秒针的走动而走动。

jerryxjr1220

预留2楼，再附送一个LCD小时钟

有树莓派的鱼油，可以直接做成LCD小台钟哦。

1. import time
   
2. import os
   
3. 
   
4. lcd={0:[' _  ','| | ','|_| '],\
   
5.      1:['    ','  | ','  | '],\
   
6.      2:[' _  ',' _| ','|_  '],\
   
7.      3:[' _  ',' _| ',' _| '],\
   
8.      4:['    ','|_| ','  | '],\
   
9.      5:[' _  ','|_  ',' _| '],\
   
10.      6:[' _  ','|_  ','|_| '],\
    
11.      7:[' _  ','  | ','  | '],\
    
12.      8:[' _  ','|_| ','|_| '],\
    
13.      9:[' _  ','|_| ',' _| ']}
    
14. 
    
15. def number2lcd(n):
    
16.     global lcd
    
17.     output = ['','','']
    
18.     l = len(str(n))
    
19.     while True:
    
20.         i = n // 10**(l-1)
    
21.         for j in range(3):
    
22.             output[j] += lcd[i][j]
    
23.         n = n % 10**(l-1)
    
24.         l -= 1
    
25.         if l == 0:
    
26.             break
    
27.     return output
    
28. 
    
29. def clock():
    
30.     t = time.localtime()
    
31.     hour = number2lcd(t.tm_hour)
    
32.     minute = number2lcd(t.tm_min)
    
33.     second = number2lcd(t.tm_sec)
    
34.     output = [hour[0]+' '+minute[0]+' '+second[0],hour[1]+'.'+minute[1]+'.'+second[1],hour[2]+'.'+minute[2]+'.'+second[2]]
    
35.     return output
    
36. 
    
37. while True:
    
38.     o = os.system('cls')
    
39.     for each in clock():
    
40.         print (each)
    
41.     time.sleep(1)

复制代码

冬雪雪冬

题目很简单，但调试花了很长的时间，主要是偏差值的确定，1e-3会多出许多临近的值，1e-4则又丢掉一些需要的值。

1. s = 43200
   
2. count = 0
   
3. temp = ''
   
4. for i in range(s):
   
5.     h = i / s
   
6.     m = (i / 3600) % 1
   
7.     if abs(h - m ) < 1.2e-4:
   
8.         count += 1
   
9.         print('%2d:%02d:%02d'%(i / 3600, (i / 60) % 60, i % 60))
   
10. print('共计%d次时针与分针重叠'%count)

复制代码

1.   0:00:00
   
2. 1:05:27
   
3. 2:10:55
   
4. 3:16:22
   
5. 4:21:49
   
6. 5:27:16
   
7. 6:32:44
   
8. 7:38:11
   
9. 8:43:38
   
10. 9:49:05
    
11. 10:54:33
    
12. 共计11次时针与分针重叠

复制代码

米饭不回家

高手在民间

jerryxjr1220

冬雪雪冬 发表于 2016-11-28 22:13
题目很简单，但调试花了很长的时间，主要是偏差值的确定，1e-3会多出许多临近的值，1e-4则又丢掉一些需要的 ...

完全正确

jerryxjr1220

版主大大的代码比我的简洁，我的也贴一下吧。

1. #coding:utf-8
   
2. '''
   
3. 计算时钟上时针走一圈（12小时），有多少次与分针重叠，重叠时分别是几点几分几秒？
   
4. 注：时钟为机械式时针，时针和分针会缓慢随秒针的走动而走动
   
5. '''
   
6. 
   
7. class clocks:
   
8.     def __init__(self):
   
9.         self.hour = 0
   
10.         self.minute = 0
    
11.         self.second = 0
    
12.         self.h_ang = 0
    
13.         self.m_ang = 0
    
14.     def calc(self):
    
15.         self.h_ang = self.hour*30+self.minute*30/60+self.second/60*(30/60)
    
16.         self.m_ang = self.minute*360/60+self.second*(360/60)/60
    
17.     def run(self):
    
18.         self.second += 1
    
19.         self.minute += self.second // 60
    
20.         self.second %= 60
    
21.         self.hour += self.minute // 60
    
22.         self.minute %= 60
    
23. flag = 1
    
24. count = 0
    
25. clock = clocks()
    
26. while clock.hour < 12:
    
27.     clock.calc()
    
28.     if flag == 0:
    
29.         if 0 < clock.h_ang - clock.m_ang < 0.1:
    
30.             flag = 1
    
31.         else:
    
32.             flag = 0
    
33.     else:
    
34.         count += 1
    
35.         print ('%d时%d分%d秒，时针与分针重叠' % (clock.hour,clock.minute,clock.second))
    
36.         flag = 0
    
37.     clock.run()
    
38. print ('时针与分针总共重合了%d次' % count)

复制代码

输出：
0时0分0秒，时针与分针重叠
1时5分28秒，时针与分针重叠
2时10分55秒，时针与分针重叠
3时16分22秒，时针与分针重叠
4时21分49秒，时针与分针重叠
5时27分17秒，时针与分针重叠
6时32分44秒，时针与分针重叠
7时38分11秒，时针与分针重叠
8时43分39秒，时针与分针重叠
9时49分6秒，时针与分针重叠
10时54分33秒，时针与分针重叠
时针与分针总共重合了11次

冬雪雪冬

我也写个LCD时钟。

1. import time
   
2. import os
   
3. font =""" _     _  _     _  _  _  _  _   
   
4. | |  | _| _||_||_ |_   ||_||_| .
   
5. |_|  ||_  _|  | _||_|  ||_| _| . """
   
6. 
   
7. while True:
   
8.     t = time.localtime()
   
9.     t_str = '%02d:%02d:%02d'%(t[3], t[4], t[5])
   
10.     os.system('cls')
    
11.     for line in range(3):
    
12.         for n in t_str:
    
13.             if n == ':':
    
14.                 n = 10
    
15.             print(font[34 * line + int(n) * 3: 34 * line + int(n) * 3 + 3], end = '')
    
16.         print()
    
17.     time.sleep(1)

复制代码

余欲渔

分钟12圈，时钟1圈，所以肯定是11次相遇，然后直接佣秒钟来算结果，最后在秒位上+0.5以四舍五入

1. for i in range(11):
   
2.     print('%d时%d分%d秒'%(((3927.27*i)//3600),((3927.27*i)%3600)//60,(3927.27*i+0.5)%60))

复制代码

1. = RESTART: C:/Users/ASUS/AppData/Local/Programs/Python/Python35-32/时钟分钟相遇.py =
   
2. 0时0分0秒
   
3. 1时5分27秒
   
4. 2时10分55秒
   
5. 3时16分22秒
   
6. 4时21分49秒
   
7. 5时27分16秒
   
8. 6时32分44秒
   
9. 7时38分11秒
   
10. 8时43分38秒
    
11. 9时49分5秒
    
12. 10时54分33秒
    
13. >>>

复制代码

余欲渔

上面是用秒算的，似乎用分钟算更简单

1. for i in range(11):
   
2.     print('%d时%d分%d秒'%(i,60*i/11,(60*i/11%1)*60+0.5))

复制代码