015

Author: DinghaoLI

010-二进制中1的个数/README.md

@@ -0,0 +1,60 @@
+# 题意
+
+> 输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
+
+样例输入
+
+3 4 5 -1
+
+样例输出
+
+1 2 32
+
+## 通过移位测试每一位
+
+我们很容易想到的算法就是
+通过移位的方法，挨个判断其每一位
+
+但是这个算法有致命的缺陷，我们假设通过移位的方式可以获取到其每一位，但是并不总是对的
+
+##逻辑右移与算术右移
+
+比如一个有符号位的8位二进制数11001101，逻辑右移就不管符号位，如果移一位就变成01100110。算术右移要管符号位，右移一位变成10100110。
+
+逻辑左移=算数左移，右边统一添0
+逻辑右移，左边统一添0
+算数右移，左边添加的数和符号有关
+
+e.g:1010101010，其中[]位是添加的数字
+
+> 逻辑左移一位：010101010[0]
+> 算数左移一位：010101010[0]
+> 逻辑右移一位：[0]101010101
+> 算数右移一位：[1]101010101
+
+因此如果输入负数，那么我们的算法简单的判断是不是0来终结，岂不是要死循环
+
+## 避免负数移位的死循环
+
+为了负数时候避免死循环，我们可以不右移数字n，转而去移动测试位
+
+那么思考我们的循环结束条件，flag一直左移（乘以2），当超出表示标识范围的时候，我们就可以终止了，但是这样子的话，最高位的符号位没有测试，因此要单独测试，同时由于会溢出，我们的flag需要用long来标识
+
+## 整数中有几个1就循环几次--lowbit优化
+
+我们分析n以n-1两个数的差别，
+
+- 如果n!=0，那么其二进制位中至少有一个1
+
+- 如果n的最低位是1（奇数），那么n-1正好把这个最低位的1变成0，其他位不变
+
+- 如果n的最低位是0（偶数），那么假设其右起第一个1位于m位，即m位后面全是0，那么n-1的第m位由1变成0，而第m位后面的所有0均变成1，m位之前的所有位保持不变。
+
+因此通过分析发现：
+
+**把一个整数n减去1，再和原来的整数做与运算，会把该整数最右边一个1变成0，那么该整数有多少个1，就会进行多少次与运算**
+
+即循环的次数，即二进制中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，就可以进行多少次这样的操作。
+

010-二进制中1的个数/problem010.go

@@ -0,0 +1,11 @@
+package problem010
+
+
+func Ones(n int) int {
+    count := 0;
+    for n!=0 {
+        count++
+        n = n & (n-1)
+    }
+    return count
+}

010-二进制中1的个数/problem010_test.go

@@ -0,0 +1,34 @@
+package problem010
+
+import (
+    "testing"
+)
+
+func Test_case(t *testing.T) {
+    if Ones(0) == 0 {
+        t.Log("Pass")
+    } else {
+        t.Error("Failed")
+    }
+    // int64
+    if Ones(-1) == 64 {
+        t.Log("Pass")
+    } else {
+        t.Error("Failed value: ",Ones(-1))
+    }
+
+    if Ones(8) == 1 {
+        t.Log("Pass")
+    } else {
+        t.Error("Failed")
+    }
+
+
+    if Ones(5) == 2 {
+        t.Log("Pass")
+    } else {
+        t.Error("Failed")
+    }
+
+}
+

011-数值的整数次方/README.md

@@ -0,0 +1,13 @@
+# 题意
+
+> 给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
+
+前面所说的指数为负数只是边界的一种情况，学习算法，必须全面了解所有的边界
+
+指数幂的所有边界包括:
+
+- 指数为0的情况，不管底数是多少都应该是1
+- 指数为负数的情况，求出的应该是其倒数幂的倒数
+- 指数为负数的情况下，底数不能为0
+
+正整数幂次可以用位运算来求

011-数值的整数次方/problem011.go

@@ -0,0 +1,37 @@
+package problem011
+
+import (
+	"errors"
+)
+
+
+func Pow(base float64, exp int) (float64, error) {
+	if exp == 0 {
+		return 1, nil
+	}
+	if exp < 0 && base == 0 {
+		return -1 , errors.New("base == 0 and exp < 0")
+	}
+
+	if exp > 0 {
+		return PowNormal(base, exp), nil   	
+	} else {
+		res := PowNormal(base, -exp)
+		res = 1/res
+		return res, nil
+	}   
+
+}
+
+
+func PowNormal(base float64, exp int) float64 {
+	res, temp := 1.0, base
+	for exp != 0 {
+		if exp&1 == 1 {
+			res *= temp
+		}
+		temp *= temp
+		exp >>= 1
+	}
+	return res
+}

011-数值的整数次方/problem011_test.go

