1、兩數之和
arg = [2, 3, 6, 5]
target = 4

for i in range(len(arg)):
other = target - arg[i]
if other in arg[i+1:]:
print(i, arg[i+1:].index(other)+i+1)
else:
print(“輸入目標數在該列表中不存在”)

2、回文數
方法一：
class Solution:
def isPalindrome(self, x):
return str(x) == str(x)[::-1]

方法二：
class Solution:
def isPalindrome(self, x):
# 不用字符串，則用數學思想解
if x < 0 or (x % 10 == 0 and x !=0 ):
return False
rem = 0
while x > rem:
rem = rem*10 + x%10
x = x//10
return x == rem or x == rem//10
3、羅馬數字轉換為整數：
class Solution:
def romanToInt(self, s):
# I 1
# V 5
# X 10
# L 50
# C 100
# D 500
# M 1000

dict_num = {'I':1,'IV':4,'V':5,'IX':9,'X':10,'XL':40,'L':50,'XC':90,'C':100,'CD':400,'D':500,'CM':900,'M':1000}ret, i =0, 0while i < len(s):if s[i: i+2] in dict_num:ret += dict_num[s[i:i+2]]i += 2else:ret += dict_num[s[i]]i += 1return ret

if name == ‘main’:
method = Solution()
x = input()
ret = method.isPalindrome(x)
print(ret)

4、最長公共前綴
class Solution(object):
def longestCommonPrefix(self, strs):
“”"
:type strs: List[str]
:rtype: str
“”"
if not strs:
return ‘’

s1, s2 = min(strs), max(strs)print(s1, s2)for i in range(len(s1)):if s1[i] != s2[i]:return s1[:i]return s1

if name == ‘main’:
method = Solution()
x = [“flower”,“flow”,“flightwe”]
ret = method.longestCommonPrefix(x)
print(ret)

5、有效的括號
class Solution(object):
def longestCommonPrefix(self, s):
# 判斷字符串3種括號的個數
if s.count(‘()’) + s.count(‘[]’) + s.count(‘{}’) != 0:
# 當個數不為0的時候，以此替換3種括號為空,直到字符串中不存在完整的括號時退出循環
s = s.replace(‘()’, ‘’)
s = s.replace(‘{}’, ‘’)
s = s.replace(‘[]’, ‘’)
# 退出循環后，如果字符串為空，則字符串包含有效的括號；反之，則包含無效（不完整）括號
if s:
return False
else:
return True

6、合并兩個有序鏈表
class Solution:
def mergeTwoLists(self, list1, list2):
for i in range(len(list2)):
list1.append(list2[i])
ret = sorted(list1)
return ret
if name == ‘main’:
method = Solution()
list1 = []
list2 = []
ret = method.mergeTwoLists(list1, list2)
print(ret)

Definition for singly-linked list.

class ListNode:

def init(self, val=0, next=None):

self.val = val

self.next = next

class Solution:

將鏈表轉換為list

def iterNode(self,node):output=list()while True:try:output.append(node.val)node=node.nextexcept:breakreturn output

將list轉換為鏈表

def iterList(self,array):output=ListNode(array[0])array=array[1:]while True:try:output=ListNode(array[0],output)array.pop(0)except:breakreturn outputdef mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:

避免l1和l2都是空的情況

try:if l1==l2:l1.nextexcept:return l1

l1和l2轉list

l1=self.iterNode(l1)l2=self.iterNode(l2)

list相加，排序，翻轉

total=l1+l2total.sort()total.reverse()

返回list轉鏈表

return self.iterList(total)

7、刪除有序數組中的重復項
方法一:

class Solution:
def removeDuplicates(self, nums: List[int]) -> int:
# 對列表進行循環修改時要使用nums[:]而不是nums
for n in nums[:]:
if nums.count(n) > 1:
nums.remove(n)
return len(nums)
方法二:

class Solution:
def removeDuplicates(self, nums: List[int]) -> int:
nums[:] = list(sorted(set(nums)))
return len(nums)

# 因為python中的集合的自動排序是正數負數分開的，所以要用sorted排序# 如果等號左邊是nums而不是nums[:]，那么nums只是指向了另一個列表而已，# 并沒有原地修改列表，原來的列表也就沒有變

8、移除元素
class Solution:
def removeElement(self, nums: List[int], val: int) -> int:
for i in nums[:]:
if i == val:
if nums.count(i) > 0:
nums.remove(i)
return len(nums)

9、搜索插入位置
class Solution:
def sameTarget(self, nums: List[int], target: int) -> int:
for i in range(len(nums)):
if nums[i] == target:
return i
def searchInsert(self, nums: List[int], target: int) -> int:
if target in nums:
return self.sameTarget(nums,target)
else:
if target not in nums:
nums.append(target)
nums = sorted(nums)
return self.sameTarget(nums,target)

