Bảng cheat Python GitHub

GitHub - gto76/python-cheatsheet. Bảng mã Python toàn diện

github. com

Václav Kotyk

Người tìm kiếm tài năng RnD @ SentinelOne CZ/SK. Tương lai của an ninh mạng sẽ do bạn quyết định 🛡️👾

• Báo cáo nhận xét này

  Bài báo cáo

  Bài báo cáo

  Quay lại Gửi

Cũng có sẵn dưới dạng PDF qua Alex Wang ➡️ https. //www. linkin. com/posts/mengyaowang11_python-tips-activity-6915272998266556416-GD99

Cheat sheet có thể thực sự hữu ích khi bạn đang thử một tập hợp các bài tập liên quan đến một chủ đề cụ thể hoặc làm việc trên một dự án. Bởi vì bạn chỉ có thể chứa quá nhiều thông tin trên một tờ giấy, hầu hết các tờ giấy gian lận là một danh sách đơn giản các quy tắc cú pháp. Bộ cheat sheet này nhằm mục đích nhắc nhở bạn về các quy tắc cú pháp, nhưng cũng nhắc nhở bạn về các khái niệm quan trọng. Bạn có thể nhấp vào đây và tải xuống tất cả các trang gốc trong một tài liệu

Phiên bản cập nhật gần đây hơn của các trang tính này (tháng 4 năm 2021) có sẵn thông qua Leanpub. Phiên bản cập nhật bao gồm một trang tính tập trung vào thông tin cơ bản về Git, phiên bản đen trắng thân thiện với máy in của mỗi trang tính và mỗi trang tính là một tài liệu riêng biệt. Có một tùy chọn để tải xuống bộ cập nhật đầy đủ miễn phí

Nếu bạn muốn biết khi nào có thêm tài nguyên, bạn có thể đăng ký nhận thông báo qua email tại đây

Tài liệu tham khảo Python3 cho các vấn đề mã hóa phỏng vấn/lập trình cạnh tranh nhẹ. đóng góp hoan nghênh

Làm sao

Tôi đã xây dựng bảng tính này trong khi tự học Python3 cho nhiều cuộc phỏng vấn khác nhau và viết mã để giải trí sau khi không sử dụng Python trong khoảng một thập kỷ. Bảng báo cáo này chỉ chứa mã mà tôi không biết nhưng cần sử dụng để giải quyết một vấn đề mã hóa cụ thể. Tôi đã làm điều này để cố gắng có được một tập hợp con tần số cao nhỏ hơn của Python so với danh sách toàn diện của tất cả các phương thức. Ngoài ra, hành động ghi lại cú pháp và thuật toán đã giúp tôi lưu trữ nó trong bộ nhớ và kết quả là tôi hầu như không bao giờ thực sự tham khảo trang tính này. Hy vọng rằng nó sẽ giúp bạn trong nỗ lực của bạn hoặc truyền cảm hứng cho bạn để xây dựng của riêng bạn và may mắn nhất

Tại sao

Quy tắc quyền lực tối thiểu

Tôi chọn Python3 mặc dù đã quen thuộc hơn với Javascript, Java, C++ và Golang cho các cuộc phỏng vấn vì tôi cảm thấy Python có sự kết hợp của hầu hết các thư viện tiêu chuẩn hiện có cũng như cú pháp tương tự như mã psuedo, do đó là ngôn ngữ biểu cảm nhất. Cả Python và Java đều có nhiều ví dụ nhất nhưng Python thắng trong trường hợp này do ngắn gọn hơn nhiều. Tôi đã có thể chuẩn bị một cách hợp lý với cú pháp Python sau sáu tuần thực hành. Sau khi chọn Python, tôi đã hẹn giờ giải các bài tập tương tự trong Golang và Python. Mặc dù tôi thích Golang hơn, nhưng tôi thấy rằng tôi có thể hoàn thành các ví dụ về Python trong một nửa thời gian thậm chí chiếm thêm hơn 50% lỗi (xấp xỉ) mà tôi thường mắc phải trong Python vs Go. Điều này đang tối ưu hóa cho các câu hỏi phỏng vấn đã được giải quyết dưới áp lực, khi hiệu suất được xem xét thì Go/C++ thực hiện nhất quán bằng 1/10 thời gian của Python. Trong một số trường hợp hiếm hoi, các thuật toán hết thời gian trong Python đôi khi vượt qua C++/Go on Leetcode

chữ

