数据结构（剑指offer）（数组）(python)

 

 

题目描述

数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。

###解释
counter 是一种特殊的字典，主要方便用来计数，key 是要计数的 item，value 保存的是个数。

?
1
2
3
4
from collections import Counter
 
>>> c = Counter('hello,world')
Counter({'l': 3, 'o': 2, 'e': 1, 'd': 1, 'h': 1, ',': 1, 'r': 1, 'w': 1})
初始化可以传入三种类型的参数：字典，其他 iterable 的数据类型，还有命名的参数对。

?
1
2
3
4
5
6
7
8
9
| __init__(self, iterable=None, **kwds)
|  Create a new, empty Counter object. And if given, count elements
|  from an input iterable. Or, initialize the count from another mapping
|  of elements to their counts.
|
|  >>> c = Counter()       # a new, empty counter
|  >>> c = Counter('gallahad')     # a new counter from an iterable
|  >>> c = Counter({'a': 4, 'b': 2})   # a new counter from a mapping
|  >>> c = Counter(a=4, b=2)     # a new counter from keyword args
默认请求下，访问不存在的 item，会返回 0。Counter 可以用来统计某些数据的出现次数，比如一个很长的数字串 numbers = "67642192097348921647512014651027586741512651" 中每个数字的频率：

?
1
2
3
4
5
6
7
8
9
10
11
12
>>> c = Counter(numbers) # c 存储了每个数字的频率
>>> c.most_common()  # 所有数字按照频率排序。如果 most_common 接受了 int 参数 n，将返回频率前n 的数据，否则会返回所有的数据
[('1', 8),
 ('2', 6),
 ('6', 6),
 ('5', 5),
 ('4', 5),
 ('7', 5),
 ('0', 3),
 ('9', 3),
 ('8', 2),
 ('3', 1)]
此外，你还可以对两个 Counter 对象进行 +, -，min， max 等操作。

综合示例：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
print('Counter类型的应用') 
c = Counter("dengjingdong") 
#c = Counter({'n': 3, 'g': 3, 'd': 2, 'i': 1, 'o': 1, 'e': 1, 'j': 1}) 
print("原始数据：",c) 
print("最多的两个元素：",c.most_common(2))#输出数量最多的元素 
print("d的个数：",c['d'])#输出d的个数 
print(c.values())#输出字典的value列表 
print(sum(c.values()))#输出总字符数 
print(sorted(c.elements()))#将字典中的数据，按字典序排序 
print('\n\n') 
""" 
#删除所有d元素 
del c['d'] 
b = Counter("dengxiaoxiao") 
#通过subtract函数删除元素，元素个数可以变成负数。 
c.subtract(b) 
"""
  
""" 
可以添加数据 
b = Counter("qinghuabeida") 
c.update(b) 
"""

# -*- coding:utf-8 -*-

import collections
class Solution:
    def MoreThanHalfNum_Solution(self,numbers):
        c = collections.Counter(numbers)
        x = len(numbers)/2
        for k,v in c.items():
            if v > x:
                return k
        return 0

 

 

题目描述

输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。

# -*- coding:utf-8 -*-
class Solution:
    def GetLeastNumbers_Solution(self, tinput, k):
        # write code here
        if tinput is None:
            return []
        n = len(tinput)
        if n<k:
            return []
        tinput = sorted(tinput)
        return tinput[:k]

 

题目描述

HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)

##解释

解法一：举例分析数组的规律

从头到尾逐个累加数组中的每个数字，初始化和为0；（nCurrSum=0，nGreatestNum=int.MinValue）

定义两个变量：“累加子数组和”和“最大子数组和”，第一步把数组中的第一个数字赋值给他们，然后从第二个数字开始累加，累加值放入“累加子数组和”。

1.如果当前“累加子数组和”小于0，那抛弃前面的“累加子数组和”，从下一个数字开始重新累加，“最大子数组和”的值不更新。

2.如果当前“累加子数组和”大于0，再让当前“累加子数组和”和当前的“最大子数组和”进行比较。

           2.1如果当前“累加子数组和”大于当前“最大子数组和”，则更新“最大子数组和”的值为“累加子数组和”的值。

           2.2如果当前“累加子数组和”小于当前“最大子数组和”，“最大子数组和”的值不更新。

3.再加入数组中的下一个值，“累加子数组和”进入下一轮的累加，“最大子数组和”也进入下一轮的更新。知道数组中所有值都累加完毕。

