python

1.给定一个单链表中的一个等待被删除的节点（非表头表尾），在o(1)时间复杂度删除该链节点：
思路分析
如果我们要在链表中删除一个节点，一般的操作是：
①修改要删除节点的上一个节点的指针
②将该指针指向要删除节点的下一个节点
例如，在链表 [4, 5, 1, 9] 中，当我们要删除节点 5 时，我们会修改节点 5 上一个节点 4 的指针，让它指向节点 5 的下一个节点，即节点 1：

首先，我们把节点 5 下一个节点的值赋给它，把它变成一个「不需要删除」的节点：

这样一来，第二个节点 1 和第三个节点 1，无论我们删除其中的哪一个，都可以得到最终结果 [4, 1, 9]。既然第二个节点不好删除，那我们就果断删除第三个啦~
改变第二个节点 1 的指针，将它指向第 4 个节点 9，这样一来，第三个节点 1 就被删除了：

def deleteNode(node):
        node.value=node.next.val
        node.next = node.next.next
    return node

2.提取“abc123qwer456tyui789”这个字符串中的数字

str="abc123qwer456tyui789"
num=" ".join([x for x in str if x.isdigit()])
print(num)

3.频繁项集挖掘Apriori算法及其Python实现
https://blog.csdn.net/u013185349/article/details/108293202

# coding:utf8
import sys
 
def apriori(D, minSup):
    """
    频繁项集用keys表示，
    key表示项集中的某一项，
    cutKeys表示经过剪枝步的某k项集。
    C表示某k项集的每一项在事务数据库D中的支持计数
    :param D:
    :param minSup:
    :return:
    """
    C1 = {}
    for T in D:
        for I in T:
            if I in C1:
                C1[I] += 1
            else:
                C1[I] = 1
 
    print C1
    _keys1 = C1.keys()
 
    keys1 = []
    for i in _keys1:
        keys1.append([i])
 
    n = len(D)
    cutKeys1 = []
    for k in keys1[:]:
        if C1[k[0]] * 1.0 / n >= minSup:
            cutKeys1.append(k)
 
    cutKeys1.sort()
 
    keys = cutKeys1
    all_keys = []
    while keys != []:
        C = getC(D, keys)
        cutKeys = getCutKeys(keys, C, minSup, len(D))
        for key in cutKeys:
            all_keys.append(key)
        keys = aproiri_gen(cutKeys)
 
    return all_keys
 
 
def getC(D, keys):
    """
     对keys中的每一个key进行计数
    :param D:
    :param keys:
    :return:
    """
    C = []
    for key in keys:
        c = 0
        for T in D:
            have = True
            for k in key:
                if k not in T:
                    have = False
            if have:
                c += 1
        C.append(c)
    return C
 
 
def getCutKeys(keys, C, minSup, length):
    """
    剪枝步
    :param keys:
    :param C:
    :param minSup:
    :param length:
    :return:
    """
    for i, key in enumerate(keys):
        if float(C[i]) / length < minSup:
            keys.remove(key)
    return keys
 
 
def keyInT(key, T):
    """
    判断项key是否在数据库中某一元组T中
    :param key:
    :param T:
    :return:
    """
    for k in key:
        if k not in T:
            return False
    return True
 
 
def aproiri_gen(keys1):
    """
    连接步
    :param keys1:
    :return:
    """
    keys2 = []
    for k1 in keys1:
        for k2 in keys1:
            if k1 != k2:
                key = []
                for k in k1:
                    if k not in key:
                        key.append(k)
                for k in k2:
                    if k not in key:
                        key.append(k)
                key.sort()
                if key not in keys2:
                    keys2.append(key)
 
    return keys2
 
 
D = [['A', 'C', 'D'], ['B', 'C', 'E'], ['A', 'B', 'C', 'E'], ['B', 'E']]
F = apriori(D, 0.5)
print '\nfrequent itemset:\n', F
# [['B'], ['C'], ['E'], ['B', 'E'], ['C', 'E']]
 

4.合并区间

class Solution:
    """
    解题思路:
    首先，我们将列表中的区间按照左端点升序排序。
    然后我们将第一个区间加入 merged 数组中，并按顺序依次考虑之后的每个区间：
    如果当前区间的左端点在数组 merged 中最后一个区间的右端点之后，那么它们不会重合，
    我们可以直接将这个区间加入数组 merged 的末尾；
    否则，它们重合，我们需要用当前区间的右端点更新数组 merged 中最后一个区间的右端点，将其置为二者的较大值。
    """
    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
        # 按照第一个元素从小到大进行排序
        intervals.sort(key=lambda x: x[0])
        
        # 初始化一个新的数组
        new_list = list()

        for i in intervals:
            # 把第一个数组元素添加到新的数组种
            if not new_list:
                new_list.append(i)
                continue
            
            # 如果有重合 就更新新的数组中的最后一个元素的最大值
            if new_list[-1][1] >= i[0]:
                x = max(new_list[-1][1], i[1])
                new_list[-1][1] = max(new_list[-1][1], i[1])
            else:
                # 如果没有重合 就直接添加到新的数组中
                new_list.append(i)
        
        return new_list

5.两个文件，文件一.txt记录用户和点击量数据，文件二.txt记录用户和城市数据，求每个城市中最大的点击量。

dict_data={}
with open('.../table1.txt','r') as df:
    for kv in [d.strip().split(' ') for d in df]:
        dict_data[kv[0]] = kv[1]
print(dict_data)
dict_data2={}
with open('.../table2.txt','r') as df:
    for kv in [d.strip().split(' ') for d in df]:
        dict_data2[kv[0]] = kv[1]
print(dict_data2)
ans={}
print(dict_data2)
for i in dict_data2:
    ans[dict_data2[i]]=max(int(ans.get(dict_data2[i],0)),int(dict_data[i]))
print(ans)

6.给n个绳子，每次取两个端点打结，求最终绳子打结的期望