255, 0b11111111, 0o377, 0xff # Integers (decimal, binary, octal, hex) 123.0, 1.23 # Float 7 + 5j, 7j # Complex 'a', '\141', '\x61' # Character (literal, octal, hex) '\n', '\\', '\'', '\"' # Newline, backslash, single quote, double quote "string\n" # String of characters ending with newline "hello"+"world" # Concatenated strings True, False # bool constants, 1 == True, 0 == False [1, 2, 3, 4, 5] # List ['meh', 'foo', 5] # List (2, 4, 6, 8) # Tuple, immutable {'name': 'a', 'age': 90} # Dict {'a', 'e', 'i', 'o', 'u'} # Set None # Null var

vòng lặp

Đi qua tất cả các yếu tố

i = 0 while i < len(str): i += 1

tương đương

for i in range(len(message)): print(i)

Nhận chỉ số số lớn nhất từ ​​​​phải

while i > 0 and nums [i-1] >= nums[i]: i -= 1

Đảo ngược thủ công

l, r = i, len(nums) - 1 while l < r: nums[l], nums[r] = nums[r], nums[l] l += 1 r -= 1

Vượt qua vòng lặp nếu chúng tôi thông minh với ranh giới của bạn

for i in range(len(message) + 1): if i == len(message) or message[i] == ' ':

Vui với Phạm vi - phạm vi (bắt đầu, dừng, bước)

for a in range(0,3): # 0,1,2 for a in reversed(range(0,3)) # 2,1,0 for i in range(3,-1,-1) # 3,2,1,0 for i in range(len(A)//2): # A = [0,1,2,3,4,5] print(i) # 0,1,2 print(A[i]) # 0,1,2 print(~i) # -1,-2,-3 print(A[~i]) # 5,4,3

Dây

str1.find('x') # find first location of char x and return index str1.rfind('x') # find first int location of char x from reverse

Phân tích nhật ký trên ". "

________số 8_______

Đảo ngược hoạt động với phân chia tích hợp, [. -1] và " ". tham gia()

# s = "the sky is blue" def reverseWords(self, s: str) -> str: wordsWithoutWhitespace = s.split() # ['the', 'sky', 'is', 'blue'] reversedWords = wordsWithoutWhitespace[::-1] # ['blue', 'is', 'sky', 'the'] final = " ".join(reversedWords) # blue is sky the

Phân chia thủ công dựa trên isalpha()

i = 0 while i < len(str): i += 10

Loại thử nghiệm của char

i = 0 while i < len(str): i += 11

chữ và số

i = 0 while i < len(str): i += 12

Lấy chỉ số ký tự

i = 0 while i < len(str): i += 13

Thay thế các ký tự hoặc chuỗi

i = 0 while i < len(str): i += 14

Chèn giá trị vào chuỗi

i = 0 while i < len(str): i += 15

Nhân các chuỗi/danh sách với *, thậm chí cả các phép toán luận ánh xạ tới True(1) và False(0)

i = 0 while i < len(str): i += 16

Tìm chuỗi con trong chuỗi

i = 0 while i < len(str): i += 17

startedwith và endwith rất tiện dụng

i = 0 while i < len(str): i += 18

Chuỗi định dạng Python3

i = 0 while i < len(str): i += 19

In chuỗi với tất cả các ký tự, hữu ích cho việc gỡ lỗi

for i in range(len(message)): print(i)0

cắt lát

giới thiệu cắt lát

for i in range(len(message)): print(i)1

Đi qua số và nhận các kết hợp thiếu thành viên

for i in range(len(message)): print(i)2

Tuple

Bộ sưu tập được đặt hàng và không thể thay đổi

for i in range(len(message)): print(i)3

Có thể được sử dụng với Dicts

for i in range(len(message)): print(i)4

Loại

đã sắp xếp (có thể lặp lại, khóa = khóa, đảo ngược = đảo ngược)

Sắp xếp sắp xếp theo thứ tự bảng chữ cái, từ nhỏ nhất đến lớn nhất

for i in range(len(message)): print(i)5

for i in range(len(message)): print(i)6

Sắp xếp khóa theo giá trị, ngay cả khi giá trị là một danh sách

for i in range(len(message)): print(i)7

for i in range(len(message)): print(i)8

Sắp xếp một mảng nhưng giữ các chỉ mục ban đầu

for i in range(len(message)): print(i)9

Sắp xếp theo bộ, phần tử thứ 2 sau đó tăng dần thứ nhất

while i > 0 and nums [i-1] >= nums[i]: i -= 10

Sắp xếp và in các giá trị chính tả theo khóa

while i > 0 and nums [i-1] >= nums[i]: i -= 11

Băm

while i > 0 and nums [i-1] >= nums[i]: i -= 12

Bố trí