这样进行一次累加的遍历之后，就可以得到最终的最大累加和，时间复杂度是O(n)。下图展示了数组{1，-2，3，10，-4，7，2，-5}求连续子数组的最大和的过程：



把过程分析清楚之后，我们就可以动手写代码了。
--------------------- 
作者：kongmin_123 
来源：优快云 
原文：https://blog.youkuaiyun.com/kongmin_123/article/details/82430985 
版权声明：本文为博主原创文章，转载请附上博文链接！

# -*- coding:utf-8 -*-
class Solution:
    def FindGreatestSumOfSubArray(self, array):
        # write code here
        if array is None:
            return 
        n = len(array)
        temp_sum = 0
        max_list = []
        sum_list = []
        for i in range(n):
            if temp_sum < 0:
                temp_sum = 0
            temp_sum = temp_sum+array[i]
            sum_list.append(temp_sum)
            if len(max_list) == 0:
                max_list.append(temp_sum)
            elif temp_sum > max_list[-1]:
                max_list.append(temp_sum)
        return max_list[-1]

 

题目描述

求出1~13的整数中1出现的次数,并算出100~1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。

# -*- coding:utf-8 -*-
class Solution:
    def NumberOf1Between1AndN_Solution(self, n):
        # write code here
        count = 0
        for i in range(1,n+1):
            s = list(str(i))
            count = count+ s.count('1')
        return count

 

题目描述

输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。

# -*- coding:utf-8 -*-
import itertools

class Solution:
    def PrintMinNumber(self, numbers):
        # write code here
        if len(numbers) == 0:
            return ''
        x = list(itertools.permutations(numbers))  #排列组合
        new_data=[]
        for i in x:
            n_str = ''.join(str(n) for n in i)
            n_str = int(n_str)
            new_data.append(n_str)
            min_n = min(new_data)
        return min_n

题目描述

把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含质因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。

# -*- coding:utf-8 -*-
class Solution:
    def GetUglyNumber_Solution(self, index):
        # write code here
        if index == 0:
            return 0
        if index == 1:
            return 1
        t2,t3,t5 = 0,0,0
        ans = [1]
        for i in range(1,index+1):
            ans.append(min(ans[t2]*2,ans[t3]*3,ans[t5]*5))
            if ans[i] == ans[t2]*2:
                t2 = t2+1
            if ans[i] == ans[t3]*3:
                t3 = t3+1
            if ans[i] == ans[t5]*5:
                t5 = t5+1
        return ans[index-1]

 

题目描述

一个整型数组里除了两个数字之外，其他的数字都出现了偶数次。请写程序找出这两个只出现一次的数字。

# -*- coding:utf-8 -*-
class Solution:
    # 返回[a,b] 其中ab是出现一次的两个数字
    def FindNumsAppearOnce(self, array):
        # write code here
        temp = []
        for i in array:
            if array.count(i) == 1:
                temp.append(i)
        return temp

 

题目描述

小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!

输出描述:

输出所有和为S的连续正数序列。序列内按照从小至大的顺序，序列间按照开始数字从小到大的顺序

# -*- coding:utf-8 -*-
class Solution:
    def FindContinuousSequence(self, tsum):
        # write code here
        res = []
        for i in range(1,tsum/2+1):
            for j in range(i,tsum/2+2):
                tmp = (j+i)*(j-i+1)/2
                if tmp>tsum:
                    break
                elif tmp==tsum:
                    res.append(range(i,j+1))
        return res

 

题目描述

输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。

输出描述:

对应每个测试案例，输出两个数，小的先输出。

# -*- coding:utf-8 -*-
class Solution:
    def FindNumbersWithSum(self, array, tsum):
        # write code here
        res = []
        if array is None:
            return []
        n = len(array)
        for i in range(n):
            w1 = array[i]
            for j in range(i,n):
                w2 = array[j]
                t = w1+w2
                if t == tsum:
                    res.append([w1,w2])
        if res:
            return res[0]
        else:
            return res

# -*- coding:utf-8 -*-
class Solution:
    def FindNumbersWithSum(self, array, tsum):
        # write code here
        ls = []
        if not isinstance(array, list):
            return ls
        for i, v in enumerate(array):
            for v1 in array[i:]:
                if (v + v1) == tsum:
                    ls.append([v, v1])
        if ls:
            return ls[0]
        else:
            return ls