10、最后一個單詞的長度
class Solution:
def lengthOfLastWord(self, s: str) -> int:
return len(s.split()[-1])

11、加一
class Solution:
def plusOne(self, digits: List[int]) -> List[int]:
digits = digits[-1]+1
return digits

12、二進制求和
class Solution:
def addBinary(self, a: str, b: str) -> str:
a, b = int(a,2),int(b,2)
sum = a + b
binNum = str(bin(sum))[2:]
return binNum

13、x的平方根

14、爬樓梯
class Solution:
def climbStairs(self, n: int) -> int:
if n == 1:
return n
if n == 2:
return n
temp1 = 1
temp2 = 2
temp = 0
for i in range(3, n+1):
temp = temp1+temp2
temp1 = temp2
temp2 = temp
return temp

15、刪除排序鏈表的重復元素
class Solution:
def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
p = head
while p and p.next:
if p.val == p.next.val:
p.next = p.next.next
continue
p = p.next
return head

16、合并兩個有序數組
class Solution:
def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
“”"
Do not return anything, modify nums1 in-place instead.
“”"
nums1[m:] = nums2
nums1.sort()
return nums1

17、二叉樹的遍歷
class Solution:
def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
if not root:
return []
left = self.inorderTraversal(root.left)
right = self.inorderTraversal(root.right)
return left + [root.val] + right

18、相同的樹
class Solution:
def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
def preorder(root):
if not root:
return [None]
else:
return [root.val] +preorder(root.left)+preorder(root.right)
return preorder§==preorder(q)

19、判斷對稱二叉樹
class Solution:
def isSymmetric(self, root: TreeNode) -> bool:
def helper(left_root, right_root):
if not left_root and not right_root:
return True
if not left_root or not right_root or abs(left_root.val-right_root.val)>0:
return False
return helper(left_root.left, right_root.right) and helper(left_root.right, right_root.left)
return helper(root.left, root.right)

求最小公倍數的算法:

最小公倍數 = 兩個整數的乘積 / 最大公約數

所以我們首先要求出兩個整數的最大公約數, 求兩個數的最大公約數思路如下:

求最大公約數算法:

① 整數A對整數B進行取整, 余數用整數C來表示 舉例: C = A % B

② 如果C等于0,則C就是整數A和整數B的最大公約數

③ 如果C不等于0, 將B賦值給A, 將C賦值給B ,然后進行 1, 2 兩步,直到余數為0, 則可以得知最大公約數

20、最小公倍數為 K 的子數組數目：
class Solution:
def gcd(self, x, y):
z = 0
while y:
x, y = y, x%y
return x

def lcm(self, a, b):g = gcd(a,b)lcm = a*b/greturn lcmdef subarrayLCM(self, nums: List[int], k: int) -> int:""":type nums: List[int]:type k: int:rtype: int"""count = 0m = 0for i in range(len(nums)):m = nums[i]for j in range(i, len(nums)):m = lcm(m, nums[j])if m == k:count += 1elif m > k:breakelse:continuereturn count

21、只出現一次的數字
class Solution:
def singleNumber(self, nums: List[int]) -> int:
for i in range(len(nums)):
if nums.count(nums[i]) == 1:
return nums[i]
22、二叉樹的最大深度
class Solution:
def maxDepth(self, root: Optional[TreeNode]) -> int:
if not root:
return 0
else:
left = self.maxDepth(root.left)
right = self.maxDepth(root.right)
return max(left,right)+1

23、顛倒二進制位
class Solution:
# @param n, an integer
# @return an integer
def reverseBits(self, n):
res = ‘{:032b}’.format(n) # 注意轉換成32為無符號整形，res=bin(n)在這里會出錯，ide不會
res = res[::-1] # 翻轉
res = int(res, 2)
return res

24、位1的個數：
class Solution:
def hammingWeight(self, n: int) -> int:
ret = ‘{:032b}’.format(n)
return str(ret).count(‘1’)

25、有效電話號碼：
cat file.txt | grep -P “^(([0-9]{3})\s|[0-9]{3}-)[0-9]{3}-[0-9]{4}$”

26、第十行
cat file.txt | sed -n 10p

27、 刪除重復的電子郵箱
DELETE p1 FROM Person p1,Person p2 WHERE p1.email = p2.email and p1.id > p2.id;

28、有效的字母異位詞
class Solution(object):
def isAnagram(self, s, t):
“”"
:type s: str
:type t: str
:rtype: bool
“”"
for aphal in s:
if s.count(aphal) == t.count(aphal):
ret = True
else:
ret = False
return ret
29、冒泡排序：
num = [1,4,5,2,3,6,8]
for i in range(len(num)-1):
for j in range(len(num)-i-1):
if num[j] > num[j+1]:
num[j],num[j+1] = num[j+1],num[j]
print(num)

總結

以上是生活随笔為你收集整理的力库华为机试题练习的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。