while i > 0 and nums [i-1] >= nums[i]: i -= 13

while i > 0 and nums [i-1] >= nums[i]: i -= 14

Danh sách

Ngăn xếp được triển khai với Danh sách. Ngăn xếp rất tốt cho việc phân tích cú pháp và duyệt đồ thị

while i > 0 and nums [i-1] >= nums[i]: i -= 15

2D

while i > 0 and nums [i-1] >= nums[i]: i -= 16

Danh sách hiểu

while i > 0 and nums [i-1] >= nums[i]: i -= 17

Đảo ngược một danh sách

while i > 0 and nums [i-1] >= nums[i]: i -= 18

tham gia danh sách

while i > 0 and nums [i-1] >= nums[i]: i -= 19

đọc chính tả

Hashtables được thực hiện với từ điển

l, r = i, len(nums) - 1 while l < r: nums[l], nums[r] = nums[r], nums[l] l += 1 r -= 10

Tạo Dict of Lists phù hợp với độ dài của danh sách để đếm phiếu bầu

l, r = i, len(nums) - 1 while l < r: nums[l], nums[r] = nums[r], nums[l] l += 1 r -= 11

Cây

1. Cây là đồ thị vô hướng trong đó hai đỉnh bất kỳ được nối với nhau bằng đúng một đường đi

2. Bất kỳ đồ thị liên thông nào có n nút với n-1 cạnh đều là một cây

3. Bậc của một đỉnh là số cạnh liên thông với đỉnh đó

4. Lá là đỉnh bậc 1. Đỉnh trong là đỉnh có bậc ít nhất bằng 2

5. Đồ thị đường đi là một cây có từ hai đỉnh trở lên không có nhánh bậc 2 trừ các lá bậc 1

6. Hai đỉnh bất kỳ trong G có thể nối với nhau bằng một đường đi đơn duy nhất

7. G không tuần hoàn và một chu trình đơn được hình thành nếu thêm bất kỳ cạnh nào vào G

8. G liên thông và không có chu trình

9. G được kết nối nhưng sẽ bị ngắt kết nối nếu bất kỳ cạnh đơn nào bị xóa khỏi G

Cây nhị phân

DFS Truyền tải trước, theo thứ tự và sau khi đặt hàng

• Đặt hàng trước
  • gặp rễ trước lá
  • tạo bản sao
• đặt hàng
  • làm phẳng cây trở lại trình tự ban đầu
  • Nhận các giá trị theo thứ tự không giảm trong BST
• Đăng đơn hàng
  • gặp lá trước rễ
  • Hữu ích cho việc xóa

đệ quy

l, r = i, len(nums) - 1 while l < r: nums[l], nums[r] = nums[r], nums[l] l += 1 r -= 12

Đặt hàng trước lặp đi lặp lại

l, r = i, len(nums) - 1 while l < r: nums[l], nums[r] = nums[r], nums[l] l += 1 r -= 13

Thứ tự lặp đi lặp lại

l, r = i, len(nums) - 1 while l < r: nums[l], nums[r] = nums[r], nums[l] l += 1 r -= 14

Đơn đặt hàng lặp đi lặp lại

l, r = i, len(nums) - 1 while l < r: nums[l], nums[r] = nums[r], nums[l] l += 1 r -= 15

BFS lặp đi lặp lại (LevelOrder)

l, r = i, len(nums) - 1 while l < r: nums[l], nums[r] = nums[r], nums[l] l += 1 r -= 16

Duyệt qua các loại dữ liệu dưới dạng biểu đồ, ví dụ BFS

l, r = i, len(nums) - 1 while l < r: nums[l], nums[r] = nums[r], nums[l] l += 1 r -= 17

Tái tạo cây nhị phân

1. Cây nhị phân có thể được xây dựng từ đặt hàng trước và duyệt theo thứ tự
2. Truyền tải theo thứ tự của BST là một mảng được sắp xếp theo thứ tự tăng dần

Chuyển đổi cây thành mảng rồi thành cây cân bằng

l, r = i, len(nums) - 1 while l < r: nums[l], nums[r] = nums[r], nums[l] l += 1 r -= 18

đồ thị

Xây dựng đồ thị kề từ danh sách các cạnh

l, r = i, len(nums) - 1 while l < r: nums[l], nums[r] = nums[r], nums[l] l += 1 r -= 19

Xây dựng đồ thị kề từ cây truyền thống

for i in range(len(message) + 1): if i == len(message) or message[i] == ' ':0

Traverse Tree trong ký hiệu đồ thị

for i in range(len(message) + 1): if i == len(message) or message[i] == ' ':1

heapq

