发表于 | 分类于 | 阅读次数:
字数统计: 580 | 阅读时长 ≈ 2

首先看看 go开发当中的测试

1
2
3
4
5
6
7
8
9
10
11
12
13
// main.go

package main

import "fmt"

func Add(x, y int) int {
    return x+y
}

func main() {
    fmt.Println(Add(1, 2))
}
1
2
3
4
5
6
7
8
9
10
11
12
13

// main_test.go

package main

import "testing"

func TestAdd(t * testing.T) {
    sum := Add(1, 2)
    if sum != 3 {
        t.Error("Add 1 and 2 result is not 3!!!")
    }
}

命令运行

go test main_test.go main.go -v -cover

因为以前补过单元测试什么的

在此记录一下覆盖率

  • 语句覆盖
  • 判定（分支）覆盖 增加false的情况
  • 判定/条件覆盖
  1. 语句覆盖是指选择足够的测试用例，使得运行这些测试用例时，被测程序的每一个语句至少执行一次，其覆盖标准无法发现判定中逻辑运算的错误；
  2. 判定覆盖是指选择足够的测试用例，使得运行这些测试用例时，每个判定的所有可能结果至少出现一次，但若程序中的判定是有几个条件联合构成时，它未必能发现每个条件的错误；
  3. 条件覆盖是指选择足够的测试用例，使得运行这些测试用例时，判定中每个条件的所有可能结果至少出现一次，但未必能覆盖全部分支；
  4. 判定/条件覆盖是使判定中每个条件的所有可能结果至少出现一次，并且每个判定本身的所有可能结果也至少出现一次；
  5. 条件组合覆盖是使每个判定中条件结果的所有可能组合至少出现一次，因此判定本身的所有可能解说也至少出现一次，同时也是每个条件的所有可能结果至少出现一次；
  6. 路径覆盖是每条可能执行到的路径至少执行一次；

其中语句覆盖是一种最弱的覆盖，判定覆盖和条件覆盖比语句覆盖强，满足判定/条件覆盖标准的测试用例一定也满足判定覆盖、条件覆盖和语句覆盖，条件组合覆盖是除路径覆盖外最强的，路径覆盖也是一种比较强的覆盖，但未必考虑判定条件结果的组合，并不能代替条件覆盖和条件组合覆盖。

发表于 | 分类于 | 阅读次数:
字数统计: 68 | 阅读时长 ≈ 1 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

int find(vector<int> &nums, int target) {
	if (nums.empty())
		return -1
	int low = 0;
	int high = nums.size() -1;
	while (low <= high) {
		int mid = low + (high -low) /2;
		if (nums[mid] < target)
			low = mid + 1;
		else
			high = mid - 1;
	}
	return low;
}

二分查找有很多变种 注意一些细节问题

发表于 | 阅读次数:
字数统计: 128 | 阅读时长 ≈ 1 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# _*_ coding: utf-8 _*_
import requests
from bs4 import BeautifulSoup
import re
import random
import datetime

page = set()
random.seed(datetime.datetime.now())
def getlink(articleurl):
    html = requests.get("https://en.wikipedia.org"+articleurl)
    soup = BeautifulSoup(html.text, "html.parser")
    return soup.find("div", {'id':'bodyContent'}).findAll("a", {"href":re.compile('^(/wiki/)')})

links = getlink("/wiki/Christopher_Nolan")
i = 0
while len(links) > 0:
    newArticle = links[random.randint(0, len(links)-1)]["href"]
    i += 1
    print "第 %d 个页面：" %i
    print newArticle
    if i == 6:
        break
    links = getlink(newArticle)

通过维基百科 只需要最多六次跳转

发表于 | 分类于 | 阅读次数:
字数统计: 279 | 阅读时长 ≈ 1

设计一个LRU cache，实现两个功能：

(cache中存放着（key,value）键值对)

get(key):获取key对应的value，如果key不在cache中那么返回-1（value 总是为正数）；

set(key, value):如果key在cache中则更新它的value；如果不在则插入，如果cache已满则先删除最近最少使用的一项后在插入。

对于get，如果key在cache中，那个get(key）表示了对key的一次访问；而set(key，value)则总是表示对key的一次访问。

使用一个list来记录访问的顺序，最先访问的放在list的前面，最后访问的放在list的后面，故cache已满时，则删除list[0]，然后插入新项；

基本方案在py 当中还是 双链表加上哈希表的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class LRUCache(object):
    def __init__(self, capacity):
        self.cache = dict()
        self.used_list = list()
        self.capacity = capacity
 
    def get(self, key):
        if key in self.cache:
            if key != self.used_list[-1]:
                self.used_list.remove(key)
                self.used_list.append(key)
            return self.cache[key]
        else:
            return -1

    def set(self, key, value):
        if key in self.cache:
            self.used_list.remove(key)
        elif len(self.cache) == self.capacity:
            self.cache.pop(self.used_list.pop(0))
        self.used_list.append(key)
        self.cache[key] = value