leetcode笔记--3 Niim game

question:

You are playing the following Nim Game with your friend: There is a heap of stones on the table, each time one of you take turns to remove 1 to 3 stones. The one who removes the last stone will be the winner. You will take the first turn to remove the stones.

Both of you are very clever and have optimal strategies for the game. Write a function to determine whether you can win the game given the number of stones in the heap.

For example, if there are 4 stones in the heap, then you will never win the game: no matter 1, 2, or 3 stones you remove, the last stone will always be removed by your friend.

my answer:

重点：

1 怎么计算，有些糊涂

2 python 除法

转自 https://segmentfault.com/a/1190000003912449

1.整数除法

对两个不能整除的整数做除法，就要面对舍入的问题。和大多数编程语言一样，Java的基本策略是向零取整(round to zero)，也就是向绝对值变小的方向取整。举几个香甜的小栗子：3/2=1, -3/2=-1。而对于Python而言，情况就有所不同了。

>>>-1/10
-1

显然如果按照Java的取整策略，-1/10应该得0，而Python给出的结果是-1。事实上Python的取整方式是向下取整，也就是向着数轴上负无穷的方向取整。好吧，Java和Python的取整方式不同，夺大点事儿啊…那么如果我们要在Python下采用向零取整的结果，咋整？一种比较直接的方式是：

>>>int(float(-1)/10)
0

2.取余

谁说没大事？(￣▽￣)大事来了！

Java和Python整数除法都遵循下面这个公式：

(a/b)*b+c=a

也就是说：

a mod b=c=a-(a/b)*b

这里的/表示的是整数除法。既然它们的取整方式不一样，那么取余也会受到影响：

For Java: -2 % 3==-2
For Python: -2 % 3==1

在某些实际应用中，我们可能会被要求得到一个整数的各位数字。如果输入的整数的正的，Java和Python都可以用相同的方法来解决：

def func(a):
    pos, res=1, []
    while a/pos:
        res+=(a/pos)%10,
        pos*=10
    return res

Java代码也差不多就是这样了。但如果输入的整数是一个负数，Java版本的代码还是可以得到正确的结果，而Python不能（曾经在这里被坑的，举手）。那怎样用Python正确地搞定这个问题嘞？可以先去绝对值和符号，当正数来处理，最后再在结果里搭上符号。

3. Follow-ups

3.1 Python中的另一个除法操作

我们知道，在Python中，基本的除号“/”是被重载了的。当两个操作数都是整数时，进行整数除法，得到整数结果，否则进行浮点数除法（真除法），得到浮点数结果。从Python 2.2开始，另一个除号被引入：//，它只执行整数除法。注意，//的结果类型依操作数而定。

>>>1.0/2
0.0
>>>1.0//2.0
0.0
>>>1//2
>0

另外，如果想同时得到商和余数，可以使用内建的函数divmod，结果是一个tuple。

>>>divmod(7, 2)
(3, 1)
>>>divmod(7.0, 2)
(3.0, 1.0)

3.2 Python中的舍入

除了缺省的舍入方式，Python还有多种舍入可供选择。
Floor rounding:

>>>import math
>>>math.floor(1.2)

1.0
>>>math.floor(-1.2)
-2.0

Ceiling rounding:

>>>math.ceil(1.2)
2.0
>>>math.ceil(-1.2)
-1.0

Round-off:

>>>round(0.5)
1.0
>>>round(-0.4)
-0.0
>>>round(-0.5)
-1.0

内嵌的round函数也可以一个指定保留小数位数的参数：

>>>round(0.21, 1)
0.2
>>>round(0.21, 2)
0.21

Caution !

>>>round(2.675, 2)
2.67

咦？bug啦？！当然不是。这里要明确一件事：计算机只认识0,1（量子计算机？懵）。就是说，我们输入的十进制数，在计算机内部都是用二进制来表示的。有的十进制数可以用二进制准确地表示出来,比如十进制的0.125可以表示为0b0.001；然而很多的小数是没法用二进制数精确表示的，计算机里存储的是它们的近似值，例如十进制的0.1，用二进制表示，可以近似为:0b0.00011001100110011001100110011001100110011001100110011010，所以当我们把它换回十进制数以输出或者使用，得到的值就是0.1000000000000000055511151231257827021181583404541015625。也就是说，0.1在计算机里并不是刚好等于1/10的。你看：

>>>0.1+0.2
0.30000000000000004

同样，当我们运行round()函数，也是对计算机中实际存储的值近似取舍。2.67实际上近似

为2.67499999999999982236431605997495353221893310546875，第三位小数是4，那么round(2.675, 2)就相当于round(2.674, 2)，结果当然是2.67。值得注意的是，这种现象是广泛存在于各种计算机和各种编程语言的，不是bug，只是有的语言选择了不让你看到。