for i in range(len(message) + 1): if i == len(message) or message[i] == ' ':2

1. Được triển khai dưới dạng cây nhị phân hoàn chỉnh, có tất cả các mức đầy đủ trừ mức sâu nhất
2. Trong cây heap, nút nhỏ hơn nút con của nó

for i in range(len(message) + 1): if i == len(message) or message[i] == ' ':3

Các phần tử của heap có thể là các bộ, heappop() giải phóng phần tử nhỏ nhất (dấu lật thành pop lớn nhất)

for i in range(len(message) + 1): if i == len(message) or message[i] == ' ':4

nsmallest có thể lấy một đối số lambda

for i in range(len(message) + 1): if i == len(message) or message[i] == ' ':5

Khóa cũng có thể là một chức năng trong nsmallest/nlarget

for i in range(len(message) + 1): if i == len(message) or message[i] == ' ':6

Sắp xếp bộ, phần tử thứ 1/thứ 2. tần suất tăng dần rồi giảm dần

for i in range(len(message) + 1): if i == len(message) or message[i] == ' ':7

Lambda

Có thể được sử dụng với (danh sách). sắp xếp(), sắp xếp(), tối thiểu(), tối đa(), (heapq). nlớn nhất, nnhỏ nhất(), bản đồ()

for i in range(len(message) + 1): if i == len(message) or message[i] == ' ':8

for i in range(len(message) + 1): if i == len(message) or message[i] == ' ':9

for a in range(0,3): # 0,1,2 for a in reversed(range(0,3)) # 2,1,0 for i in range(3,-1,-1) # 3,2,1,0 for i in range(len(A)//2): # A = [0,1,2,3,4,5] print(i) # 0,1,2 print(A[i]) # 0,1,2 print(~i) # -1,-2,-3 print(A[~i]) # 5,4,30

Lambda có thể sắp xếp theo phần tử thứ 1, thứ 2 trong bộ dữ liệu

for a in range(0,3): # 0,1,2 for a in reversed(range(0,3)) # 2,1,0 for i in range(3,-1,-1) # 3,2,1,0 for i in range(len(A)//2): # A = [0,1,2,3,4,5] print(i) # 0,1,2 print(A[i]) # 0,1,2 print(~i) # -1,-2,-3 print(A[~i]) # 5,4,31

khóa kéo

Kết hợp hai lệnh hoặc danh sách

for a in range(0,3): # 0,1,2 for a in reversed(range(0,3)) # 2,1,0 for i in range(3,-1,-1) # 3,2,1,0 for i in range(len(A)//2): # A = [0,1,2,3,4,5] print(i) # 0,1,2 print(A[i]) # 0,1,2 print(~i) # -1,-2,-3 print(A[~i]) # 5,4,32

Đi ngang song song

for a in range(0,3): # 0,1,2 for a in reversed(range(0,3)) # 2,1,0 for i in range(3,-1,-1) # 3,2,1,0 for i in range(len(A)//2): # A = [0,1,2,3,4,5] print(i) # 0,1,2 print(A[i]) # 0,1,2 print(~i) # -1,-2,-3 print(A[~i]) # 5,4,33

Rỗng trong một danh sách bị bỏ qua

for a in range(0,3): # 0,1,2 for a in reversed(range(0,3)) # 2,1,0 for i in range(3,-1,-1) # 3,2,1,0 for i in range(len(A)//2): # A = [0,1,2,3,4,5] print(i) # 0,1,2 print(A[i]) # 0,1,2 print(~i) # -1,-2,-3 print(A[~i]) # 5,4,34

So sánh các ký tự của các từ xen kẽ

for a in range(0,3): # 0,1,2 for a in reversed(range(0,3)) # 2,1,0 for i in range(3,-1,-1) # 3,2,1,0 for i in range(len(A)//2): # A = [0,1,2,3,4,5] print(i) # 0,1,2 print(A[i]) # 0,1,2 print(~i) # -1,-2,-3 print(A[~i]) # 5,4,35

Truyền vào * giải nén một danh sách hoặc danh sách có thể lặp lại khác, làm cho mỗi phần tử của nó trở thành một đối số riêng biệt

for a in range(0,3): # 0,1,2 for a in reversed(range(0,3)) # 2,1,0 for i in range(3,-1,-1) # 3,2,1,0 for i in range(len(A)//2): # A = [0,1,2,3,4,5] print(i) # 0,1,2 print(A[i]) # 0,1,2 print(~i) # -1,-2,-3 print(A[~i]) # 5,4,36

Hữu ích khi quay một ma trận