@@ -0,0 +1,44 @@
+package problem011
+
+import (
+    "testing"
+)
+
+func Test_case(t *testing.T) {
+    res, _ := Pow(0, 0)
+    if res == 1 {
+        t.Log("Pass")
+    } else {
+        t.Error("Failed")
+    }
+    
+    res, _ = Pow(2, -1)
+    if res == 0.5 {
+        t.Log("Pass")
+    } else {
+        t.Error("Failed value: ")
+    }
+
+    res, _ = Pow(2, 3)
+    if res == 8 {
+        t.Log("Pass")
+    } else {
+        t.Error("Failed")
+    }
+
+    res, _ = Pow(2, -2)
+    if res == 0.25 {
+        t.Log("Pass")
+    } else {
+        t.Error("Failed")
+    }
+
+    res, err := Pow(0, -2)
+    if err != nil  {
+        t.Log("Pass")
+    } else {
+        t.Error("Failed")
+    }
+
+}
+

012-打印1到最大的N位数/README.md

@@ -0,0 +1,19 @@
+# 题意
+
+给定一个数字N，打印从1到最大的N位数。
+
+输入
+
+每个输入文件仅包含一组测试样例。
+
+对于每个测试案例，输入一个数字N(1<=N<=5)。 输出 对应每个测试案例，依次打印从1到最大的N位数。
+
+样例输入
+
+1
+
+样例输出
+
+1 2 3 4 5 6 7 8 9
+
+这题其实没什么太大意义，控制好溢出就好了。

012-打印1到最大的N位数/problem012.go

@@ -0,0 +1,78 @@
+package main
+
+import (
+    "fmt"
+    "errors"
+)
+
+var MaxInt int = int(^uint(0) >> 1)
+
+// problem 011
+func Pow(base float64, exp int) (float64, error) {
+    if exp == 0 {
+        return 1, nil
+    }
+    if exp < 0 && base == 0 {
+        return -1 , errors.New("base == 0 and exp < 0")
+    }
+
+    if exp > 0 {
+        return PowNormal(base, exp), nil    
+    } else {
+        res := PowNormal(base, -exp)
+        res = 1/res
+        return res, nil
+    }   
+
+}
+
+func PowNormal(base float64, exp int) float64 {
+    res, temp := 1.0, base
+    for exp != 0 {
+        if exp&1 == 1 {
+            res *= temp
+        }
+        temp *= temp
+        exp >>= 1
+    }
+    return res
+}
+
+// 012
+func showN(n int) error {
+    top, _ := Pow(10, n)
+
+    if (int(top) > MaxInt){
+        return errors.New("Overflow")
+    }
+
+    for i := 1; i < int(top); i++ {
+        fmt.Println(i)
+    }
+    return nil 
+}
+
+func main() {
+    showN(1)
+    showN(3)
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

014-调整数组顺序使奇数位于偶数前面/README.md

@@ -0,0 +1,37 @@
+#题意
+
+题目描述
+
+输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
+
+样例输入
+
+5 1 2 3 4 5
+
+样例输出
+
+1 3 5 2 4
+
+下面我们考虑算法复杂度的同时还会考虑其稳定性，（排序的稳定型则是指相同元素在数组中的相对位置是否发生变化），这里的稳定性我们理解为，顺序交换后，各个奇数（或者偶数）在数组中的相对位置是否发生变化
+
+## 不影响顺序　=> 冒泡解法
+最简单的思路就是从头到尾扫描一遍数组，每遇见一个偶数时，就拿出这个数字，并把位于这个数字之后的所有数字往前挪动一位,然后把当前这个偶数放到最后。
+
+这样每次遇到一个偶数就要挪动$O(n)$个数字，因此总的时间复杂度是$O(n^2)$
+
+但是这种方法不仅暴力而且还需要复杂的挪动工作，因此我们对比一下冒泡排序，每次循环前偶后奇就交换
+
+同时我们设立一个标识，来标识数组是否已经符合要求
+
+当再次循环时，发现没有要交换的数据，说明数组已经符合要求
+
+## 高效但是影响顺序 => 双指针
+由于题目中只要求记奇数在偶数之前，那么我们在扫描这个数组的时候，如果发现一个偶数出现在奇数之前就交换他们的位置，这样一趟后就满足要求了。
+
+因此我们
+
+维护两个索引或者指针，一个指向数组的第一个元素，并向后移动，一个指向数组的最后一个元素，并向前移动。
+
+如果第一个指针指向的元素是偶数，而第二个指针指向的元素是奇数，说明偶数在奇数前面，那么就交换这两个数。
+
+直到两个指针相遇为止

014-调整数组顺序使奇数位于偶数前面/problem014.go

@@ -0,0 +1,45 @@
+package main
+
+import (
+    "fmt"
+)
+
+
+func oddFirst(s []int){
+    left, right := 0, len(s)-1
+    for left < right {
+        for s[right]%2==0 && left<right{
+            right--
+        }
+        for s[left]%2==1 && left<right{
+            left++
+        }
+        if left==right {
+            break
+        }
+        if left<right {
+            s[left], s[right] = s[right], s[left]
+        }
+    }
+}
+
+
+
+func main() {
+    //test
+
+    l := []int{1,2,3,4,5,6,7}
+    fmt.Println("before: ", l)
+    oddFirst(l)
+    fmt.Println("after: ",l)
+
+    l = []int{2,2,2,2,5,6,7}
+    fmt.Println("before: ", l)
+    oddFirst(l)
+    fmt.Println("after: ",l)
+}
+
+
+
+
+