1、剪绳子
给你一根长度为n的绳子，请把绳子剪成整数长的m段（m、n都是整数，n>1并且m>1），每段绳子的长度记为k[0],k[1],…,k[m]。请问k[0]xk[1]x…xk[m]可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。
解题思路：
- 先举几个例子，可以看出规律来。
- n：f(n)
- 特殊点：带1的
- 2: 1*1
- 3： 2*1
- 正常点：只有2和3
- 4 ： 2*2
- 5 ： 2*3
- 6 ： 3*3
- 7 ： 223 或者4*3
- 8 ： 233
- 9 ： 333
- 10：2233 或者43*3
- 11：233*3
- 12：333*3
- 13：22333 或者433*3
- 下面是分析：
- 首先判断k[0]到k[m]可能有哪些数字，实际上只可能是2或者3。
- 当然也可能有4，但是4=2*2，我们就简单些不考虑了。
- 5<23,6<33,比6更大的数字我们就更不用考虑了，肯定要继续分。
- 其次看2和3的数量，2的数量肯定小于3个，为什么呢？因为
2*2*2<3*3，那么题目就简单了。 - 直接用n除以3，根据得到的余数判断是一个2还是两个2还是没有2就行了,余数为1，则两个2，余数为0，没有2，余数为2，则1个2。
- 由于题目规定
m>1,n>1，所以2只能是1*1，3只能是2*1，这两个特殊情况直接返回就行了。 m>1(m=2,3,4,...n-1),2<=n<=60
# -*- coding:utf-8 -*-
class Solution:
def cutRope(self, number):
# write code here
if number == 2:
return 1
if number == 3:
return 2
x = number % 3 # 取余
y = number // 3 # 取整
#dp = [1]
if (x == 0):
return pow(3, y) # 3^y
elif (x == 1):
return 2 * 2 * pow(3, y - 1)
else:
return 2 * pow(3, y)
pass
pass
pass
sr=Solution()
print(sr.cutRope(8))
2、数据流中的中位数
如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流（1个1个值给你），使用GetMedian()方法获取当前读取数据的中位数。
# -*- coding:utf-8 -*-
class Solution:
def __init__(self):
self.num=[]
def Insert(self, num):
# write code here
self.num.append(num)
def GetMedian(self):
# write code here
self.num.sort()
n=len(self.num)
if n%2==0:
m=int(n//2)
return int((self.num[m]+self.num[m-1])/2)
else:
m=int(n//2)
return self.num[m]
pass
pass
pass
zws=Solution()
zws.Insert(2)
zws.Insert(1)
zws.Insert(4)
zws.Insert(8)
print(zws.GetMedian())
3、整数中1出现的个数（1到n的整数中）
求出1-13的整数中1出现的次数,并算出100-1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。
解题思路：
分别除以10 ，将数拆分开，例如12143，除以10取余分别为3,4,1,2,1
# -*- coding:utf-8 -*-
class Solution:
def NumberOf1Between1AndN_Solution(self, n):
# write code here
if n<1:
return 0
Count = []
for c in list(range(1, n+1)):
# print(n)
l = []
count = 0
while (c > 0):
l.append(c % 10)
c = c // 10
# print(l)
for num in range(0, len(l)):
if l[num] == 1:
count += 1
else:
count = count
pass
pass
# print(count)
Count.append(count)
pass
return sum(Count)
pass
pass
pass
gs=Solution()
print(gs.NumberOf1Between1AndN_Solution(50))
优化：
class Solution:
def NumberOf1Between1AndN_Solution(self, n):
# write code here
if n < 1:
return 0
num=list(range(1,n+1))
num2=[]
for i in num:
x=list(map(int,str(i))) # 12-->[1,2]
for j in x:
if j==1:
num2.append(1)
else:
num2.append(0)
return sum(num2)
gs=Solution()
print(gs.NumberOf1Between1AndN_Solution(50))
4、连续子数组的最大和
HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止，其他连续的和小于8)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)
解题思路：
6+（-3）=3<6,3>(-3),目前最大值是6，但是3比从-3开始往后面好；
3+（-2）=1<6,1>(-2),最大值6,1比（-2）开始好；
1+7=8>6,7,替换最大值6变成最大值8，比7开始好；
8-15=-7<8,-7>-15,最大值8，比-15开始好；
-7+1=-6<1,最大值8，没有1开始好，所以从1开始继续操作第一步；
1+2=3>2,比2开始好，最大值3；
3+2=5>2,3，比2开始好，最大值5；
比较两个最大值：8>5，左移最大值为8
集合会自动排序，所以本题不能输入集合。
# -*- coding:utf-8 -*-
class Solution:
def FindGreatestSumOfSubArray(self, array):
# write code here
maxnum=None
tmpnum=0
for i in array:
if maxnum==None:
maxnum=i
pass
if tmpnum+i<i: # 比较有没有不加好
tmpnum=i
else:
tmpnum+=i
pass
if maxnum<tmpnum:
maxnum=tmpnum
pass
return maxnum
zds=Solution()
print(zds.FindGreatestSumOfSubArray([6,-3,-2,7,-15,1,2,2]))
5、孩子们的游戏（圆圈中最后剩下的数）
每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。HF作为牛客的资深元老,自然也准备了一些小游戏。其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0…m-1报数…这样下去…直到剩下最后一个小朋友,可以不用表演,并且拿到牛客名贵的“名侦探柯南”典藏版(名额有限哦!!_)。请你试着想下,哪个小朋友会得到这份礼品呢？(注：小朋友的编号是从0到n-1)。如果没有小朋友，请返回-1
这道题的背景是约瑟夫环：
约瑟夫环（约瑟夫问题）是一个数学的应用问题：已知n个人（以编号1，2，3…n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。
在约瑟夫环中，只是需要求出最后的一个出列者最初的序号，而不必要去模拟整个报数的过程。因此，为了追求效率，可以考虑从数学角度进行推算，找出规律然后再编写程序即可。
上面编写的解约瑟夫环的程序模拟了整个报数的过程，因为N和M都比较小，程序运行时间还可以接受，很快就可以出计算结果。可是，当参与的总人数N及出列值M非常大时，其运算速度就慢下来。例如，当N的值有上百万，M的值为几万时，到最后虽然只剩2个人，也需要循环几万次（由M的数量决定）才能确定2个人中下一个出列的序号。显然，在这个程序的执行过程中，很多步骤都是进行重复无用的循环。
那么，能不能设计出更有效率的程序呢？
办法当然有。其中，在约瑟夫环中，只是需要求出最后的一个出列者最初的序号，而不必要去模拟整个报数的过程。因此，为了追求效率，可以考虑从数学角度进行推算，找出规律然后再编写程序即可。
为了讨论方便，先根据原意将问题用数学语言进行描述。
问题：将编号为0～（N–1）这N个人进行圆形排列，按顺时针从0开始报数，报到M–1的人退出圆形队列，剩下的人继续从0开始报数，不断重复。求最后出列者最初在圆形队列中的编号。
下面首先列出0~(N-1)这N个人的原始编号如下：
0 1 2 3 … N-3 N-2 N-1
根据前面曾经推导的过程可知，第一个出列人的编号一定是(M–1)%N。例如，在13个人中，若报到3的人出列，则第一个出列人的编号一定是(4–1)%13=3，注意这里的编号是从0开始的，因此编号3实际对应以1为起点中的编号4。根据前面的描述，m的前一个元素(M–1)已经出列，则出列1人后的列表如下：
0 1 2 3 … M-3 M-2 ○ M M+1 M+2 … N-3 N-2 N-1
注意，上面的圆圈表示被删除的数。
根据规则，当有人出列之后，下一个位置的人又从0开始报数，则以上列表可调整为以下形式（即以M位置开始，N–1之后再接上0、1、2……，形成环状）：
M M+1 M+2 … N-2 N-1 0 1 … M-3 M-2
按上面排列的顺序从0开始重新编号，可得到下面的对应关系：
M M+1 M+2 … N-2 N-1 0 1 … M-3 M-2
0 1 2 … N-(M+2) N-(M+1) N-M N-(M-1) … N-3 N-2
这里，假设上一行的数为x，下一行的数为y，则对应关系为:
x = (y + M) % N 公式【1】 相当于前移了M位置，防止过区间，所以取余
通过上表的转换，将出列1人后的数据重新组织成了0～（N–2）共N–1个人的列表，继续求N–1个参与人员，按报数到M–1即出列，求解最后一个出列者最初在圆形队列中的编号。
看出什么规律没有？通过一次处理，将问题的规模缩小了。即对于N个人报数的问题，可以分解为先求解（N–1）个人报数的子问题；而对于（N–1）个人报数的子问题，又可分解为先求[(N-1)-1]个人报数的子问题，……。
问题中的规模最小时是什么情况？就是只有1个人时（N=1），报数到（M–1）的人出列，这时最后出列的是谁？当然只有编号为0这个人。因此，可设有以下函数：
F(1) = 0
那么，当N=2，报数到（M–1）的人出列，最后出列的人是谁？应该是只有一个人报数时得到的最后出列的序号加上M，因为报到M-1的人已出列，只有2个人，则另一个出列的就是最后出列者，利用公式【1】，可表示为以下形式：
F(2) = [F(1) + M] % N = [F(1) + M] % 2
于是，咱们可以得到递推公式：
F(1) = 0
F(N) = [F(N - 1) + M] % N (N>1)
设计编程：
# -*- coding:utf-8 -*-
class Solution:
def LastRemaining_Solution(self, n, m):
# write code here
if n is None or m is None or n < 1 or m < 1:
return -1
if n==1:
return 0
last_out=0 # 最后出的人的编号
for index in range(2,n+1): # n从2开始到n结束
last_out=(last_out+m)%index #递归，F(n)=(F(n-1)+m)%n,n>1
return last_out
isv=Solution()
print(isv.LastRemaining_Solution(5,2))
6、数组中出现次数超过一半的数字
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。
# -*- coding:utf-8 -*-
class Solution:
def MoreThanHalfNum_Solution(self, numbers):
# write code here
for item in set(numbers):
if numbers.count(item) > len(numbers)/2:
return item
return 0
tj= Solution()
print(tj.MoreThanHalfNum_Solution([1,2,3,2,2,2,5,4,2]))
7、数值的整数次方
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。保证base和exponent不同时为0
# -*- coding:utf-8 -*-
class Solution:
'''
给定一个double类型的浮点数base和int类型的整数exponent。
求base的exponent次方。
保证base和exponent不同时为0
'''
def Power(self, base, exponent):
# write code here
if base == 0:
return 0
elif base == 1:
return 1
elif exponent == 0:
return 1
elif exponent == 1:
return base
else:
return pow(base, exponent)
cf=Solution()
print(cf.Power(1.5,2))
8、斐波那契数列
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。n<=39
# -*- coding:utf-8 -*-
class Solution:
'''
菲波那切数列
F(1)=1，F(2)=1, F(n)=F(n - 1)+F(n - 2)（n ≥ 3，n ∈ N*）
1、1、2、3、5、8、13、21、34
'''
def Fibonacci(self, n):
# write code here
if n==0:
return 0
if n==1 or n==2:
return 1
if 2<n<=39:
s = [] * n
s.append(1) #s[0]
s.append(1) #s[1]
for i in range(2, n):
s.append(s[i - 2] + s[i - 1])
return s[n - 1]
fbnq=Solution()
print(fbnq.Fibonacci(6))
198
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