for a in range(0,3): # 0,1,2 for a in reversed(range(0,3)) # 2,1,0 for i in range(3,-1,-1) # 3,2,1,0 for i in range(len(A)//2): # A = [0,1,2,3,4,5] print(i) # 0,1,2 print(A[i]) # 0,1,2 print(~i) # -1,-2,-3 print(A[~i]) # 5,4,37

Lặp lại qua các ký tự trong danh sách strs

for a in range(0,3): # 0,1,2 for a in reversed(range(0,3)) # 2,1,0 for i in range(3,-1,-1) # 3,2,1,0 for i in range(len(A)//2): # A = [0,1,2,3,4,5] print(i) # 0,1,2 print(A[i]) # 0,1,2 print(~i) # -1,-2,-3 print(A[~i]) # 5,4,38

Các đường chéo có thể được duyệt qua với sự trợ giúp của một danh sách

for a in range(0,3): # 0,1,2 for a in reversed(range(0,3)) # 2,1,0 for i in range(3,-1,-1) # 3,2,1,0 for i in range(len(A)//2): # A = [0,1,2,3,4,5] print(i) # 0,1,2 print(A[i]) # 0,1,2 print(~i) # -1,-2,-3 print(A[~i]) # 5,4,39

Ngẫu nhiên

str1.find('x') # find first location of char x and return index str1.rfind('x') # find first int location of char x from reverse0

Trình tạo ngẫu nhiên khác

str1.find('x') # find first location of char x and return index str1.rfind('x') # find first int location of char x from reverse1

hằng số

str1.find('x') # find first location of char x and return index str1.rfind('x') # find first int location of char x from reverse2

bậc ba

a nếu điều kiện khác b

str1.find('x') # find first location of char x and return index str1.rfind('x') # find first int location of char x from reverse3

toán tử Bitwise

str1.find('x') # find first location of char x and return index str1.rfind('x') # find first int location of char x from reverse4

Đối với khác

Điều kiện khác bật vòng lặp for nếu break không được gọi

str1.find('x') # find first location of char x and return index str1.rfind('x') # find first int location of char x from reverse5

mô-đun

str1.find('x') # find first location of char x and return index str1.rfind('x') # find first int location of char x from reverse6

Bất kỳ

nếu bất kỳ phần tử nào của iterable là True

str1.find('x') # find first location of char x and return index str1.rfind('x') # find first int location of char x from reverse7

Tất cả các

str1.find('x') # find first location of char x and return index str1.rfind('x') # find first int location of char x from reverse8

chia đôi

• chia đôi. bisect_left trả về vị trí ngoài cùng bên trái trong danh sách đã sắp xếp để chèn phần tử đã cho
• chia đôi. bisect_right trả về vị trí ngoài cùng bên phải trong danh sách được sắp xếp để chèn phần tử đã cho

str1.find('x') # find first location of char x and return index str1.rfind('x') # find first int location of char x from reverse9

Chèn x vào một thứ tự được sắp xếp. Điều này tương đương với một. chèn (chia đôi. bisect_left(a, x, lo, hi), x) giả sử rằng a đã được sắp xếp. Tìm kiếm là tìm kiếm nhị phân O(logn) và chèn là O(n)

l = "0:start:0" tokens = l.split(":") print(tokens) # ['0', 'start', '0']0

l = "0:start:0" tokens = l.split(":") print(tokens) # ['0', 'start', '0']1

Bisect có thể cung cấp hai đầu của một phạm vi, nếu mảng được sắp xếp tất nhiên

l = "0:start:0" tokens = l.split(":") print(tokens) # ['0', 'start', '0']2

Toán học

tính công suất

l = "0:start:0" tokens = l.split(":") print(tokens) # ['0', 'start', '0']3

Chia có dư

l = "0:start:0" tokens = l.split(":") print(tokens) # ['0', 'start', '0']4

đánh giá

Đánh giá một biểu thức

l = "0:start:0" tokens = l.split(":") print(tokens) # ['0', 'start', '0']5

lặp đi lặp lại

Tạo trình vòng lặp từ đối tượng vùng chứa như danh sách, bộ dữ liệu, từ điển và bộ

l = "0:start:0" tokens = l.split(":") print(tokens) # ['0', 'start', '0']6

Bản đồ

bản đồ (func, * iterables)

l = "0:start:0" tokens = l.split(":") print(tokens) # ['0', 'start', '0']7

l = "0:start:0" tokens = l.split(":") print(tokens) # ['0', 'start', '0']8

Lọc

bộ lọc (func, có thể lặp lại)

l = "0:start:0" tokens = l.split(":") print(tokens) # ['0', 'start', '0']9

