2.18

Author: DmrfCoder

README.md

@@ -8,3 +8,7 @@
 - [旋转数组的最小数字](./SwordToOffer/Doc/旋转数组的最小数字.md)
 - [跳台阶](./SwordToOffer/Doc/跳台阶.md)
 - [变态跳台阶](./SwordToOffer/Doc/变态跳台阶.md)
+- [***矩形覆盖***](./SwordToOffer/Doc/矩形覆盖.md)
+- [二进制中1的个数](./SwordToOffer/Doc/二进制中1的个数.md)
+- [***数值的整数次方***](./SwordToOffer/Doc/数值的整数次方.md)
+

SwordToOffer/Code/10.py

@@ -0,0 +1,27 @@
+# -*- coding:utf-8 -*-
+class Solution:
+    def NumberOf1(self, n):
+        # write code here
+        count = 0
+        c = 1
+
+        for i in range(32):
+            p = c & n
+            if p != 0:
+                count += 1
+            c = c << 1
+
+        return count
+
+    def NumberOf1_2(self, n):
+        count=0
+        while n:
+            count += 1
+            n = (n - 1) & n
+        return count
+
+
+
+solution = Solution()
+print solution.NumberOf1_2(-2)
+

SwordToOffer/Code/11.py

@@ -0,0 +1,30 @@
+# -*- coding:utf-8 -*-
+class Solution:
+    def Power(self, base, exponent):
+        # write code here
+        if base == 0:
+            return 0
+        if exponent == 0:
+            return 1
+        flag = 1
+        if exponent < 0:
+            flag = 0
+            exponent = -exponent
+
+        sum = 1.0
+        tmp = base
+        while (exponent > 0):
+            if exponent & 1 == 1:
+                sum *= tmp
+            tmp *= tmp
+            exponent = exponent >> 1
+
+        if flag == 0:
+            sum = 1 / sum
+
+        return sum
+
+
+solution = Solution()
+# 00..11
+print solution.Power(3, 2)

SwordToOffer/Code/7.py

@@ -1,23 +1,14 @@
 # -*- coding:utf-8 -*-
 class Solution:
     def jumpFloor(self, number):
-        a=1
-        b=2
 
         # write code here
         if number == 1:
             return 1
         elif number == 2:
             return 2
         else:
-            number=number-2
-            while number != 0:
-                c=a+b
-                a=b
-                b=c
-                number -= 1
-
-            return b
+            return self.jumpFloor(number - 1) + self.jumpFloor(number-2)
 
 
 solution = Solution()

SwordToOffer/Code/8.py

@@ -0,0 +1,14 @@
+# -*- coding:utf-8 -*-
+class Solution:
+    def jumpFloorII(self, number):
+        # write code here
+        if number == 1:
+            return 1
+        elif number == 2:
+            return 2
+        else:
+            return 2 * self.jumpFloorII(number - 1)
+
+
+solution = Solution()
+print solution.jumpFloorII(4)

SwordToOffer/Code/9.py

@@ -0,0 +1,23 @@
+class Solution:
+    def rectCover(self, number):
+        # write code here
+        if number==0:
+            return 0
+        elif number==1:
+            return 1
+        elif number==2:
+            return 2
+        else:
+            c=0
+            a=1
+            b=2
+            for i in range(number-2):
+                c=a+b
+                a=b
+                b=c
+            return c
+
+
+solution = Solution()
+print solution.rectCover(3)
+

SwordToOffer/Doc/doc-sample.md

@@ -0,0 +1,12 @@
+# title
+
+
+## 题目描述
+
+## 解题思路
+
+
+
+## 代码
+
+[这里](../Code/n.py)

SwordToOffer/Doc/二进制中1的个数.md

@@ -0,0 +1,26 @@
+# 二进制中1的个数
+
+
+## 题目描述
+输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
+
+## 解题思路
+首先明确负数的补码是什么：
+-1的原码则为1000 0001，其中第一个1，表示负号，是符号位。如果是正数则为0，-7的原码是1000 0111；
+计算机中的负数默认都是按照补码存储的。
+
+### 思路1
+
+如果一个整数不为0，那么这个整数至少有一位是1。如果我们把这个整数减1，那么原来处在整数最右边的1就会变为0，原来在1后面的所有的0都会变成1(如果最右边的1后面还有0的话)。其余所有位将不会受到影响。
+举个例子：一个二进制数1100，从右边数起第三位是处于最右边的一个1。减去1后，第三位变成0，它后面的两位0变成了1，而前面的1保持不变，因此得到的结果是1011.我们发现减1的结果是把最右边的一个1开始的所有位都取反了。这个时候如果我们再把原来的整数和减去1之后的结果做与运算，从原来整数最右边一个1那一位开始所有位都会变成0。如1100&1011=1000.
+
+也就是说，把一个整数减去1，再和原整数做与运算，会把该整数最右边一个1变成0.那么一个整数的二进制有多少个1，就可以进行多少次这样的操作。
+
+### 思路2
+
+利用位的运算，初始用1和目标数与去探测目标数二进制最低位是否为1，然后将1左移，以此类推探测后面的二进制位。
+
+
+## 代码
+
+[这里](../Code/10.py)

SwordToOffer/Doc/变态跳台阶.md

@@ -4,7 +4,6 @@
 ## 题目描述
 一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
 
-
 ## 解题思路
 
 设共有m种不同跳法
@@ -15,11 +14,31 @@
 对于n阶台阶：
 
 - case1：第一次跳了1个台阶，就有f（n-1）种跳法
