💡 Định nghĩa. Một palindrome là một dãy các ký tự đọc ngược cũng như đọc xuôi chẳng hạn như 'madam', 'anna' hoặc
def find_palindromes[s]:
palindromes = []
n = len[s]
for i in range[n]:
for j in range[i+1,n+1]:
word = s[i:j]
if word == word[::-1]:
palindromes.append[word]
return palindromes
print[find_palindromes['locoannamadam']]
# ['l', 'o', 'oco', 'c', 'o', 'a', 'anna',
# 'n', 'nn', 'n', 'a', 'ama', 'm', 'madam',
# 'a', 'ada', 'd', 'a', 'm']
print[find_palindromes['anna']]
# ['a', 'anna', 'n', 'nn', 'n', 'a']
print[find_palindromes['abc']]
# ['a', 'b', 'c']0Bài viết này muốn cung cấp cho bạn một giải pháp nhanh chóng và dễ dàng trong Python. Đầu tiên, chúng ta sẽ giải bài toán dễ hơn nhưng quan trọng là kiểm tra xem một chuỗi con có phải là một palindrome hay không ngay từ đầu
Kiểm tra xem chuỗi con có phải là Palindrome không
Bạn có thể dễ dàng kiểm tra xem một chuỗi con có phải là một bảng màu hay không bằng cách sử dụng biểu thức cắt lớp
def find_palindromes[s]:
palindromes = []
n = len[s]
for i in range[n]:
for j in range[i+1,n+1]:
word = s[i:j]
if word == word[::-1]:
palindromes.append[word]
return palindromes
print[find_palindromes['locoannamadam']]
# ['l', 'o', 'oco', 'c', 'o', 'a', 'anna',
# 'n', 'nn', 'n', 'a', 'ama', 'm', 'madam',
# 'a', 'ada', 'd', 'a', 'm']
print[find_palindromes['anna']]
# ['a', 'anna', 'n', 'nn', 'n', 'a']
print[find_palindromes['abc']]
# ['a', 'b', 'c']1 ước tính thành def find_palindromes[s]:
palindromes = []
n = len[s]
for i in range[n]:
for j in range[i+1,n+1]:
word = s[i:j]
if word == word[::-1]:
palindromes.append[word]
return palindromes
print[find_palindromes['locoannamadam']]
# ['l', 'o', 'oco', 'c', 'o', 'a', 'anna',
# 'n', 'nn', 'n', 'a', 'ama', 'm', 'madam',
# 'a', 'ada', 'd', 'a', 'm']
print[find_palindromes['anna']]
# ['a', 'anna', 'n', 'nn', 'n', 'a']
print[find_palindromes['abc']]
# ['a', 'b', 'c']2 nếu từ tiến và lùi giống nhau, i. e. , nó là một đối xứng👉 Hướng dẫn đề xuất. Python Palindromes một lớp lót
Tiếp theo, chúng ta sẽ khám phá cách tìm chuỗi con dài nhất trong chuỗi Python cũng là Palindrome. Bạn có thể tìm thấy trình kiểm tra palindrome của chúng tôi trong giải pháp mã [được đánh dấu]
Tìm chuỗi con dài nhất đó là Palindrome
Cách tiếp cận brute-force để tìm palindrome dài nhất trong một chuỗi là lặp qua tất cả các chuỗi con trong một vòng lặp
def find_palindromes[s]:
palindromes = []
n = len[s]
for i in range[n]:
for j in range[i+1,n+1]:
word = s[i:j]
if word == word[::-1]:
palindromes.append[word]
return palindromes
print[find_palindromes['locoannamadam']]
# ['l', 'o', 'oco', 'c', 'o', 'a', 'anna',
# 'n', 'nn', 'n', 'a', 'ama', 'm', 'madam',
# 'a', 'ada', 'd', 'a', 'm']
print[find_palindromes['anna']]
# ['a', 'anna', 'n', 'nn', 'n', 'a']
print[find_palindromes['abc']]
# ['a', 'b', 'c']3 lồng nhau. Sau đó kiểm tra từng chuỗi con xem nó có phải là một palindrom hay không bằng cách sử dụng def find_palindromes[s]:
palindromes = []
n = len[s]
for i in range[n]:
for j in range[i+1,n+1]:
word = s[i:j]
if word == word[::-1]:
palindromes.append[word]
return palindromes
print[find_palindromes['locoannamadam']]
# ['l', 'o', 'oco', 'c', 'o', 'a', 'anna',
# 'n', 'nn', 'n', 'a', 'ama', 'm', 'madam',
# 'a', 'ada', 'd', 'a', 'm']
print[find_palindromes['anna']]
# ['a', 'anna', 'n', 'nn', 'n', 'a']
print[find_palindromes['abc']]
# ['a', 'b', 'c']1. Theo dõi bảng màu dài nhất bằng cách sử dụng hàm def find_palindromes[s]:
palindromes = []
n = len[s]
for i in range[n]:
for j in range[i+1,n+1]:
word = s[i:j]
if word == word[::-1]:
palindromes.append[word]
return palindromes
print[find_palindromes['locoannamadam']]
# ['l', 'o', 'oco', 'c', 'o', 'a', 'anna',
# 'n', 'nn', 'n', 'a', 'ama', 'm', 'madam',
# 'a', 'ada', 'd', 'a', 'm']
print[find_palindromes['anna']]
# ['a', 'anna', 'n', 'nn', 'n', 'a']
print[find_palindromes['abc']]
# ['a', 'b', 'c']50 trong điều kiện def find_palindromes[s]:
palindromes = []
n = len[s]
for i in range[n]:
for j in range[i+1,n+1]:
word = s[i:j]
if word == word[::-1]:
palindromes.append[word]
return palindromes
print[find_palindromes['locoannamadam']]
# ['l', 'o', 'oco', 'c', 'o', 'a', 'anna',
# 'n', 'nn', 'n', 'a', 'ama', 'm', 'madam',
# 'a', 'ada', 'd', 'a', 'm']
print[find_palindromes['anna']]
# ['a', 'anna', 'n', 'nn', 'n', 'a']
print[find_palindromes['abc']]
# ['a', 'b', 'c']51Đây là giải pháp đầy đủ
def find_longest_palindrome[s]:
longest = ''
n = len[s]
for i in range[n]:
for j in range[i+1,n+1]:
word = s[i:j]
if word == word[::-1]:
if len[word]>len[longest]:
longest = word
return longest
print[find_longest_palindrome['locoannamadam']]
# madam
print[find_longest_palindrome['anna']]
# anna
print[find_longest_palindrome['abc']]
# a
Độ phức tạp của thời gian chạy
Điều này có độ phức tạp thời gian chạy khối, tôi. e. , đối với một chuỗi có độ dài
def find_palindromes[s]:
palindromes = []
n = len[s]
for i in range[n]:
for j in range[i+1,n+1]:
word = s[i:j]
if word == word[::-1]:
palindromes.append[word]
return palindromes
print[find_palindromes['locoannamadam']]
# ['l', 'o', 'oco', 'c', 'o', 'a', 'anna',
# 'n', 'nn', 'n', 'a', 'ama', 'm', 'madam',
# 'a', 'ada', 'd', 'a', 'm']
print[find_palindromes['anna']]
# ['a', 'anna', 'n', 'nn', 'n', 'a']
print[find_palindromes['abc']]
# ['a', 'b', 'c']52, chúng ta cần kiểm tra các từ khác nhau của def find_palindromes[s]:
palindromes = []
n = len[s]
for i in range[n]:
for j in range[i+1,n+1]:
word = s[i:j]
if word == word[::-1]:
palindromes.append[word]
return palindromes
print[find_palindromes['locoannamadam']]
# ['l', 'o', 'oco', 'c', 'o', 'a', 'anna',
# 'n', 'nn', 'n', 'a', 'ama', 'm', 'madam',
# 'a', 'ada', 'd', 'a', 'm']
print[find_palindromes['anna']]
# ['a', 'anna', 'n', 'nn', 'n', 'a']
print[find_palindromes['abc']]
# ['a', 'b', 'c']53. Mỗi từ có thể có tối đa def find_palindromes[s]:
palindromes = []
n = len[s]
for i in range[n]:
for j in range[i+1,n+1]:
word = s[i:j]
if word == word[::-1]:
palindromes.append[word]
return palindromes
print[find_palindromes['locoannamadam']]
# ['l', 'o', 'oco', 'c', 'o', 'a', 'anna',
# 'n', 'nn', 'n', 'a', 'ama', 'm', 'madam',
# 'a', 'ada', 'd', 'a', 'm']
print[find_palindromes['anna']]
# ['a', 'anna', 'n', 'nn', 'n', 'a']
print[find_palindromes['abc']]
# ['a', 'b', 'c']52 ký tự, do đó bản thân kiểm tra palindrome là def find_palindromes[s]:
palindromes = []
n = len[s]
for i in range[n]:
for j in range[i+1,n+1]:
word = s[i:j]
if word == word[::-1]:
palindromes.append[word]
return palindromes
print[find_palindromes['locoannamadam']]
# ['l', 'o', 'oco', 'c', 'o', 'a', 'anna',
# 'n', 'nn', 'n', 'a', 'ama', 'm', 'madam',
# 'a', 'ada', 'd', 'a', 'm']
print[find_palindromes['anna']]
# ['a', 'anna', 'n', 'nn', 'n', 'a']
print[find_palindromes['abc']]
# ['a', 'b', 'c']55. Cùng với nhau, điều này mang lại độ phức tạp thời gian chạy của def find_palindromes[s]:
palindromes = []
n = len[s]
for i in range[n]:
for j in range[i+1,n+1]:
word = s[i:j]
if word == word[::-1]:
palindromes.append[word]
return palindromes
print[find_palindromes['locoannamadam']]
# ['l', 'o', 'oco', 'c', 'o', 'a', 'anna',
# 'n', 'nn', 'n', 'a', 'ama', 'm', 'madam',
# 'a', 'ada', 'd', 'a', 'm']
print[find_palindromes['anna']]
# ['a', 'anna', 'n', 'nn', 'n', 'a']
print[find_palindromes['abc']]
# ['a', 'b', 'c']56Thảo luận và giải pháp tốt hơn
đây là điều tốt nhất mà chúng ta có thể làm sao?
Không. Điều tốt nhất chúng ta có thể làm về mặt lý thuyết là độ phức tạp thời gian chạy tuyến tính và độ phức tạp không gian tuyến tính được gọi là. Ý tưởng là chọn nhiều “trung tâm đối xứng” và phát triển từng bước một các trung tâm này bằng cách thêm các ký tự vào bên trái hoặc bên phải
Tuy nhiên, bạn không nên tự nghĩ ra điều này trong một cuộc phỏng vấn viết mã
Ý tưởng lập trình bậc hai
Điều mà một số người phỏng vấn có thể mong đợi là đưa ra ý tưởng “lập trình động” trong đó bạn xây dựng ma trận Boolean
Cấu trúc dữ liệu. Mỗi ô
def find_palindromes[s]:
palindromes = []
n = len[s]
for i in range[n]:
for j in range[i+1,n+1]:
word = s[i:j]
if word == word[::-1]:
palindromes.append[word]
return palindromes
print[find_palindromes['locoannamadam']]
# ['l', 'o', 'oco', 'c', 'o', 'a', 'anna',
# 'n', 'nn', 'n', 'a', 'ama', 'm', 'madam',
# 'a', 'ada', 'd', 'a', 'm']
print[find_palindromes['anna']]
# ['a', 'anna', 'n', 'nn', 'n', 'a']
print[find_palindromes['abc']]
# ['a', 'b', 'c']57 của Ma trận Boolean là def find_palindromes[s]:
palindromes = []
n = len[s]
for i in range[n]:
for j in range[i+1,n+1]:
word = s[i:j]
if word == word[::-1]:
palindromes.append[word]
return palindromes
print[find_palindromes['locoannamadam']]
# ['l', 'o', 'oco', 'c', 'o', 'a', 'anna',
# 'n', 'nn', 'n', 'a', 'ama', 'm', 'madam',
# 'a', 'ada', 'd', 'a', 'm']
print[find_palindromes['anna']]
# ['a', 'anna', 'n', 'nn', 'n', 'a']
print[find_palindromes['abc']]
# ['a', 'b', 'c']2 nếu chuỗi def find_palindromes[s]:
palindromes = []
n = len[s]
for i in range[n]:
for j in range[i+1,n+1]:
word = s[i:j]
if word == word[::-1]:
palindromes.append[word]
return palindromes
print[find_palindromes['locoannamadam']]
# ['l', 'o', 'oco', 'c', 'o', 'a', 'anna',
# 'n', 'nn', 'n', 'a', 'ama', 'm', 'madam',
# 'a', 'ada', 'd', 'a', 'm']
print[find_palindromes['anna']]
# ['a', 'anna', 'n', 'nn', 'n', 'a']
print[find_palindromes['abc']]
# ['a', 'b', 'c']59 là Palindrome và ngược lại là 'madam'0. Ô là def find_palindromes[s]:
palindromes = []
n = len[s]
for i in range[n]:
for j in range[i+1,n+1]:
word = s[i:j]
if word == word[::-1]:
palindromes.append[word]
return palindromes
print[find_palindromes['locoannamadam']]
# ['l', 'o', 'oco', 'c', 'o', 'a', 'anna',
# 'n', 'nn', 'n', 'a', 'ama', 'm', 'madam',
# 'a', 'ada', 'd', 'a', 'm']
print[find_palindromes['anna']]
# ['a', 'anna', 'n', 'nn', 'n', 'a']
print[find_palindromes['abc']]
# ['a', 'b', 'c']2 và có giá trị cao nhất cho 'madam'2 đại diện cho Palindrome dài nhấtthuật toán. Điền vào cấu trúc dữ liệu với các giá trị Boolean. Bạn có thể tạo một ô
def find_palindromes[s]:
palindromes = []
n = len[s]
for i in range[n]:
for j in range[i+1,n+1]:
word = s[i:j]
if word == word[::-1]:
palindromes.append[word]
return palindromes
print[find_palindromes['locoannamadam']]
# ['l', 'o', 'oco', 'c', 'o', 'a', 'anna',
# 'n', 'nn', 'n', 'a', 'ama', 'm', 'madam',
# 'a', 'ada', 'd', 'a', 'm']
print[find_palindromes['anna']]
# ['a', 'anna', 'n', 'nn', 'n', 'a']
print[find_palindromes['abc']]
# ['a', 'b', 'c']57 từ các ô nhỏ hơn một cách dễ dàng bằng cách kiểm tra xem chuỗi con nhỏ hơn 'madam'4 có phải là Palindrome hay không và các ký tự đầu tiên và cuối cùng của 'madam'5 và 'madam'6 có giống nhau không. Đặt ô thành 'madam'0 hoặc def find_palindromes[s]:
palindromes = []
n = len[s]
for i in range[n]:
for j in range[i+1,n+1]:
word = s[i:j]
if word == word[::-1]:
palindromes.append[word]
return palindromes
print[find_palindromes['locoannamadam']]
# ['l', 'o', 'oco', 'c', 'o', 'a', 'anna',
# 'n', 'nn', 'n', 'a', 'ama', 'm', 'madam',
# 'a', 'ada', 'd', 'a', 'm']
print[find_palindromes['anna']]
# ['a', 'anna', 'n', 'nn', 'n', 'a']
print[find_palindromes['abc']]
# ['a', 'b', 'c']2 tương ứng. Khởi tạo cấu trúc dữ liệu với các giá trị đường chéo 'madam'9Lưu ý rằng chúng tôi KHÔNG sử dụng lập chỉ mục Python trong mô tả này, tôi. e. , chỉ mục kết thúc của một lát cắt được bao gồm
Dưới đây là tổng quan nhanh về ý tưởng này
🧩 Tập thể dục. Triển khai ý tưởng này bằng mã Python và gửi cho tôi
Chris
Trong khi làm việc với tư cách là một nhà nghiên cứu trong các hệ thống phân tán, Dr. Christian Mayer tìm thấy tình yêu của mình với việc dạy sinh viên khoa học máy tính
Để giúp sinh viên đạt được mức độ thành công Python cao hơn, anh ấy đã thành lập trang web giáo dục lập trình Finxter. com. Ông là tác giả của cuốn sách lập trình nổi tiếng Python One-Liners [NoStarch 2020], đồng tác giả của loạt sách tự xuất bản Coffee Break Python, người đam mê khoa học máy tính, cộng tác viên tự do và chủ sở hữu của một trong 10 blog Python lớn nhất thế giới
Niềm đam mê của anh ấy là viết, đọc và mã hóa. Nhưng niềm đam mê lớn nhất của anh ấy là phục vụ các lập trình viên đầy tham vọng thông qua Finxter và giúp họ nâng cao kỹ năng của mình. Bạn có thể tham gia học viện email miễn phí của anh ấy tại đây
💡 Định nghĩa. Một palindrome là một dãy các ký tự đọc ngược cũng như đọc xuôi chẳng hạn như 'madam', 'anna' hoặc
def find_palindromes[s]:
palindromes = []
n = len[s]
for i in range[n]:
for j in range[i+1,n+1]:
word = s[i:j]
if word == word[::-1]:
palindromes.append[word]
return palindromes
print[find_palindromes['locoannamadam']]
# ['l', 'o', 'oco', 'c', 'o', 'a', 'anna',
# 'n', 'nn', 'n', 'a', 'ama', 'm', 'madam',
# 'a', 'ada', 'd', 'a', 'm']
print[find_palindromes['anna']]
# ['a', 'anna', 'n', 'nn', 'n', 'a']
print[find_palindromes['abc']]
# ['a', 'b', 'c']0Bài viết này muốn cung cấp cho bạn một giải pháp nhanh chóng và dễ dàng trong Python. Đầu tiên, chúng ta sẽ giải bài toán dễ hơn nhưng quan trọng là kiểm tra xem một chuỗi con có phải là một palindrome hay không ngay từ đầu
Cách kiểm tra xem chuỗi có phải là Palindrome không
Bạn có thể dễ dàng kiểm tra xem một chuỗi có phải là một bảng màu hay không bằng cách sử dụng biểu thức cắt lớp
def find_palindromes[s]:
palindromes = []
n = len[s]
for i in range[n]:
for j in range[i+1,n+1]:
word = s[i:j]
if word == word[::-1]:
palindromes.append[word]
return palindromes
print[find_palindromes['locoannamadam']]
# ['l', 'o', 'oco', 'c', 'o', 'a', 'anna',
# 'n', 'nn', 'n', 'a', 'ama', 'm', 'madam',
# 'a', 'ada', 'd', 'a', 'm']
print[find_palindromes['anna']]
# ['a', 'anna', 'n', 'nn', 'n', 'a']
print[find_palindromes['abc']]
# ['a', 'b', 'c']1 ước tính thành def find_palindromes[s]:
palindromes = []
n = len[s]
for i in range[n]:
for j in range[i+1,n+1]:
word = s[i:j]
if word == word[::-1]:
palindromes.append[word]
return palindromes
print[find_palindromes['locoannamadam']]
# ['l', 'o', 'oco', 'c', 'o', 'a', 'anna',
# 'n', 'nn', 'n', 'a', 'ama', 'm', 'madam',
# 'a', 'ada', 'd', 'a', 'm']
print[find_palindromes['anna']]
# ['a', 'anna', 'n', 'nn', 'n', 'a']
print[find_palindromes['abc']]
# ['a', 'b', 'c']2 nếu từ đó tiến và lùi giống nhau, i. e. , nó là một đối xứng👉 Hướng dẫn đề xuất. Python Palindromes một lớp lót
Tiếp theo, chúng ta sẽ khám phá cách tìm tất cả các chuỗi con trong chuỗi Python cũng là chuỗi đối xứng. Bạn có thể tìm thấy trình kiểm tra palindrome của chúng tôi trong giải pháp mã [được đánh dấu]
Tìm tất cả các chuỗi con là Palindrome
Cách tiếp cận brute-force để tìm tất cả các palindrome trong một chuỗi là lặp qua tất cả các chuỗi con trong một vòng lặp
def find_palindromes[s]:
palindromes = []
n = len[s]
for i in range[n]:
for j in range[i+1,n+1]:
word = s[i:j]
if word == word[::-1]:
palindromes.append[word]
return palindromes
print[find_palindromes['locoannamadam']]
# ['l', 'o', 'oco', 'c', 'o', 'a', 'anna',
# 'n', 'nn', 'n', 'a', 'ama', 'm', 'madam',
# 'a', 'ada', 'd', 'a', 'm']
print[find_palindromes['anna']]
# ['a', 'anna', 'n', 'nn', 'n', 'a']
print[find_palindromes['abc']]
# ['a', 'b', 'c']3 lồng nhau. Sau đó kiểm tra từng chuỗi con xem nó có phải là một palindrom hay không bằng cách sử dụng def find_palindromes[s]:
palindromes = []
n = len[s]
for i in range[n]:
for j in range[i+1,n+1]:
word = s[i:j]
if word == word[::-1]:
palindromes.append[word]
return palindromes
print[find_palindromes['locoannamadam']]
# ['l', 'o', 'oco', 'c', 'o', 'a', 'anna',
# 'n', 'nn', 'n', 'a', 'ama', 'm', 'madam',
# 'a', 'ada', 'd', 'a', 'm']
print[find_palindromes['anna']]
# ['a', 'anna', 'n', 'nn', 'n', 'a']
print[find_palindromes['abc']]
# ['a', 'b', 'c']1. Theo dõi các palindrome được tìm thấy bằng phương pháp def find_palindromes[s, j, k]:
''' Finds palindromes in substring between indices j and k'''
palindromes = []
while j >= 0 and k < len[s]:
if s[j] != s[k]:
break
palindromes.append[s[j: k + 1]]
j -= 1
k += 1
return palindromes
def find_all[s]:
'''Finds all palindromes [non-trivial] in string s'''
palindromes = []
for i in range[0, len[s]]:
palindromes.extend[find_palindromes[s, i-1, i+1]]
palindromes.extend[find_palindromes[s, i, i+1]]
return palindromes
print[find_all['locoannamadam']]
# ['oco', 'nn', 'anna', 'ama', 'ada', 'madam']
print[find_all['anna']]
# ['nn', 'anna']
print[find_all['abc']]
# []
2. Trả về danh sách cuối cùng sau khi duyệt qua tất cả các chuỗi conĐây là giải pháp đầy đủ
def find_palindromes[s]:
palindromes = []
n = len[s]
for i in range[n]:
for j in range[i+1,n+1]:
word = s[i:j]
if word == word[::-1]:
palindromes.append[word]
return palindromes
print[find_palindromes['locoannamadam']]
# ['l', 'o', 'oco', 'c', 'o', 'a', 'anna',
# 'n', 'nn', 'n', 'a', 'ama', 'm', 'madam',
# 'a', 'ada', 'd', 'a', 'm']
print[find_palindromes['anna']]
# ['a', 'anna', 'n', 'nn', 'n', 'a']
print[find_palindromes['abc']]
# ['a', 'b', 'c']Độ phức tạp của thời gian chạy
Điều này có độ phức tạp thời gian chạy khối, tôi. e. , đối với chuỗi có độ dài
def find_palindromes[s, j, k]:
''' Finds palindromes in substring between indices j and k'''
palindromes = []
while j >= 0 and k < len[s]:
if s[j] != s[k]:
break
palindromes.append[s[j: k + 1]]
j -= 1
k += 1
return palindromes
def find_all[s]:
'''Finds all palindromes [non-trivial] in string s'''
palindromes = []
for i in range[0, len[s]]:
palindromes.extend[find_palindromes[s, i-1, i+1]]
palindromes.extend[find_palindromes[s, i, i+1]]
return palindromes
print[find_all['locoannamadam']]
# ['oco', 'nn', 'anna', 'ama', 'ada', 'madam']
print[find_all['anna']]
# ['nn', 'anna']
print[find_all['abc']]
# []
0, chúng ta cần kiểm tra def find_palindromes[s, j, k]:
''' Finds palindromes in substring between indices j and k'''
palindromes = []
while j >= 0 and k < len[s]:
if s[j] != s[k]:
break
palindromes.append[s[j: k + 1]]
j -= 1
k += 1
return palindromes
def find_all[s]:
'''Finds all palindromes [non-trivial] in string s'''
palindromes = []
for i in range[0, len[s]]:
palindromes.extend[find_palindromes[s, i-1, i+1]]
palindromes.extend[find_palindromes[s, i, i+1]]
return palindromes
print[find_all['locoannamadam']]
# ['oco', 'nn', 'anna', 'ama', 'ada', 'madam']
print[find_all['anna']]
# ['nn', 'anna']
print[find_all['abc']]
# []
1 từ khác nhau. Mỗi từ có thể có tối đa def find_palindromes[s, j, k]:
''' Finds palindromes in substring between indices j and k'''
palindromes = []
while j >= 0 and k < len[s]:
if s[j] != s[k]:
break
palindromes.append[s[j: k + 1]]
j -= 1
k += 1
return palindromes
def find_all[s]:
'''Finds all palindromes [non-trivial] in string s'''
palindromes = []
for i in range[0, len[s]]:
palindromes.extend[find_palindromes[s, i-1, i+1]]
palindromes.extend[find_palindromes[s, i, i+1]]
return palindromes
print[find_all['locoannamadam']]
# ['oco', 'nn', 'anna', 'ama', 'ada', 'madam']
print[find_all['anna']]
# ['nn', 'anna']
print[find_all['abc']]
# []
0 ký tự, do đó bản thân kiểm tra palindrome là def find_palindromes[s, j, k]:
''' Finds palindromes in substring between indices j and k'''
palindromes = []
while j >= 0 and k < len[s]:
if s[j] != s[k]:
break
palindromes.append[s[j: k + 1]]
j -= 1
k += 1
return palindromes
def find_all[s]:
'''Finds all palindromes [non-trivial] in string s'''
palindromes = []
for i in range[0, len[s]]:
palindromes.extend[find_palindromes[s, i-1, i+1]]
palindromes.extend[find_palindromes[s, i, i+1]]
return palindromes
print[find_all['locoannamadam']]
# ['oco', 'nn', 'anna', 'ama', 'ada', 'madam']
print[find_all['anna']]
# ['nn', 'anna']
print[find_all['abc']]
# []
3. Cùng với nhau, điều này mang lại độ phức tạp thời gian chạy của def find_palindromes[s, j, k]:
''' Finds palindromes in substring between indices j and k'''
palindromes = []
while j >= 0 and k < len[s]:
if s[j] != s[k]:
break
palindromes.append[s[j: k + 1]]
j -= 1
k += 1
return palindromes
def find_all[s]:
'''Finds all palindromes [non-trivial] in string s'''
palindromes = []
for i in range[0, len[s]]:
palindromes.extend[find_palindromes[s, i-1, i+1]]
palindromes.extend[find_palindromes[s, i, i+1]]
return palindromes
print[find_all['locoannamadam']]
# ['oco', 'nn', 'anna', 'ama', 'ada', 'madam']
print[find_all['anna']]
# ['nn', 'anna']
print[find_all['abc']]
# []
4Giải pháp thời gian chạy bậc hai
đây là điều tốt nhất mà chúng ta có thể làm sao? . Ngoài ra còn có một giải pháp thời gian O[n²]
Đây là một giải pháp thời gian chạy bậc hai để tìm tất cả các đối xứng trong một chuỗi đã cho mà bỏ qua các đối xứng một ký tự tầm thường [được sửa đổi đáng kể từ nguồn]
def find_palindromes[s, j, k]:
''' Finds palindromes in substring between indices j and k'''
palindromes = []
while j >= 0 and k < len[s]:
if s[j] != s[k]:
break
palindromes.append[s[j: k + 1]]
j -= 1
k += 1
return palindromes
def find_all[s]:
'''Finds all palindromes [non-trivial] in string s'''
palindromes = []
for i in range[0, len[s]]:
palindromes.extend[find_palindromes[s, i-1, i+1]]
palindromes.extend[find_palindromes[s, i, i+1]]
return palindromes
print[find_all['locoannamadam']]
# ['oco', 'nn', 'anna', 'ama', 'ada', 'madam']
print[find_all['anna']]
# ['nn', 'anna']
print[find_all['abc']]
# []
Vui lòng tham gia cộng đồng của chúng tôi gồm những người học đầy tham vọng như bạn [chúng tôi cũng có cheat sheet]. ❤️
Chris
Trong khi làm việc với tư cách là một nhà nghiên cứu trong các hệ thống phân tán, Dr. Christian Mayer tìm thấy tình yêu của mình với việc dạy sinh viên khoa học máy tính
Để giúp sinh viên đạt được mức độ thành công Python cao hơn, anh ấy đã thành lập trang web giáo dục lập trình Finxter. com. Ông là tác giả của cuốn sách lập trình nổi tiếng Python One-Liners [NoStarch 2020], đồng tác giả của loạt sách tự xuất bản Coffee Break Python, người đam mê khoa học máy tính, cộng tác viên tự do và chủ sở hữu của một trong 10 blog Python lớn nhất thế giới
Niềm đam mê của anh ấy là viết, đọc và mã hóa. Nhưng niềm đam mê lớn nhất của anh ấy là phục vụ các lập trình viên đầy tham vọng thông qua Finxter và giúp họ nâng cao kỹ năng của mình. Bạn có thể tham gia học viện email miễn phí của anh ấy tại đây