# s = "the sky is blue" def reverseWords(self, s: str) -> str: wordsWithoutWhitespace = s.split() # ['the', 'sky', 'is', 'blue'] reversedWords = wordsWithoutWhitespace[::-1] # ['blue', 'is', 'sky', 'the'] final = " ".join(reversedWords) # blue is sky the0

# s = "the sky is blue" def reverseWords(self, s: str) -> str: wordsWithoutWhitespace = s.split() # ['the', 'sky', 'is', 'blue'] reversedWords = wordsWithoutWhitespace[::-1] # ['blue', 'is', 'sky', 'the'] final = " ".join(reversedWords) # blue is sky the1

Nhận độ == 0 từ danh sách

# s = "the sky is blue" def reverseWords(self, s: str) -> str: wordsWithoutWhitespace = s.split() # ['the', 'sky', 'is', 'blue'] reversedWords = wordsWithoutWhitespace[::-1] # ['blue', 'is', 'sky', 'the'] final = " ".join(reversedWords) # blue is sky the2

Giảm

giảm (func, iterable [, ban đầu]) trong đó ban đầu là tùy chọn

# s = "the sky is blue" def reverseWords(self, s: str) -> str: wordsWithoutWhitespace = s.split() # ['the', 'sky', 'is', 'blue'] reversedWords = wordsWithoutWhitespace[::-1] # ['blue', 'is', 'sky', 'the'] final = " ".join(reversedWords) # blue is sky the3

itertools

itertools. tích lũy (lặp lại [, func]) -> đối tượng tích lũy

# s = "the sky is blue" def reverseWords(self, s: str) -> str: wordsWithoutWhitespace = s.split() # ['the', 'sky', 'is', 'blue'] reversedWords = wordsWithoutWhitespace[::-1] # ['blue', 'is', 'sky', 'the'] final = " ".join(reversedWords) # blue is sky the4

Biểu hiện thông thường

Mô-đun RE cho phép các biểu thức chính quy trong python

# s = "the sky is blue" def reverseWords(self, s: str) -> str: wordsWithoutWhitespace = s.split() # ['the', 'sky', 'is', 'blue'] reversedWords = wordsWithoutWhitespace[::-1] # ['blue', 'is', 'sky', 'the'] final = " ".join(reversedWords) # blue is sky the5

các loại

từ việc nhập danh sách nhập, Đặt, Dict, Tuple, Bảng cheat tùy chọn

lưới

Chức năng hữu ích hữu ích

# s = "the sky is blue" def reverseWords(self, s: str) -> str: wordsWithoutWhitespace = s.split() # ['the', 'sky', 'is', 'blue'] reversedWords = wordsWithoutWhitespace[::-1] # ['blue', 'is', 'sky', 'the'] final = " ".join(reversedWords) # blue is sky the6

Ngăn xếp với appendleft() và popleft()

Deque

# s = "the sky is blue" def reverseWords(self, s: str) -> str: wordsWithoutWhitespace = s.split() # ['the', 'sky', 'is', 'blue'] reversedWords = wordsWithoutWhitespace[::-1] # ['blue', 'is', 'sky', 'the'] final = " ".join(reversedWords) # blue is sky the7

Phản đối

# s = "the sky is blue" def reverseWords(self, s: str) -> str: wordsWithoutWhitespace = s.split() # ['the', 'sky', 'is', 'blue'] reversedWords = wordsWithoutWhitespace[::-1] # ['blue', 'is', 'sky', 'the'] final = " ".join(reversedWords) # blue is sky the8

Nhận bộ đếm k phổ biến nhất trong danh sách các bộ dữ liệu

# s = "the sky is blue" def reverseWords(self, s: str) -> str: wordsWithoutWhitespace = s.split() # ['the', 'sky', 'is', 'blue'] reversedWords = wordsWithoutWhitespace[::-1] # ['blue', 'is', 'sky', 'the'] final = " ".join(reversedWords) # blue is sky the9

các phần tử () cho phép bạn duyệt qua từng số trong Bộ đếm

i = 0 while i < len(str): i += 100

toán tử làm việc trên Counter

i = 0 while i < len(str): i += 101

Dict mặc định

i = 0 while i < len(str): i += 102

i = 0 while i < len(str): i += 103

Mẹo chung

• Nhận tất cả thông tin
• Ví dụ gỡ lỗi, đây có phải là trường hợp đặc biệt không?
• Lực lượng vũ phu
  • Nhận giải pháp vũ phu càng sớm càng tốt. Nhà nước runtime rồi tối ưu, chưa code