-- case2：第一次挑个2个台阶，就有f（n-2）种跳法
+- case2：第一次跳个2个台阶，就有f（n-2）种跳法
+- ...
+- case n:第一次跳了n个台阶，就有0中跳法
+
+
+
+将所有情况加起来，对于n级台阶，有：`f(n)=f(1)+f(2)+f(3)+..+f(n-1)+1`种跳法，如果直接用该式进行计算，每次计算f(n)时需要计算`n-1`个`f`，会有很多重复计算，考虑：
+
+```
+f(1)=1 
+f(2)=2 
+f(3)=f(2)+f(1)+1
+f(4)=f(3)+f(2)+f(1)+1
+f(5)=f(4)+f(3)+f(2)+f(1)+1
+      =f(4)+f(4)
+
+f(6)=f(5)+f(4)+f(3)+f(2)+f(1)+1
+      =f(5)+f(5)
+
+```
 
-所以总的n阶台阶的跳法f（n）=case1+case2=f(n-1)+f(n-2)
+可以发现：    
+   ` f(n)=2*f(n-1)`
 
-这是典型的斐波那契数列，需要注意的是尽量不要用递归去求解斐波那契数列，尽量使用循环，如果只需要第n项，不用保存所有n项数据，只需每次保存前2项即可。
+利用该式即可解决此问题。
 
 
 ## 代码

SwordToOffer/Doc/数值的整数次方.md

@@ -0,0 +1,53 @@
+# 数值的整数次方
+
+
+## 题目描述
+给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
+## 解题思路
+这是典型的快速求幂算法的题，举个例子：
+
+$3 ^{ 999}$ = 3 * 3 * 3 * … * 3
+
+直接乘要做998次乘法，复杂度为$O(n)$.
+
+但事实上可以这样做，先求出2^k次幂：
+
+$3 ^ 2$ = 3 * 3
+$3 ^ 4$ = $3 ^ 2$* $3 ^ 2$
+$3 ^ 8$ = $3 ^ 4$* $3 ^ 4$
+$3 ^{16}$ = $3 ^ 8$ * $3 ^ 8$
+$3 ^ {32}$ = $3 ^{16}$ * $3 ^{16}$
+$3 ^{64}$ = $3 ^ {32} $* $3 ^ {32}$
+$3 ^{128}$ = $3 ^ {64}$ * $3 ^ {64}$
+$3 ^ {256}$ = $3 ^ {128}$ * $3 ^ {128}$
+$3 ^ {512}$ = $3 ^ {256}$ * $3 ^ {256}$
+
+再相乘：
+
+$3 ^ {999}$
+= $3 ^ {(512 + 256 + 128 + 64 + 32 + 4 + 2 + 1)}$
+=$ 3 ^ {512}* 3 ^ {256} * 3 ^ {128} * 3 ^ {64}* 3 ^ {32} * 3 ^ 4 * 3 ^ 2 * 3$
+
+这样只要做16次乘法,复杂度为$O(logn)​$,即使加上一些辅助的存储和运算，也比直接乘高效得多（尤其如果这里底数是成百上千位的大数字的话）。
+我们发现，把999转为2进制数：1111100111，其各位就是要乘的数.
+
+所以我们只需利用exponent的二进制位即可，同时需要考虑exponent和base的特殊情况，比如0 、正、负等。
+
+
+
+## 代码
+
+核心代码：
+
+```python
+sum = 1.0
+tmp = base
+while (exponent > 0):
+    if exponent & 1 == 1:
+    sum *= tmp
+    tmp *= tmp
+    exponent = exponent >> 1
+```
+
+[这里](../Code/11.py)
+

SwordToOffer/Doc/文档模板.md

@@ -0,0 +1,12 @@
+# 矩形覆盖
+
+
+## 题目描述
+我们可以用2$\times$1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2$\times$1的小矩形无重叠地覆盖一个2$\times​$n的大矩形，总共有多少种方法？
+## 解题思路
+
+![8](https://ws1.sinaimg.cn/large/006tKfTcly1g0as26m4uuj30gz076q2x.jpg)
+
+## 代码
+
+[这里](../Code/9.py)

SwordToOffer/Doc/矩形覆盖.md

@@ -0,0 +1,46 @@
+# 变态跳台阶
+
+
+## 题目描述
+一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
+
+## 解题思路
+
+设共有m种不同跳法
+
+- 如果n=1，那么m=1
+- 如果n=2，那么m=2
+
+对于n阶台阶：
+
+- case1：第一次跳了1个台阶，就有f（n-1）种跳法
+- case2：第一次跳个2个台阶，就有f（n-2）种跳法
+- ...
+- case n:第一次跳了n个台阶，就有0中跳法
+
+
+
+将所有情况加起来，对于n级台阶，有：`f(n)=f(1)+f(2)+f(3)+..+f(n-1)+1`种跳法，如果直接用该式进行计算，每次计算f(n)时需要计算`n-1`个`f`，会有很多重复计算，考虑：
+
+```
+f(1)=1 
+f(2)=2 
+f(3)=f(2)+f(1)+1
+f(4)=f(3)+f(2)+f(1)+1
+f(5)=f(4)+f(3)+f(2)+f(1)+1
+      =f(4)+f(4)
+
+f(6)=f(5)+f(4)+f(3)+f(2)+f(1)+1
+      =f(5)+f(5)
+
+```
+
+可以发现：    
+   ` f(n)=2*f(n-1)`
+
+利用该式即可解决此问题。
+
+
+## 代码
+
+[这里](../Code/8.py)