文章目录
041 和为S的两个数字
输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。
# -*- coding:utf-8 -*-
class Solution:
def FindNumbersWithSum(self, array, tsum):
i, j = 0, len(array)-1
while i < j:
if array[i] + array[j] == tsum:
return [array[i], array[j]]
while i < j and array[i] + array[j] > tsum:
j -= 1
while i < j and array[i] + array[j] < tsum:
i += 1
return []
042 左旋转字符串
汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！
# -*- coding:utf-8 -*-
class Solution:
def LeftRotateString(self, s, n):
# write code here
ret1,ret2=s[:n],s[n:]
return ret2+ret1
043 翻转单词顺序列
牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？
# -*- coding:utf-8 -*-
class Solution:
def ReverseSentence(self, s):
# write code here
strList=s.split(" ")
return " ".join(strList[::-1])
044 扑克牌顺子
LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张_)…他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子…LL不高兴了,他想了想,决定大\小 王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”。LL决定去买体育彩票啦。 现在,要求你使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何， 如果牌能组成顺子就输出true，否则就输出false。为了方便起见,你可以认为大小王是0。
# -*- coding:utf-8 -*-
class Solution:
def IsContinuous(self, numbers):
# write code here
if len(numbers)<5:
return False
maplist={}
for item in numbers:
if item ==0 :
continue
elif item in maplist:
return False
else:
maplist[item]=1
return True if max(maplist.keys()) -min(maplist.keys())<=4 else False
045 孩子们的游戏
每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。HF作为牛客的资深元老,自然也准备了一些小游戏。其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0…m-1报数…这样下去…直到剩下最后一个小朋友,可以不用表演,并且拿到牛客名贵的“名侦探柯南”典藏版(名额有限哦!!_)。请你试着想下,哪个小朋友会得到这份礼品呢？(注：小朋友的编号是从0到n-1)
# -*- coding:utf-8 -*-
import sys
sys.setrecursionlimit(100000)
class Solution:
def LastRemaining_Solution(self, n, m):
# write code here
if n<1:
return -1
if n ==1:
return 0
return (self.LastRemaining_Solution(n-1,m)+m)%n
046 求1+2+3+…+n
求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。
# -*- coding:utf-8 -*-
class Solution:
def Sum_Solution(self, n):
# write code here
return sum(list(range(1,n+1)))
#return n and n + self.Sum_Solution(n-1)
047 不用加减乘除做加法
写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号。
# -*- coding:utf-8 -*-
class Solution:
def Add(self, num1, num2):
# write code here
#return sum([num1,num2])
"""
while num2:
mainPart = num1^num2
num2 = (num1&num2)<<1
num1 = mainPart
return num1
"""
048 把字符串转成整数
将一个字符串转换成一个整数(实现Integer.valueOf(string)的功能，但是string不符合数字要求时返回0)，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0。
# -*- coding:utf-8 -*-
class Solution:
def StrToInt(self, s):
# write code here
if not s:
return 0
sign=1
if s[0]=='-' or s[0]=='+':
if s[0]=='-':
sign=-1
s=s[1:]
pos=1
value=0
for i in range(len(s)-1,-1,-1):
if '0'<=s[i]<='9':
value+=(ord(s[i])-48)*pos
pos=pos*10
else:
return 0
return value*sign
"""
res,mult,flag = 0,1,1
if not s:
return res
if s[0] == '-' or s[0] == '+':
if s[0] == '-':
flag = -1
s = s[1:]
for i in range(len(s)-1, -1, -1):
if '9' >= s[i] >= '0':
res += (ord(s[i]) - 48)*mult
mult = mult * 10
else:
return 0
return res*flag
"""
049 数组中重复的数字
在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。
# -*- coding:utf-8 -*-
class Solution:
# 这里要特别注意~找到任意重复的一个值并赋值到duplication[0]
# 函数返回True/False
def duplicate(self, numbers, duplication):
# write code here
maplist={}
for item in numbers:
if item in maplist:
duplication[0]=item
return True
else:
maplist[item] =1
return False
050 构建乘积数组
给定一个数组A[0,1,…,n-1],请构建一个数组B[0,1,…,n-1],其中B中的元素B[i]=A[0]A[1]…*A[i-1]A[i+1]…*A[n-1]。不能使用除法。
# -*- coding:utf-8 -*-
class Solution:
def multiply(self, A):
# write code here
ret=[]
length=len(A)
prod=1
for i in range(len(A)):
ret.append(prod)
prod=prod*A[i]
prod=1
for i in range(len(A)-1,-1,-1):
ret[i]*=prod
prod*=A[i]
return ret
051 正则表达式匹配
请实现一个函数用来匹配包括’.‘和’‘的正则表达式。模式中的字符’.‘表示任意一个字符，而’'表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"abaca"匹配，但是与"aa.a"和"ab*a"均不匹配
# -*- coding:utf-8 -*-
class Solution:
# s, pattern都是字符串
def match(self, s, pattern):
# write code here
if len(s)==0 and len(pattern)==0:
return True
if len(s)>0 and len(pattern)==0:
return False
if len(pattern)>1 and pattern[1]=='*':
if len(s) >0 and (s[0]==pattern[0] or pattern[0]=='.'):
return self.match(s,pattern[2:]) or self.match(s[1:],pattern)
else:
return self.match(s,pattern[2:])
if len(s)>0 and (s[0]==pattern[0] or pattern[0]=='.'):
return self.match(s[1:],pattern[1:])
else:
return False
052 表示数值的字符串
请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100",“5e2”,"-123",“3.1416"和”-1E-16"都表示数值。 但是"12e",“1a3.14”,“1.2.3”,"±5"和"12e+4.3"都不是。
# -*- coding:utf-8 -*-
class Solution:
# s字符串
def isNumeric(self, s):
# write code here
hasE=False
sign=False
dec=False
if s == None:
return False
for i in range(len(s)):
if s[i] =='e' or s[i] =='E':
if i==len(s)-1:
return False
if hasE:
return False
hasE=True
elif s[i] =='+' or s[i] =='-':
if sign and s[i-1] !='e' and s[i-1] !='E':
return False
if sign== False and i>0 and s[i-1] !='e' and s[i-1] !='E':
return False
sign=True
elif s[i] =='.':
if hasE or dec:
return False
dec=True
elif s[i]<'0' or s[i]>'9':
return False
return True
053 字符流中第一个不重复的字符
请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。
# -*- coding:utf-8 -*-
class Solution:
# 返回对应char
charDict = {}
s=''
def FirstAppearingOnce(self):
# write code here
for item in self.s:
if self.charDict[item] ==1:
return item
return "#"
def Insert(self, char):
if char in self.charDict:
self.charDict[char]+=1
else:
self.charDict[char]=1
self.s=self.s+char
054 链表中环的入口结点
给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。
# -*- coding:utf-8 -*-
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def EntryNodeOfLoop(self, pHead):
# write code here
fastpointer=pHead
slowpointer=pHead
while fastpointer and fastpointer.next:
fastpointer=fastpointer.next.next
slowpointer=slowpointer.next
if fastpointer==slowpointer:
break
if fastpointer==None or fastpointer.next==None:
return None
fastpointer=pHead
while fastpointer != slowpointer :
slowpointer=slowpointer.next
fastpointer=fastpointer.next
return slowpointer
055 删除链表中重复的结点
在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5
# -*- coding:utf-8 -*-
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def deleteDuplication(self, pHead):
# write code here
first = ListNode(-1)
first.next = pHead
last = first
current = pHead
while current and current.next:
if current.val != current.next.val:
last = last.next
current = current.next
else:
val = current.val
while current and current.val == val:
current = current.next
last.next = current
return first.next
056 二叉树的下一结点
给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
# -*- coding:utf-8 -*-
# class TreeLinkNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
# self.next = None
class Solution:
def GetNext(self, pNode):
# write code here
if pNode.right:
tempNode=pNode.right
while tempNode.left:
tempNode=tempNode.left
return tempNode
else:
tempNode=pNode
while tempNode.next:
if tempNode.next.left==tempNode:
return tempNode.next
tempNode=tempNode.next
return None
057 对称二叉树
请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。
# -*- coding:utf-8 -*-
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def isSymmetrical(self, pRoot):
# write code here
def isMirror(left,right):
if left ==None and right == None:
return True
elif left ==None or right == None:
return False
if left.val !=right.val:
return False
ret1=isMirror(left.left,right.right)
ret2=isMirror(left.right,right.left)
return ret1 and ret2
if pRoot==None:
return True
return isMirror(pRoot.left,pRoot.right)
058 按之字形顺序打印二叉树
请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。
# -*- coding:utf-8 -*-
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def Print(self, pRoot):
# write code here
if pRoot ==None:
return []
stack1=[pRoot]
stack2=[]
ret=[]
while stack1 or stack2:
if stack1:
tempret=[]
while stack1:
pnode =stack1.pop()
tempret.append(pnode.val)
if pnode.left:
stack2.append(pnode.left)
if pnode.right:
stack2.append(pnode.right)
ret.append(tempret)
if stack2:
tempret=[]
while stack2:
pnode =stack2.pop()
tempret.append(pnode.val)
if pnode.right:
stack1.append(pnode.right)
if pnode.left:
stack1.append(pnode.left)
ret.append(tempret)
return ret
059 把二叉树打印成多行
从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。
# -*- coding:utf-8 -*-
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
# 返回二维列表[[1,2],[4,5]]
def Print(self, pRoot):
# write code here
if pRoot ==None:
return []
queue1=[pRoot]
queue2=[]
ret=[]
while queue1 or queue2:
if queue1:
temp=[]
while queue1:
pnode=queue1[0]
temp.append(pnode.val)
del queue1[0]
if pnode.left:
queue2.append(pnode.left)
if pnode.right:
queue2.append(pnode.right)
ret.append(temp)
if queue2:
temp=[]
while queue2:
pnode=queue2[0]
temp.append(pnode.val)
del queue2[0]
if pnode.left:
queue1.append(pnode.left)
if pnode.right:
queue1.append(pnode.right)
ret.append(temp)
return ret
060 序列化二叉树
请实现两个函数，分别用来序列化和反序列化二叉树
# -*- coding:utf-8 -*-
# class TreeNode(int(val))
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def Serialize(self, root):
if not root:
return '#'
return str(root.val) +',' + self.Serialize(root.left) +','+ self.Serialize(root.right)
def Deserialize(self, s):
list = s.split(',')
return self.deserializeTree(list)
def deserializeTree(self, list):
if len(list)<=0:
return None
val = list.pop(0)
root = None
if val != '#':
root = TreeNode(int(val))
root.left = self.deserializeTree(list)
root.right = self.deserializeTree(list)
return root
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