• Tối ưu hóa
  • Tìm kiếm thông tin không sử dụng
  • Ví dụ, giải quyết nó theo cách thủ công, sau đó đảo ngược quá trình suy nghĩ của kỹ sư
  • Không gian so với thời gian, băm
  • BUDS (Tắc nghẽn cổ chai, Công việc không cần thiết, Sao chép)
• Đi bộ qua cách tiếp cận
• Mã số
• Bài kiểm tra
  • Khởi đầu nhỏ
  • Lượt các trường hợp cạnh

Tìm kiếm nhị phân

i = 0 while i < len(str): i += 104

i = 0 while i < len(str): i += 105

Tìm kiếm nhị phân

Cây tìm kiếm nhị phân

Sử dụng các giá trị để phát hiện nếu số bị thiếu

i = 0 while i < len(str): i += 106

Nhận tổng phạm vi giá trị

i = 0 while i < len(str): i += 107

Kiểm tra nếu hợp lệ

i = 0 while i < len(str): i += 108

Sắp xếp tô pô

Thuật toán của Kahn, phát hiện các chu kỳ thông qua độ và cần tất cả các nút được biểu diễn để hoạt động

1. Khởi tạo các đỉnh là chưa được thăm
2. Chọn đỉnh có bậc bằng 0, nối vào kết quả, giảm bậc của các lân cận
3. Bây giờ lặp lại cho hàng xóm, danh sách kết quả được sắp xếp theo nguồn -> đích

Nếu chu kỳ thì bậc của các nút trong chu kỳ sẽ không bằng 0 vì không có gốc tọa độ

i = 0 while i < len(str): i += 109

i = 0 while i < len(str): i += 110

cửa sổ trượt

1. Có một bộ đếm hoặc bản đồ băm để đếm đầu vào mảng cụ thể và tiếp tục tăng cửa sổ về phía bên phải bằng cách sử dụng vòng lặp bên ngoài
2. Có một vòng lặp bên trong để giảm cạnh cửa sổ bằng cách trượt về phía bên phải. Chuyển động sẽ dựa trên các ràng buộc của bài toán
3. Lưu trữ kích thước cửa sổ tối đa hiện tại hoặc kích thước cửa sổ tối thiểu hoặc số lượng cửa sổ dựa trên yêu cầu của bài toán

Đầu mối vấn đề điển hình

1. Nhận tối thiểu/tối đa/số mảng con hài lòng
2. Trả về độ dài của mảng con với tổng/tích tối đa
3. Trả về độ dài tối đa/tối thiểu/số mảng con có tổng/tích bằng K

Có thể yêu cầu 2 hoặc 3 con trỏ để giải quyết

i = 0 while i < len(str): i += 111

i = 0 while i < len(str): i += 112

Tham

Đưa ra lựa chọn tối ưu ở mỗi bước

Tăng dãy con bộ ba, đúng nếu i < j < k

i = 0 while i < len(str): i += 113

thủ thuật cây

Giải pháp từ dưới lên với các đối số cho tối thiểu, tối đa

i = 0 while i < len(str): i += 114

Xây dựng một con đường xuyên qua một cái cây

i = 0 while i < len(str): i += 115

Sử dụng giá trị trả về để tính tổng

i = 0 while i < len(str): i += 116

Thay đổi Cây thành Đồ thị

i = 0 while i < len(str): i += 117

phép đảo ngữ

Phần phụ của cửa sổ trượt, giải quyết bằng Counter Dict

i. e. abc = bca. = eba 111 111 111

i = 0 while i < len(str): i += 118

Phiên bản Cửa sổ trượt (chuỗi con)

i = 0 while i < len(str): i += 119

Lập trình năng động

1. lập trình năng động

i = 0 while i < len(str): i += 120

Lưới DP cổ điển, dãy con chung dài nhất

i = 0 while i < len(str): i += 121

Sắp xếp theo chu kỳ

1. Thuật toán hữu ích khi sắp xếp tại chỗ

i = 0 while i < len(str): i += 122

Sắp xếp nhanh chóng

1. Có thể được sửa đổi để phân chia trong các vấn đề chinh phục

i = 0 while i < len(str): i += 123

Hợp nhất Sắp xếp

i = 0 while i < len(str): i += 124

Hợp nhất mảng

Hợp nhất K mảng được sắp xếp với một đống

i = 0 while i < len(str): i += 125

Hoặc thủ công với heappush/heappop

i = 0 while i < len(str): i += 126

Hợp nhất K danh sách được sắp xếp

i = 0 while i < len(str): i += 127

Danh sách liên kết

