1. 打印1000以内的质数

 draft版本：

```

def printlist():
    a = []
    for i in range(1, 1001):
        b.append(i)
        for j in range(2, i):
            if i % j == 0:
                a.remove(i)
                break
    print(a)
checklist()

```

稍稍优化一下，把判断是否质数方法独立出来，使用filter或者列表生成器来返回列表
```

def check(a):
    for i in range(2, a):
        if a % i == 0:
            return 0
    return 1
b = list(filter(lambda x:check(x), range(1, 1001)))     
c = [x for x in range(1, 1001) if check(x)]
print(b)
print(c)

```

2. 给定字符串str1和str2，求str1中子串含有str2所有字符串的最小子串长度，若str1不包含所有str2中字符，则返回0，例如str1='abcdeca'，str2='ac',则输出3
实现思路：使用字符串的find方法，当字符存在时返回第一次出现的位置，不存在时返回-1。
首先把str2转换成列表，遍历该列表，所有字符在str1中的位置生成新的列表，列表最大值即为符合条件的最小子串长度。
写法一：
```

def minlength(str1, str2):
    lista = list(str2)
    listb = []
    for item in lista:
        x = str1.find(item)+1
        if x:
            listb.append(x)
        else:
            return 0
    print(max(listb))
minlength('abcdeca', 'ac')

```

写法二：列表生成器生成新列表
```

def minlength(str1, str2):
    lista = list(str2)
    listb = [str1.find(x)+1 for x in lista]
    if listb.count(0) > 0:
        return 0
    else:
        print(max(listb))
minlength('abcdeca', 'ac')

```

3. 统计一个字符串中的词频，按照词频逆序输出
实现思路一：生成集合，然后对集合元素用在原始字符串中的个数倒序排序，使用sorted()方法对集合排序
```

def reverselist(a):
    b = set(a)
    c = sorted(b, key=lambda x: a.count(x), reverse=True)
    print(" ".join(c))
reverselist('aabcddeeab')
```

实现思路二：使用collection模块的Counter方法，生成字符串中字符与字符个数的字典，key生成列表，对列表用value值排序

def reverselist(a):
    dicta = dict(Counter(a))
    b = [x for x in dicta]
    b.sort(key=lambda x: dicta[x], reverse=True)
    print(" ".join(b))
reverselist('aabcddeeab')

4. 存在某商品的价格列表，列表中是商品每天的价格，要在某一天买入，之后的某一天卖出获得利润，如果没有利润，则返回0
方法一：嵌套循环实现，第一层是买入的价格，第二层是列表该价格之后的价格遍历，计算出每个价格与买入价格的差值，如果大于利润值p，就更新p值
```

def profit(a):
    p = 0
    if len(a) < 2:
        return 0
    for i in a[:-1]:   
        for j in a[a.index(i)+1:]:
            p1 = j-i
            if p1 > p:
                p1, p = p, p1
    if p >0:
        return p
    else:
        return 0
a = profit([5, 5, 2])
print(a)

```

方法二：截取买入值后的值的子列表，找到最大值，然后把买入值与最大值计算利润，如果大于p就更新p值
```

def profit1(a):
    p = 0
    if len(a) < 2:
        return 0
    for i in a[:-1]:
        a1 = a[a.index(i)+1:]
        j = max(a1)
        p1 = j-i
        if p1 > p:
            p1, p = p, p1
    if p > 0:
        return p
    else:
        return 0
a = profit1([5, 1, 2])
print(a)

```
说明，遍历列表中的价格时，由于最后一个价格买入时，没有卖出价格，所以列表最后一个值不用遍历。
在第二种写法中，必须遍历a[:-1],否则生成子列表的时候会生成空列表，max()取最大值时会报错，

5. 判断字符串中有没有重复值
解决思路：把字符串转换成集合，然后判断字符串与集合的长度是否相等，由于集合中无重复元素，当长度相等时字符串中也无重复字符，反之则有重复字符
```

def checkdup(a):
    b = set(a)
    if len(b) == len(a):
        print("无重复字符")
    else:
        print("有重复字符")
checkdup('aac')
```