1 字符串中所有重排（10分）

题目内容：

给定一个字符串s与待查找字符串p，请给出使得s[i:i+len(p)]是p的一个字母重排的所有下标i

题目保证字符串p非空

输入格式:

两行字符串，第一行为s，第二行为p

输出格式：

所有满足条件的下标从小到大排列，以空格分隔输出

若无对应下标，则输出"none"

输入样例：

cbaebabacd

abc

输出样例：

0 6

参考代码模板：

1. def findAnagrams(s, p):
2.     # code here
3.     pass
4.  
5. s = input()
6. p = input()
7. findAnagrams(s, p)

程序代码1：

def findAnagrams(s, p):
    s_len = len(s)
    p_len = len(p)
    l = []
    p_list = [0 for _ in range(26)]
    s_list = [0 for _ in range(26)]
    for i in p:
        p_list[ord(i) - ord('a')] = p_list[ord(i) - ord('a')] + 1
    i = 0
    while i <= s_len - p_len:
        for x in s[i:i + p_len]:
            s_list[ord(x) - ord('a')] = s_list[ord(x) - ord('a')] + 1
        if s_list == p_list:
            l.append(i)
        s_list = [0 for _ in range(26)]
        i = i + 1
    if len(l) == 0:
        return ['none']
    else:
        return l

s = input()
p = input()
print(*findAnagrams(s, p))

程序代码2：

def findAnagrams(s, p):
    results = []
    i = 0
    while i <= len(s) - len(p):
        pp = list(p)
        for x in s[i: i + len(p)]:
            if x in pp:
                pp.remove(x)
            else:
                break
        else:
            if not pp:
                results.append(i)
        i += 1
    if results:
        print(*results)
    else:
        print('none')

s = input()
p = input()
findAnagrams(s, p)

2 列表出现最频繁的元素（10分）

题目内容：

给定一个列表与数字K，按出现次数倒序输出列表中前K个出现最频繁的元素；若少于K个元素则返回所有元素

输入格式:

输入为两行

第一行为给定列表，以合法的Python表达式给出

第二行为数字K

输出格式：

不多于K个数字，以空格分隔

输入样例：

[1,1,1,2,2,3]

2

输出样例：

1 2

参考代码模板：

1. def topKFrequent(nums, k):
2.     # code here
3.     pass
4.  
5. lst = eval(input())
6. k = int(input())
7. topKFrequent(lst, k)

程序代码：

def topKFrequent(nums, k):
    dct = {}
    for x in nums:
        dct[x] = dct.get(x, 0) + 1
    result = sorted(dct.items(), key=lambda x: (-x[1],x[0]))
    result = [x[0] for x in result[:k]]
    print(*result)


lst = eval(input())
k = int(input())
topKFrequent(lst, k)

3 散列表（10分）

题目内容：

给定一个指定大小N的散列表，并输入一系列数字：若找到空槽，则插入该数字，并返回槽位置；若该数字在散列表中存在，则直接输出其位置。

注：使用下标增加的二次探测法解决散列冲突

注2：散列表实际大小应确定为不小于用户输入N的最小质数

输入格式:

两行

第一行为用户指定散列表大小N

第二行为一系列数字，以空格分隔

输出格式：

逐个输出对应数字在散列表中位置，以空格分隔

若该数字无法插入，则输出“-”

输入样例：

4

10 6 4 10 15

输出样例：

0 1 4 0 -

参考代码模板：

1. def createHashTable(n):
2.     # code here
3.     pass
4.  
5. def insertNumbers(table, nums):
6.     # code here
7.     pass
8.  
9. n = int(input())
10. nums = list(map(int, input().split()))
11. table = createHashTable(n)
12. insertNumbers(table, nums)

程序代码:

def createHashTable(n):
    for i in range(2, n):
        if n % i == 0:
            n = n + 1
    else:
        return n


def insertNumbers(table, nums):
    lst = []
    for i in range(len(nums)):
        j = nums[i] % table
        if j not in lst:
            lst.append(j)
        else:
            found = 0
            a = i
            while(not found):
                for x in range(a):
                    if nums[x] == nums[a]:
                        found = 1
                        break
                break
            if found == 1:
                lst.append(lst[x])
            else:
                for m in range(1,table):
                    k = (nums[i] + m*m) % table
                    if k not in lst:
                        lst.append(k)
                        break
                else:
                    lst.append("-")
    return lst
n = int(input())
nums = list(map(int, input().split()))
table = createHashTable(n)
print(*insertNumbers(table, nums))

这个题自己测试没毛病呀，不知道为什么提交最后一个不能通过，可能还是有些地方不对吧，课多的都没时间做。