1. Các giải pháp thường yêu cầu 3 con trỏ. hiện tại, trước đó và tiếp theo
2. Các giải pháp thường được thực hiện đơn giản hơn với nút đầu giả hoặc đầu giả mà bạn tạo và sau đó thêm vào. Sau đó trả lại giả. tiếp theo

Đảo ngược

i = 0 while i < len(str): i += 128

Việc đảo ngược sẽ dễ dàng hơn nếu bạn có thể sửa đổi các giá trị của danh sách

i = 0 while i < len(str): i += 129

hợp nhất

i = 0 while i < len(str): i += 130

chuyển đổi cơ sở

1. Thông thường hai bước. Một bước modulo chữ số và một bước chia số nguyên cho cơ sở tiếp theo sau đó đảo ngược kết quả hoặc sử dụng deque()

Cơ sở 10 thành 16 hoặc bất kỳ cơ sở nào bằng cách thay đổi '16' và chỉ mục

i = 0 while i < len(str): i += 131

dấu ngoặc đơn

1. Đếm có thể được sử dụng nếu trường hợp đơn giản, nếu không thì xếp chồng. là một phần mở rộng của thuật toán này

i = 0 while i < len(str): i += 132

Có thể dùng stack nếu phức tạp hơn

i = 0 while i < len(str): i += 133

Hoặc phải lưu trữ chỉ số ngoặc đơn để sửa đổi thêm

i = 0 while i < len(str): i += 134

Cổ phiếu lợi nhuận tối đa

Giao dịch vô hạn, công thức cơ sở

i = 0 while i < len(str): i += 135

Giao dịch đơn lẻ, t0 (k-1) = 0

i = 0 while i < len(str): i += 136

Giao dịch K

i = 0 while i < len(str): i += 137

Dịch chuyển mảng sang phải

Mảng có thể được dịch chuyển sang phải bằng cách đảo ngược toàn bộ chuỗi, sau đó đảo ngược 0,k-1 và k,len(str)

i = 0 while i < len(str): i += 138

Các mảng con liên tục với tổng k

Có thể tìm thấy tổng số mảng con liên tục có tổng k bằng cách băm tổng liên tục trên mỗi giá trị và thêm số lượng tổng liên tục - k

i = 0 while i < len(str): i += 139

Sự kiện

Mẫu sự kiện có thể được áp dụng khi giải quyết nhiều vấn đề về khoảng thời gian, chẳng hạn như 'Tìm thời gian rảnh của nhân viên giữa các cuộc họp' và 'tìm dân số cao nhất' khi thời gian bắt đầu/kết thúc của từng cá nhân không liên quan và tổng thời gian bắt đầu/kết thúc quan trọng hơn

i = 0 while i < len(str): i += 140

Hợp nhất các cuộc họp

Hợp nhất một cuộc họp mới vào một danh sách

i = 0 while i < len(str): i += 141

Trie

Tốt cho tự động điền, kiểm tra chính tả, định tuyến IP (khớp tiền tố dài nhất), văn bản tiên đoán, giải trò chơi chữ

i = 0 while i < len(str): i += 142

Ví dụ tìm kiếm với. cho ký tự đại diện

i = 0 while i < len(str): i += 143

Kadane

local_maxiumum[i] = max(A[i], A[i] + local_maximum[i-1]) Giải thích Xác định tổng tối đa của mảng con

i = 0 while i < len(str): i += 144

Đoàn Tìm

Union Find là một thuật toán hữu ích cho đồ thị

DSU cho số nguyên

i = 0 while i < len(str): i += 145

DSU cho chuỗi

i = 0 while i < len(str): i += 146

DSU với liên minh theo cấp bậc

i = 0 while i < len(str): i += 147

điện nhanh

Công suất nhanh hoặc Hàm mũ bằng cách bình phương cho phép tính bình phương trong thời gian đăng nhập (x^n)2 = x^(2n)

i = 0 while i < len(str): i += 148

Fibonacci vàng

Fibonacci có thể được tính bằng Tỷ lệ vàng

i = 0 while i < len(str): i += 149

Máy tính cơ bản

Một máy tính có thể được mô phỏng với ngăn xếp

i = 0 while i < len(str): i += 150

đánh bóng ngược

i = 0 while i < len(str): i += 151

lấy mẫu hồ chứa

Được sử dụng để lấy mẫu các quần thể lớn chưa biết. Mỗi mục mới được thêm vào có 1/số cơ hội được chọn

i = 0 while i < len(str): i += 152

chuỗi con

Có thể tìm thấy số lượng chuỗi con tối thiểu trong một số nguồn thông qua tìm kiếm nhị phân và một lệnh của các chỉ mục của mảng nguồn