Python 练习题

一棵菠菜

没看到后几页，原来已经写完了 ，囧啊

古龙想的回忆

def findlastpeople():
    total=range(1,101)
    i=2
    while len(total)>1:
        total=total[1:101:2]
    a=total[0]
    print(a)
findlastpeople()
   

我要吃西瓜

大家貌似都是比较依赖各种函数~说一个简单一点的~更依赖于算法~2的n次方＜100，而2的n次方就是剩下的最后一个人，100以内是第64个人，也就是2的6次方~

Hadron74

回复 33# 我要吃西瓜

你这个答案是最牛的，真正的数学，我用程序测试了一下，一万以内是正确的。如果可能你能给出证明吗？你又是怎么想到的呢？谢谢，学习了。
   

icymirror

因为：第一个开始枪毙，每枪毙一个跳过一个(相当于对2求余，余数为1则干掉)
所以，当总人数<2^(n+1), n=1时结果显然成立。

假设当 n = k 时结果成立，此时，不妨设: 总人数为 T = 2 ^ (k+1) - 1
则，当n=k+1时，
在所有 2 ^ (k+1) < T < 2 ^ (k + 2)的数中，
只有 2^(K+1) 对包含2的因子数>2^k,
所以，当2^k这位被干掉时，2^(k+1)这位还活着，
又：在范围2 ^ (k+1) < T < 2 ^ (k + 2)中，没有其它的数字比2^(K+1)的2的因子数多，
所以，最后剩下来的是 2^(k+1)这位。

联合上面两个，可以得出，在给定数的范围内中，2^n的值最大的人会活下来。
(PS:考虑到 Python 下标是 0 开始的，代码的结果索引应当是 2^n-1)

yaozhibing41001

回复 1# yingweixu

1. #! /usr/bin/python
   
2. list=range(1,101)
   
3. while  len(list)>1:
   
4.     for x  in  list[0::2]:
   
5.             list.remove(x)
   
6. print list

复制代码

yjphhw

>>> def a(l=range(1,101)):
        ll=[]
        for i in range(1,len(l),2):
                ll.append(l[i])
        if len(l)==1:
                return l
        return a(ll)

>>> a()
[64]

cao627

回复 34# Hadron74

123456789......   源数据
*2*4*6*8*......   第一轮
***4***8*......   第二轮


可见 ：
第1轮后剩下的数之间隔开1个*，剩下的最小的数之前有1个*
第2轮后剩下的数之间隔开3个*，剩下的最小的数之前有3个*  
第3轮后剩下的数之间隔开7个*，剩下的最小的数之前有7个*
可概括为第n轮后剩下的数之间隔开2^n-1个*，剩下的最小的数之前有2^n-1*
于是第6轮后剩下的数之间隔开63个*，剩下的最小的数之前有63个*
63个*，然后是一个数64，然后再是63个*。127之内（当然更是100之内了）就剩下唯一的数64了


可见对于数列 [range(1,x)]   x为一整数>1
经过n轮“枪杀”过后，侥幸剩下的数的最小数之前有2^n-1个*，如果2^n-1已经大于x的一半，那么数列中就只能剩下数2^n了。

1. >>> [2**i for i in range(1,101) if  101 > 2**i > 50 ]

复制代码

这样或更有效率： 用了网上查到的方法：用i & i-1 == 0 判断一个数是否为2的n次方，原理为2的整数次方（0次方除外）i的2进制结构中必然只有一位为1,与i-1进行&与运算必然为0

1. >>> [i for i in range(50,101) if  i & i-1 == 0 ]
   

复制代码

ragkk

这个是list的基操作测试，很多人把问题复杂化了，其实很简单就可以搞定了。

1. people = [i for i in range(100)]
   
2. 
   
3. while len(people) > 1 :
   
4.     people = people[1::2]
   
5. 
   
6. print people

复制代码

Hadron74

回复 38# cao627


你的结果很有意思.兴趣所致，我稍改一下题目，看看是什么样子？

练习题：有N个人，分别从1一直到N, 站成一个圈。现在有人拿枪从第一个开始枪毙，每枪毙一个跳过一个，转圈完成。请问最后活着的是这N人里的第几个人？看谁写的简单。

我先试着写了一个：

1. for N in range(1,101):
   
2.     c = list(range(1,N+1))
   
3.     while len(c) > 1:
   
4.         c.pop(0)
   
5.         b = c.pop(0)
   
6.         c.append(b)
   
7.     print c
   

复制代码

结果很有意思：

1. 
   
2. [1]
   
3. [2]
   
4. [2]
   
5. [4]
   
6. [2]
   
7. [4]
   
8. [6]
   
9. [8]
   
10. [2]
    
11. [4]
    
12. [6]
    
13. [8]
    
14. [10]
    
15. [12]
    
16. [14]
    
17. [16]
    
18. [2]
    
19. [4]
    
20. [6]
    
21. [8]
    
22. [10]
    
23. [12]
    
24. [14]
    
25. [16]
    
26. [18]
    
27. [20]
    
28. [22]
    
29. [24]
    
30. [26]
    
31. [28]
    
32. [30]
    
33. [32]
    
34. [2]
    
35. [4]
    
36. [6]
    
37. [8]
    
38. [10]
    
39. [12]
    
40. [14]
    
41. [16]
    
42. [18]
    
43. [20]
    
44. [22]
    
45. [24]
    
46. [26]
    
47. [28]
    
48. [30]
    
49. [32]
    
50. [34]
    
51. [36]
    
52. [38]
    
53. [40]
    
54. [42]
    
55. [44]
    
56. [46]
    
57. [48]
    
58. [50]
    
59. [52]
    
60. [54]
    
61. [56]
    
62. [58]
    
63. [60]
    
64. [62]
    
65. [64]
    
66. [2]
    
67. [4]
    
68. [6]
    
69. [8]
    
70. [10]
    
71. [12]
    
72. [14]
    
73. [16]
    
74. [18]
    
75. [20]
    
76. [22]
    
77. [24]
    
78. [26]
    
79. [28]
    
80. [30]
    
81. [32]
    
82. [34]
    
83. [36]
    
84. [38]
    
85. [40]
    
86. [42]
    
87. [44]
    
88. [46]
    
89. [48]
    
90. [50]
    
91. [52]
    
92. [54]
    
93. [56]
    
94. [58]
    
95. [60]
    
96. [62]
    
97. [64]
    
98. [66]
    
99. [68]
    
100. [70]
     
101. [72]
     

复制代码

有兴趣的朋友证明一个，呵呵；抛砖引玉。