Mã python giải sudoku

Máy học là xu hướng phát triển mới của lĩnh vực Trí Tuệ Nhân Tạo và ngày càng có nhiều ứng dụng trong đời sống thực tế. Các ví dụ điển hình của máy học có thể kể đến như cỗ máy tìm kiếm Google. Hằng ngày bạn vào Google tìm kiếm và để ý rằng, Google có thể hiểu được ngữ nghĩa của từ khóa mà bạn tìm kiếm nhằm gợi ý và đưa ra các kết quả tìm kiếm tốt hơn hay gợi ý các kết quả tìm kiếm cho bạn. Hoặc như Facebook, có thể nhận dạng khuôn mặt ở chức năng tag ảnh, có thể gợi ý bài viết liên quan hoặc gợi ý kết bạn. Có khi nào bạn tự hỏi vì sao các ứng dụng có thể “thông minh” đến như thế? Nhờ vào thuật toán cụ thể nào để có thể đạt được như thế?

Bạn có phải là nhà phát triển Python đang trau dồi các kỹ năng của mình trước khi phỏng vấn không? Nếu vậy, thì hướng dẫn này sẽ mở ra cho bạn một loạt các vấn đề thực hành Python nhằm mô phỏng các tình huống kiểm tra code phổ biến.  Sau khi bạn phát triển các giải pháp của riêng mình, bạn sẽ xem qua các câu trả lời của nhóm V1Study để bạn có thể tối ưu hóa code, gây ấn tượng với người phỏng vấn và đạt được công việc mơ ước của bạn

Trong hướng dẫn này, bạn sẽ học cách

• Viết code cho các vấn đề kiểu phỏng vấn
• Thảo luận về các giải pháp của bạn trong cuộc phỏng vấn
• Làm việc qua các chi tiết thường bị bỏ qua
• Nói về các quyết định thiết kế và sự đánh đổi

Hướng dẫn này dành cho các nhà phát triển Python trung cấp.  Nó giả định kiến thức cơ bản về Python và khả năng giải quyết vấn đề bằng Python. Bạn có thể nhận mã với các bài kiểm tra đơn vị không thành công cho từng vấn đề mà bạn sẽ thấy trong hướng dẫn này bằng cách nhấp vào liên kết bên dưới

Bài tập thực hành Python 1. Tổng của một dãy số nguyên

Hãy bắt đầu với một câu hỏi khởi động.  Trong bài toán thực hành đầu tiên, bạn sẽ viết mã để tính tổng một danh sách các số nguyên. Mỗi vấn đề thực hiện bao gồm một mô tả. Mô tả này được lấy trực tiếp từ các tệp khung trong repo để giúp bạn dễ nhớ hơn khi bạn đang nghiên cứu giải pháp của mình

Bạn cũng sẽ thấy phần giải pháp cho từng vấn đề. Hầu hết các thảo luận sẽ nằm trong phần thu gọn bên dưới. Sao chép repo đó nếu bạn chưa có, tìm giải pháp cho vấn đề sau, sau đó mở rộng hộp giải pháp để xem lại công việc của bạn

Mô tả vấn đề

Đây là vấn đề đầu tiên của bạn

Tổng số nguyên lên đến n ( 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

2)

Viết một hàm, 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

3 lấy một số nguyên duy nhất làm đầu vào và trả về tổng số nguyên từ 0 đến tham số đầu vào

Hàm sẽ trả về 0 nếu một số không phải là số nguyên được truyền vào

Hãy nhớ chạy các bài kiểm tra đơn vị cho đến khi bạn vượt qua chúng

Giải pháp

Dưới đây là một số thảo luận về một số giải pháp khả thi

Lưu ý. Hãy nhớ rằng, đừng mở phần thu gọn bên dưới cho đến khi bạn sẵn sàng xem câu trả lời cho vấn đề thực thi Python này

zzzGiải pháp cho Tổng số nguyên của dãy số Hiển thị

Làm thế nào để viết các giải pháp đi?

Đối với vấn đề này, bạn sẽ xem xét một số giải pháp khác nhau. Cái đầu tiên trong số này không tốt lắm

# integersums.py
def first(n):
    num = 1
    sum = 0
    while num < n + 1:
        sum = sum + num
        num = num + 1
    return sum

Trong giải pháp này, bạn tự xây dựng một 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Giải pháp này hoạt động, nhưng nó có hai vấn đề

1. Nó không hiển thị ý kiến ​​của bạn về Python và cách ngôn ngữ này đơn giản hóa các tác vụ như thế này

2. Nó không trả lời các điều kiện lỗi trong mô tả sự cố. Truyền vào một chuỗi sẽ dẫn đến lệnh ném hàm ra một ngoại lệ khi nó chỉ trả về

   # integersums.py
   def add_it_up(n):
       try:
           result = sum(range(n + 1))
       except TypeError:
           result = 0
       return result
   

   8

Bạn sẽ giải quyết các lỗi điều kiện trong câu trả lời cuối cùng bên dưới, nhưng trước tiên hãy tinh chỉnh giải pháp cốt lõi cốt lõi để Pythonic hơn một chút

Điều kiện đầu tiên cần nghĩ đến là 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Bạn có thể thấy rằng 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Đây là một bước tốt đẹp. Nó loại bỏ một số mã viết sẵn của công việc lặp lại trên một phạm vi và làm cho ý định của bạn rõ ràng hơn.  Nhưng vẫn còn nhiều điều bạn có thể làm ở đây

Tính tổng danh sách các số nguyên là một thứ khác mà Python giỏi

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

chà. Bằng cách sử dụng tính hợp lệ sẵn có 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Tuy nhiên, vẫn còn một vấn đề.  Mã này vẫn không xử lý các điều kiện lỗi một cách chính xác. Để giải quyết điều đó, bạn có thể bọc mã trước đó của mình thành một

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Điều này giải quyết vấn đề và xử lý các điều kiện lỗi một cách chính xác. Tốt thôi

Đôi khi, những người phỏng vấn sẽ hỏi câu hỏi này với một giới hạn cố định, chẳng hạn như “In tổng của chín số nguyên đầu tiên”.  Khi vấn đề được giải quyết theo cách đó, một giải pháp đúng sẽ là 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Tuy nhiên, nếu bạn đưa ra câu trả lời này, thì bạn nên theo dõi mã giải quyết vấn đề từng bước.  Câu trả lời mẹo là một nơi tốt để bắt đầu câu trả lời của bạn, nhưng nó không phải là một nơi tuyệt vời để kết thúc

Nếu bạn muốn mở rộng vấn đề này, hãy thử thêm một giới hạn thấp hơn tùy chọn 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Vấn đề thực hành Python 2. Mật mã Caesar

Câu hỏi tiếp theo là một hai mệnh giá.  Bạn sẽ viết mã một hàm để tính toán mật mã Caesar khi nhập văn bản.  Đối với vấn đề này, bạn có thể sử dụng bất kỳ phần nào của thư viện chuẩn Python để thực hiện chuyển đổi

Gợi ý.  Có một hàm trong 

# integersums.py
def first(n):
    num = 1
    sum = 0
    while num < n + 1:
        sum = sum + num
        num = num + 1
    return sum

Mô tả vấn đề

Câu lệnh sự cố nằm ở đầu tệp nguồn bộ xương

Mật mã Caesar ( 

# integersums.py
def first(n):
    num = 1
    sum = 0
    while num < n + 1:
        sum = sum + num
        num = num + 1
    return sum

21)

Mật mã Caesar là một mật mã thay thế đơn giản, trong đó mỗi chữ cái của văn bản thuần túy được thay thế bằng một chữ cái được tìm thấy bằng cách di chuyển các 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

6vị trí xuống bảng chữ cái.  Ví dụ. giả sử văn bản thuần túy đầu vào là như sau

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

0

Nếu giá trị shift 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

6, là 4, thì văn bản được mã hóa sẽ như sau

# integersums.py
def first(n):
    num = 1
    sum = 0
    while num < n + 1:
        sum = sum + num
        num = num + 1
    return sum

2

Bạn phải viết một hàm chấp nhận hai đối số, một tin nhắn văn bản thuần túy và một số chữ cái cần dịch chuyển trong mật mã.  Hàm sẽ trả về một chuỗi được mã hóa với tất cả các chữ cái đã được biến đổi và tất cả các dấu câu và khoảng trắng vẫn không thay đổi

Lưu ý.  Bạn có thể cho rằng văn bản thuần túy là tất cả ASCII viết thường ngoại trừ khoảng trắng và dấu chấm câu

Hãy nhớ rằng, phần này của câu hỏi thực sự là về việc bạn có thể tham quan tốt như thế nào trong thư viện tiêu chuẩn.  Nếu bạn thấy mình đang tìm cách thực hiện chuyển đổi mà không cần thư viện, thì hãy lưu lại suy nghĩ đó.  Bạn sẽ cần nó sau

Giải pháp vấn đề

Đây là một giải pháp cho vấn đề mật mã Caesar được mô tả ở trên

Lưu ý. Hãy nhớ rằng, đừng mở phần thu gọn bên dưới cho đến khi bạn sẵn sàng xem câu trả lời cho vấn đề thực thi Python này

Giải pháp cho Mật mã Caesar Hiện an

Giải pháp này tận dụng 

# integersums.py
def first(n):
    num = 1
    sum = 0
    while num < n + 1:
        sum = sum + num
        num = num + 1
    return sum

# integersums.py
def first(n):
    num = 1
    sum = 0
    while num < n + 1:
        sum = sum + num
        num = num + 1
    return sum

# integersums.py
def first(n):
    num = 1
    sum = 0
    while num < n + 1:
        sum = sum + num
        num = num + 1
    return sum

Được rồi, bây giờ bạn đã sẵn sàng, hãy xem giải pháp này

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Bạn có thể thấy rằng hàm sử dụng ba thứ từ 

# integersums.py
def first(n):
    num = 1
    sum = 0
    while num < n + 1:
        sum = sum + num
        num = num + 1
    return sum

1. # integersums.py
   def first(n):
       num = 1
       sum = 0
       while num < n + 1:
           sum = sum + num
           num = num + 1
       return sum
   

   28

2. # integersums.py
   def first(n):
       num = 1
       sum = 0
       while num < n + 1:
           sum = sum + num
           num = num + 1
       return sum
   

   29

3. # integersums.py
   def first(n):
       num = 1
       sum = 0
       while num < n + 1:
           sum = sum + num
           num = num + 1
       return sum
   

   24

Trong hai dòng đầu tiên, bạn tạo một biến với tất cả các chữ cái thường của bảng chữ cái (ASCII chỉ dành cho chương trình này) và sau đó tạo một 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

>>>

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Bạn có thể thấy đó 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Dòng 6 trong giải pháp, 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def first(n):
    num = 1
    sum = 0
    while num < n + 1:
        sum = sum + num
        num = num + 1
    return sum

Tiếp theo, bạn chuyển bảng dịch sang chuỗi công thức 

# integersums.py
def first(n):
    num = 1
    sum = 0
    while num < n + 1:
        sum = sum + num
        num = num + 1
    return sum

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Câu hỏi này là một bài tập về việc biết và sử dụng thư viện chuẩn.  Bạn có thể được hỏi một câu hỏi như thế này vào một thời điểm nào đó trong một cuộc phỏng vấn.  Nếu điều đó xảy ra với bạn, tốt hơn hết là bạn nên dành thời gian suy nghĩ về những câu trả lời khả thi.  Nếu bạn có thể nhớ phương pháp— 

# integersums.py
def first(n):
    num = 1
    sum = 0
    while num < n + 1:
        sum = sum + num
        num = num + 1
    return sum

Nhưng có một số kịch bản khác cần xem xét

1. Bạn hoàn toàn có thể vẽ một khoảng trống.  Trong trường hợp này, có thể bạn sẽ giải quyết vấn đề này theo cách bạn giải quyết vấn đề tiếp theo , và đó là một câu trả lời có thể chấp nhận được

2. Bạn có thể nhớ rằng thư viện chuẩn có chức năng làm những gì bạn muốn nhưng không nhớ chi tiết

Nếu bạn đang làm công việc bình thường và gặp phải một trong hai tình huống này, thì bạn chỉ cần thực hiện một số tìm kiếm và đi trên con đường của mình.  Nhưng trong một tình huống phỏng vấn, nó sẽ giúp bạn nói rõ vấn đề một cách rõ ràng

Yêu cầu người phỏng vấn giúp đỡ cụ thể sẽ tốt hơn nhiều so với việc phớt lờ nó.  Hãy thử một cái gì đó như “Tôi nghĩ rằng có một chức năng ánh xạ một bộ ký tự này sang một bộ ký tự khác.  Bạn có thể giúp tôi nhớ nó được gọi là gì không? ”

Trong một cuộc phỏng vấn tình huống, thông thường tốt hơn là thừa nhận rằng bạn không biết điều gì đó hơn là cố gắng vượt qua một cách vô tội.

Bây giờ bạn đã thấy một giải pháp bằng cách sử dụng thư viện chuẩn Python, hãy thử lại vấn đề tương tự, nhưng không có sự trợ giúp đó

Vấn đề thực thi Python 3. Mật mã Caesar Redux

Đối với vấn đề thực hành thứ ba, bạn sẽ giải lại mật mã Caesar, nhưng lần này bạn sẽ làm điều đó mà không cần sử dụng 

# integersums.py
def first(n):
    num = 1
    sum = 0
    while num < n + 1:
        sum = sum + num
        num = num + 1
    return sum

Mô tả vấn đề

Mô tả của vấn đề này cũng giống như vấn đề trước đó.  Trước khi đi sâu vào giải pháp, bạn có thể tự hỏi tại sao bạn lại lặp lại cùng một bài tập mà không có sự trợ giúp của 

# integersums.py
def first(n):
    num = 1
    sum = 0
    while num < n + 1:
        sum = sum + num
        num = num + 1
    return sum

Đó là một câu hỏi tuyệt vời. Trong cuộc sống bình thường, khi mục tiêu của bạn là một chương trình hoạt động được, có thể bảo trì được, thì việc viết lại các phần của thư viện chuẩn là một lựa chọn không tồi. Thư viện chuẩn Python được đóng gói với các giải pháp hoạt động, được kiểm tra tốt và nhanh chóng cho các vấn đề lớn và nhỏ. Tận dụng triệt để nó là một dấu ấn của một thành viên giỏi

Điều đó nói lên rằng, đây không phải là một dự án công việc hay một chương trình mà bạn đang xây dựng để đáp ứng nhu cầu. Đây là một bài học tập và nó là loại câu hỏi có thể được hỏi trong một cuộc phỏng vấn. Mục tiêu của cả hai là xem bạn có thể giải quyết vấn đề như thế nào và bạn phải đánh đổi thiết kế thú vị nào khi thực hiện nó

Vì vậy, với câu hỏi của tinh thần học hỏi, chúng ta sẽ cố gắng giải mật mã Caesar mà không có 

# integersums.py
def first(n):
    num = 1
    sum = 0
    while num < n + 1:
        sum = sum + num
        num = num + 1
    return sum

Giải pháp vấn đề

Đối với vấn đề này, bạn sẽ có hai giải pháp khác nhau để xem xét khi bạn sẵn sàng mở rộng phần bên dưới

Lưu ý. Hãy nhớ rằng, đừng mở phần thu gọn bên dưới cho đến khi bạn sẵn sàng xem câu trả lời cho vấn đề thực thi Python này

Giải pháp cho Caesar Cipher Redux Hiển thị

Đối với vấn đề này, hai giải pháp khác nhau được cung cấp. Kiểm tra cả hai và xem bạn thích cái nào hơn

Giải pháp 1

Đối với giải pháp đầu tiên, bạn làm theo các mô tả vấn đề chặt chẽ, bổ sung một số tiền cho mỗi nhân vật và đặt nó trở lại phần đầu của bảng chữ cái khi nó đi vào bên ngoài

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Bắt đầu từ dòng 14, bạn có thể thấy điều đó 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Tại đây, bạn có thể thấy một mục đích sử dụng khác 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

1. # integersums.py
   def add_it_up(n):
       try:
           result = sum(range(n + 1))
       except TypeError:
           result = 0
       return result
   

   32

2. # integersums.py
   def add_it_up(n):
       try:
           result = sum(range(n + 1))
       except TypeError:
           result = 0
       return result
   

   33

Một lần nữa, bạn không chỉ được khen thưởng về những chức năng của học sinh mà còn xem xét xem bạn có thể trả lời như thế nào trong một vấn đề phỏng vấn nếu bạn không thể nhớ tên của họ

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Bước đầu mã hóa của bạn trên dòng 7 lấy giá trị số của ký tự đã được mã hóa bằng cách sử dụng 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Đối với nhiều chữ cái có giá trị giao dịch chuyển nhỏ, bạn có thể chuyển đổi chữ cái trở lại một ký tự và bạn sẽ hoàn tất. Nhưng hãy xem xét chữ cái bắt đầu , 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Một sự thay đổi của một ký tự sẽ dẫn đến chữ cái 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Bạn thực hiện công việc này trong các dòng từ 8 đến 11 bằng cách thêm liên tục 26 vào hoặc loại bỏ nó khỏi các ký tự cho đến khi nó nằm trong phạm vi của ký tự ASCII. Lưu ý rằng đây là một phương pháp khá kém hiệu quả để giải quyết vấn đề này. Bạn sẽ thấy một giải pháp tốt hơn trong câu trả lời tiếp theo

Cuối cùng, trên dòng 12, chức năng chuyển đổi hàm shift của bạn lấy giá trị số của ký tự mới và chuyển nó trở lại thành một ký tự để trả về

Mặc dù giải pháp này sử dụng một cách tiếp cận theo nghĩa đen để giải quyết vấn đề mật mã Caesar, nhưng bạn cũng có thể sử dụng một cách tiếp cận khác được mô phỏng theo 

# integersums.py
def first(n):
    num = 1
    sum = 0
    while num < n + 1:
        sum = sum + num
        num = num + 1
    return sum

Giải pháp 2

Giải pháp thứ hai cho vấn đề này bắt đầu khởi động hành vi của phương thức tích hợp sẵn của Python

# integersums.py
def first(n):
    num = 1
    sum = 0
    while num < n + 1:
        sum = sum + num
        num = num + 1
    return sum

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Bắt đầu với 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Mod nhà điều hành tạo ra phần còn lại từ một bộ phận nguyên. Trong trường hợp này, bạn chia cho 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Tiếp theo, bạn tạo bảng dịch. Đây là một sự thay đổi so với các giải pháp trước đó và đáng chú ý. Bạn sẽ tìm hiểu thêm về điều này ở cuối phần này

Sau khi bạn tạo 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Bây giờ chúng ta hãy thảo luận về vấn đề tạo bảng. Đối với ví dụ chơi này, nó không thể quá quan trọng, nhưng nó minh họa một tình huống thường xuyên xảy ra trong quá trình phát triển hàng ngày. cân bằng độ rõ ràng của mã với các tắc nghẽn hiệu suất đã biết

Nếu kiểm tra lại mã, bạn sẽ thấy nó 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Vấn đề với cách tiếp cận đó là nó dành thời gian tính toán cùng một bảng cho từng chữ cái của tin nhắn. Đối với các tin nhắn nhỏ, thời gian này sẽ không đáng kể, nhưng nó có thể tăng lên so với các tin nhắn lớn hơn

Một cách khác có thể xảy ra mà bạn có thể tránh được hình phạt hiệu suất này là tạo ra 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Vào cuối ngày, hãy lựa chọn giữa việc tạo 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Nếu đây là một dự án nhỏ và bạn biết nó sẽ được sử dụng để mã hóa các thông báo lớn, thì việc tạo bảng chỉ một lần có thể là quyết định đúng đắn. Nếu đây chỉ là một phần của dự án lớn hơn, có nghĩa là khả năng bảo trì là chìa khóa, thì có thể tạo bảng mỗi lần là lựa chọn tốt hơn

Vì bạn đã xem xét hai giải pháp, nên dành một chút thời gian để thảo luận về những điểm giống và khác nhau của chúng

So sánh giải pháp

Bạn đã thấy hai giải pháp trong phần này của mật mã Caesar và chúng khá giống nhau về nhiều mặt. We are same lines. Hai quy hoạch chính của tòa nhà giống nhau ngoại trừ giới hạn 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

First 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Mặc dù có cùng độ dài với phiên bản thứ hai nhưng phiên bản đầu tiên 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Phiên bản đầu tiên của chức năng cũng có thể giải quyết vấn đề cụ thể này. Phiên bản thứ hai 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def first(n):
    num = 1
    sum = 0
    while num < n + 1:
        sum = sum + num
        num = num + 1
    return sum

Một trong những câu thần chú được phát hành từ phong trào Lập trình cực mê là “Bạn sẽ không cần nó” (YAGNI). Thông thường, các nhà phát triển phần mềm sẽ xem xét một chức năng như thế nào 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Trong khi điều đó thực sự sẽ làm cho chức năng có mục đích chung hơn, nó cũng sẽ làm cho nó phức tạp hơn. Câu thần chú YAGNI ở đó để nhắc nhở bạn đừng thêm phức tạp trước khi bạn có một trường hợp sử dụng cụ thể cho nó

Để kết thúc phần mật mã Caesar của bạn, có sự cân bằng rõ ràng giữa hai giải pháp, nhưng giải pháp thứ hai _______530có vẻ giống như một hàm Pythonic tốt hơn và nhiều hơn một chút

Bây giờ bạn đã viết mật mã Caesar theo ba cách nhau, hãy chuyển sang một vấn đề mới

Bài tập thực thi Python 4. Nhật ký phân tích cú pháp

Vấn đề phân tích cú pháp nhật ký là một vấn đề thường xảy ra trong quá trình phát triển phần mềm. Nhiều hệ thống tạo ra các tệp nhật ký trong quá trình hoạt động bình thường và đôi khi bạn cần phân tích cú pháp các tệp này để tìm các điểm bất thường hoặc thông tin chung về hệ thống đang chạy

Mô tả vấn đề

Đối với vấn đề này, bạn cần phải phân tích cú pháp tệp nhật ký có định dạng được chỉ định và tạo báo cáo

Nhật ký phân tích cú pháp ( 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

124)

Chấp nhận tên tệp trên dòng lệnh. Tệp này là tệp nhật ký giống Linux từ hệ thống mà bạn đang khắc phục sự cố. Xen kẽ giữa các câu lệnh khác nhau là các thông báo cho biết trạng thái của thiết bị. Chúng trông như thế này

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

11

Trạng thái thông báo của thiết bị có thể có nhiều giá trị, nhưng chương trình này quan tâm đến chỉ có ba.

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

125, 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

126, và 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

127

Chương trình của bạn sẽ phân tích cú pháp tệp nhật ký đã chọn và đưa ra một báo cáo để biết thời gian hoạt động của thiết bị 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

125và dấu thời gian của bất kỳ 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

127 điều kiện nào

Lưu ý rằng mã khung được cung cấp không bao gồm các bài kiểm tra đơn vị. Điều này đã bị loại bỏ vì định dạng chính xác của báo cáo là tùy thuộc vào bạn. Suy nghĩ và bài viết của riêng bạn trong suốt quá trình

Một 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Mặc dù định dạng đó được tạo bởi giải pháp Python thực, nhưng bạn có thể tự thiết kế định dạng của riêng mình cho đầu ra. Tệp đầu vào mẫu phải tạo thông tin tương thích

Giải pháp vấn đề

Trong phần thu gọn bên dưới, bạn sẽ tìm thấy giải pháp khả thi cho vấn đề phân tích cú pháp nhật ký. Khi bạn đã có sẵn, hãy mở rộng hộp và so sánh nó với những gì bạn đã nghĩ ra

Lưu ý. Hãy nhớ rằng, đừng mở phần thu gọn bên dưới cho đến khi bạn sẵn sàng xem câu trả lời cho vấn đề thực thi Python này

Giải pháp cho vấn đề phân tích cú pháp nhật ký Hiển thị

Full solution

Vì giải pháp này dài hơn những gì bạn đã thấy về tổng số nguyên hoặc các vấn đề về mật mã Caesar, hãy bắt đầu với chương trình đầy đủ

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

That is your full solution. Bạn có thể thấy rằng chương trình bao gồm ba chức năng và phần chính. You will doing work through them from the start

Trợ giúp chức năng.

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

131

Đầu tiên là 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Bởi vì nó chứa một 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Bạn chỉ có thể cần sử dụng 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Điều này có thể 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Bạn có thể tự hỏi khi nào

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Trợ giúp chức năng.

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

141

Chức năng thứ hai 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Có một số điểm thú vị cho chức năng này. Đầu tiên là việc trừ hai 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Điều lưu ý thứ hai là có rất nhiều gói trong Python giúp đơn giản hóa công việc xử lý ngày và giờ. Trong trường hợp này, mô hình sử dụng của bạn đủ đơn giản để không đảm bảo sự phức tạp khi kéo trong thư viện bên ngoài khi chức năng của thư viện chuẩn sẽ đủ

Điều đó nói rằng,

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Đây là một nơi khác, trong một tình huống phỏng vấn, điều quan trọng là đừng hoảng sợ nếu bạn không thể nhớ tên chính xác của các thư viện hàm Python chuẩn

Trợ giúp chức năng.

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

150

Tiếp theo là 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Trạng thái máy là thiết bị phần mềm (hoặc phần cứng) chuyển đổi từ trạng thái này sang trạng thái khác tùy thuộc vào các đầu vào cụ thể. Đó là một định nghĩa thực sự về độ rộng có thể khó bắt, vì vậy hãy xem sơ đồ trạng thái máy mà bạn sẽ sử dụng bên dưới

Trong biểu đồ này, các trạng thái được biểu diễn bằng các hộp có nhãn. Ở đây chỉ có hai trạng thái 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Ví dụ, nếu máy ở 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Trong khi máy trạng thái ở đây chỉ là hai trạng thái với hai đầu vào, máy trạng thái thường phức tạp hơn nhiều. Tạo sơ đồ chờ đợi về hành vi mong muốn có thể giúp bạn thực hiện mã phát triển khai thác trạng thái máy rút ngắn hơn

Vui lòng quay lại 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Có thể khó tìm thấy trạng thái máy ở đây. Thông thường, các trạng thái máy yêu cầu một biến để giữ trạng thái. Trong trường hợp này, bạn sử dụng 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

1. Cho biết trạng thái.

   # integersums.py
   def add_it_up(n):
       try:
           result = sum(range(n + 1))
       except TypeError:
           result = 0
       return result
   

   163  trạng thái lưu trữ của máy trạng thái của bạn. Nếu có 

   # integersums.py
   def add_it_up(n):
       try:
           result = sum(range(n + 1))
       except TypeError:
           result = 0
       return result
   

   165, thì máy đang ở 

   # integersums.py
   def add_it_up(n):
       try:
           result = sum(range(n + 1))
       except TypeError:
           result = 0
       return result
   

   126trạng thái. Nếu nó là 

   # integersums.py
   def add_it_up(n):
       try:
           result = sum(range(n + 1))
       except TypeError:
           result = 0
       return result
   

   167, thì sau đó là máy 

   # integersums.py
   def add_it_up(n):
       try:
           result = sum(range(n + 1))
       except TypeError:
           result = 0
       return result
   

   125
2. Thời gian bắt đầu lưu trữ. Nếu là trạng thái 

   # integersums.py
   def add_it_up(n):
       try:
           result = sum(range(n + 1))
       except TypeError:
           result = 0
       return result
   

   125, thì 

   # integersums.py
   def add_it_up(n):
       try:
           result = sum(range(n + 1))
       except TypeError:
           result = 0
       return result
   

   163đồng thời giữ dấu thời gian của điểm thiết bị được bật. You used this time time to call_______1141

Phần trên cùng của _______ 1150 thiết lập biến trạng thái của bạn 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Khi bạn đã hoàn thành thiết lập ban đầu, bạn gọi chương trình 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Sau khi kiểm tra lỗi, 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Thứ hai 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Chức năng chính

Cuối cùng, bạn có thể chuyển sang phần

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Để gọi giải pháp này, bạn chạy lệnh và chuyển tên của tệp nhật ký. Chạy mã ví dụ của bạn dẫn đến kết quả đầu ra này

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Giải pháp của bạn có thể có định dạng khác, nhưng thông tin phải giống nhau đối với tệp nhật ký mẫu

Có nhiều cách để giải quyết một vấn đề như thế này. Hãy nhớ rằng trong một vấn đề giải quyết vấn đề, việc nói chuyện thông suốt vấn đề và quá trình suy nghĩ của bạn có thể quan trọng hơn việc bạn chọn giải pháp nào để thực hiện

Đó là cú pháp phân tích cú pháp nhật ký. Please transfer to the last end. sudoku

Bài tập thực hành Python 5. Bộ giải Sudoku

Bài toán thực thi Python cuối cùng của bạn đang giải một câu đố sudoku

Tìm một giải pháp nhanh chóng và tiết kiệm bộ nhớ cho vấn đề này có thể là một phương thức khá lớn. Giải pháp bạn sẽ kiểm tra đã được chọn vì khả năng đọc tốt hơn là tốc độ, nhưng bạn có thể tự thực hiện tối ưu hóa giải pháp của mình tùy ý

Mô tả vấn đề

Mô tả cho chương trình giải sudoku có liên quan nhiều hơn một chút so với các vấn đề trước đó

Sudoku Solver ( 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

603)

Chọn một chuỗi ở định dạng SDM, được mô tả bên dưới, hãy viết một chương trình để tìm và trả về lời giải cho câu hỏi sudoku trong chuỗi. Giải pháp phải được trả về cùng một định dạng SDM như ban đầu

Một số câu đố sẽ không thể giải được. Trong trường hợp đó, hãy trả về chuỗi “Không thể giải quyết được”

Định dạng SDM chung được mô tả tại đây

Theo mục đích của chúng tôi, mỗi chuỗi SDM sẽ là một chuỗi bao gồm 81 chữ số, một chữ số cho mỗi vị trí trên câu đố sudoku. Các số đã biết sẽ được đưa ra, và các vị trí chưa biết sẽ có giá trị bằng không

Ví dụ. giả sử bạn được cung cấp chuỗi chữ số này

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

19

Chuỗi đại diện cho câu đối sudoku bắt đầu this

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

60

Các bài kiểm tra đơn vị được cung cấp có thể mất một lúc để chạy, vì vậy hãy kiên nhẫn

Lưu ý. Bạn có thể tìm thấy mô tả về câu đố sudoku trên Wikipedia

Bạn có thể thấy rằng bạn sẽ cần phải xử lý việc đọc và ghi một định dạng cụ thể cũng như tạo ra một giải pháp

Giải pháp vấn đề

Khi bạn đã có sẵn, bạn có thể tìm lời giải thích chi tiết về giải pháp cho vấn đề sudoku trong hộp bên dưới. Một khung tệp với các bài kiểm tra đơn vị được cung cấp trong repo

Lưu ý. Hãy nhớ rằng, đừng mở phần thu gọn bên dưới cho đến khi bạn sẵn sàng xem câu trả lời cho vấn đề thực thi Python này

Giải pháp cho Sudoku Solver Hiển thị

Đây là một vấn đề lớn hơn và phức tạp hơn những gì bạn đã xem xét cho đến nay trong hướng dẫn này. Bạn sẽ từng bước giải quyết vấn đề, kết thúc bằng một hàm đệ quy giải quyết câu hỏi. Dưới đây là bộ phác thảo phác thảo về các bước bạn sẽ thực hiện

• Đọc câu đối thành dạng lưới
• Đối chiếu với mỗi ô
  • Đối chiếu với mỗi số có thể có trong ô đó
    • Đặt số vào ô
    • Xóa số đó khỏi hàng, cột và ô vuông nhỏ
    • Di chuyển đến vị trí tiếp theo
  • Nếu không có số nào có thể còn lại, thì hãy khẳng định câu hỏi là không thể giải được
  • Nếu tất cả các ô được lấp đầy, sau đó trả lời về giải pháp

Phần phức tạp của thuật toán này là theo dõi lưới ở mỗi bước của quy trình. Bạn sẽ sử dụng đệ quy, tạo một bản sao mới của lưới ở mỗi cấp của đệ quy, để duy trì thông tin này

Với ý tưởng về phác thảo đó, hãy bắt đầu với bước đầu tiên, tạo lưới

Tạo lưới từ một dòng

Để bắt đầu, sẽ hữu ích khi chuyển đổi câu hỏi dữ liệu sang một định dạng dễ sử dụng hơn. Ngay cả khi cuối cùng bạn muốn giải câu đố ở định dạng SDM đã chọn, bạn có thể sẽ đạt được tiến độ nhanh hơn khi làm việc thông qua các chi tiết của thuật toán toán học với dữ liệu ở dạng lưới. Sau khi bạn có một giải pháp hoạt động, thì bạn có thể chuyển đổi nó để hoạt động trên một cấu trúc dữ liệu khác

Để kết thúc, hãy bắt đầu với một vài chức năng chuyển đổi

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Hàm đầu tiên của bạn 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Mỗi danh sách bên trong đây đại diện cho một hàng ngang trong câu đố sudoku của bạn

Bạn bắt đầu với một khoảng trống trống 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Hàm kết thúc bằng cách thêm giá trị cuối cùng 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Ham nghịch đảo, 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Bây giờ bạn đã có dữ liệu trong cấu trúc dữ liệu mà bạn muốn, hãy bắt đầu làm việc với nó

Create a small event refigure

Chức năng tiếp theo của bạn là một trình tạo sẽ giúp bạn tìm kiếm hình vuông nhỏ hơn ba nhân ba ở một vị trí nhất định. Với tọa độ x và y của ô được đề cập, trình tạo này sẽ tạo ra một danh sách các tọa độ phù hợp với hình vuông chứa nó

Trong hình trên, bạn đang kiểm tra ô 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Đặt logic để xác định hình vuông nhỏ này trong một chức năng tiện ích đặc biệt sẽ giữ cho luồng các chức năng khác của bạn dễ đọc hơn. Làm cho điều này một trình tạo cho phép bạn sử dụng nó trong một 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Hàm để thực hiện công việc này liên quan đến việc sử dụng các giới hạn của phép toán nguyên

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Có rất nhiều thứ ba trong một vài dòng đó, điều này làm cho các dòng giống như 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

>>>

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Sử dụng phép toán làm tròn số nguyên cho phép bạn nhận được bội số cao nhất tiếp theo của ba trên một giá trị nhất định. Khi bạn có điều này, ngoại trừ ba sẽ cho bạn bội số của ba bên dưới số đã cho

Có một số chức năng tiện ích cấp thấp hơn để kiểm tra trước khi bạn bắt đầu xây dựng trên chúng

Move to the next point

Giải pháp của bạn sẽ cần phải đi qua cấu trúc lưới từng ô. Điều này có nghĩa là tại một số thời điểm, bạn sẽ cần phải tìm ra vị trí tiếp theo.

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Các ______ 1631 lá cờ nói với người gọi rằng các thuật toán đã bước ra khỏi cuối các câu hỏi và đã hoàn thành tất cả các ô vuông. Bạn sẽ thấy nó được sử dụng như thế nào trong phần sau

Loại bỏ các số lượng không thể

Tiện ích cấp thấp cuối cùng của bạn khá nhỏ. Nó nhận một số nguyên giá trị và một giá trị có thể lặp lại. Nếu giá trị khác không và xuất hiện khi có thể lặp lại, thì hàm sẽ xóa nó khỏi giá trị có thể lặp lại

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Thông thường, bạn sẽ không biến một chức năng nhỏ này thành một chức năng. Tuy nhiên, bạn sẽ sử dụng chức năng này nhiều lần, vì vậy tốt nhất bạn nên tuân theo nguyên tắc DRY và kéo nó lên thành một chức năng

Bây giờ bạn đã thấy cấp dưới cùng của chức năng kim tự tháp. Đã đến lúc nâng cấp và sử dụng những công cụ đó để xây dựng một chức năng phức tạp hơn. Bạn gần như đã sẵn sàng để giải câu đố

Find the what can may

Chức năng tiếp theo của bạn sử dụng một số chức năng cấp thấp mà bạn vừa xem qua. Cho một lưới và một vị trí trên lưới đó, nó xác định những giá trị mà vị trí đó vẫn có thể có

Đối với lưới ở trên, tại vị trí 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Đây là trách nhiệm của 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Hàm bắt đầu bằng cách kiểm tra xem vị trí đã chọn tại 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Nếu không, hàm sẽ tạo một tập hợp các số từ một đến chín. Chức năng tiến hành kiểm tra các số chặn khác nhau và loại bỏ các số đó khỏi tập hợp này

Nó bắt đầu bằng cách kiểm tra cột và hàng của vị trí đã chọn. Điều này có thể được thực hiện với một vòng lặp duy nhất bằng cách xen kẽ những thay đổi chỉ số bên dưới.

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Khi các giá trị đó đã bị xóa khỏi 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Khi tất cả các giá trị chặn đã biết đã bị xóa khỏi tập hợp của bạn, bạn sẽ có danh sách tất cả các 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Bạn có thể thắc mắc tại sao mã và mô tả của nó lại nói lên vị trí “trên lưới đó”. Trong chức năng tiếp theo, bạn sẽ thấy rằng chương trình tạo ra nhiều bản sao của lưới khi nó cố gắng giải quyết nó

Giải quyết nó

Bạn đã đạt đến tầm quan trọng của giải pháp này 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Thiết kế chung của 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Đối với mỗi giá trị này, nó tạo ra một lưới với giá trị được dự đoán ở vị trí này. Sau đó, nó gọi một chức năng để kiểm tra một giải pháp, chuyển vào lưới mới và vị trí tiếp theo

Nó chỉ xảy ra rằng chức năng mà nó gọi là chính nó

Đối với bất kỳ yêu cầu nào, bạn cần kết thúc một điều kiện. Thuật toán này có bốn trong số chúng

1. Không có giá trị khả thi nào cho vị trí này. Điều đó cho thấy giải pháp mà nó đang thử nghiệm không thể hoạt động
2. Nó được đi đến cuối lưới và tìm thấy các giá trị có thể có cho mỗi vị trí. Câu đố đã được giải quyết
3. Một trong những dự đoán ở vị trí này, khi được chuyển lại cho người giải, sẽ trả về một giải pháp
4. Nó đã thử tất cả các giá trị có thể có ở vị trí này và không có giá trị nào trong số chúng sẽ hoạt động

Vui lòng xem mã cho điều này và xem tất cả các diễn biến như thế nào

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Điều đầu tiên cần lưu ý trong chức năng này là nó tạo ra một 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Khi lưới được sao chép, 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Nếu không có giá trị khả thi nào, thì bạn đã đạt được điều kiện đầu tiên cho đệ quy. Hàm trả về

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Nếu có là giá trị có thể, thì bạn cần phải di chuyển trên và xem ai trong số họ là một giải pháp. Trước khi làm điều đó, bạn có thể thêm một chút tối ưu hóa vào mã. Nếu chỉ có một giá trị duy nhất có thể, thì bạn có thể thêm giá trị đó và chuyển sang vị trí tiếp theo. Giải pháp được hiển thị để thực hiện điều này trong một vòng lặp, vì vậy bạn có thể đặt nhiều số vào lưới mà không cần phải lặp lại

Điều này có vẻ như là một cải tiến nhỏ và tôi sẽ thừa nhận rằng lần phát triển đầu tiên của tôi không bao gồm điều này. Nhưng một số thử nghiệm cho thấy rằng giải pháp này nhanh hơn đáng kể so với việc chỉ lặp lại ở đây với mức giá của mã phức tạp hơn

Lưu ý. Đây là một điểm tuyệt vời để đưa ra trong cuộc phỏng vấn ngay cả khi bạn không thêm mã để thực hiện điều này. Cho họ thấy rằng bạn đang nghĩ đến việc đánh đổi tốc độ để chống lại sự phức tạp là một tín hiệu tích cực mạnh mẽ đối với những người phỏng vấn

Tất nhiên, đôi khi sẽ có nhiều giá trị có thể có cho vị trí hiện tại và bạn cần phải quyết định xem bất kỳ giá trị nào trong số đó sẽ dẫn đến giải pháp. May mắn thay, bạn đã xác định vị trí tiếp theo trong lưới, vì vậy bạn có thể bỏ qua việc đặt các giá trị có thể

Nếu vị trí tiếp theo nằm ngoài phần cuối của lưới, thì vị trí hiện tại là vị trí cuối cùng cần điền. Nếu bạn biết rằng có ít nhất một giá trị khả dĩ cho vị trí này, thì bạn đã tìm ra giải pháp. Vị trí hiện tại được điền vào và lưới đã hoàn thành được trả lại cho chức năng gọi

Nếu vị trí tiếp theo vẫn nằm trên lưới, thì bạn gõ qua từng giá trị có thể cho vị trí hiện tại, điền phỏng đoán vào vị trí hiện tại và sau đó gọi 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Nếu tất cả các phỏng đoán có thể đã được thực hiện và không có giải pháp nào trong số chúng là giải pháp, thì lưới đã được đưa vào là không thể giải thích được. Nếu đây là cuộc gọi cấp cao nhất, thì điều đó có nghĩa là câu đố không thể giải được. Nếu lệnh gọi thấp hơn trong cây đệ quy, thì điều đó có nghĩa là nhánh này của cây đệ quy không khả thi

To all they same nhau

Tại thời điểm này, bạn gần như thông qua giải pháp. Only have a left function, 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Hàm này thực hiện ba điều

1. Chuyển chuỗi đầu vào thành lưới
2. Gọi 

   # integersums.py
   def add_it_up(n):
       try:
           result = sum(range(n + 1))
       except TypeError:
           result = 0
       return result
   

   646 với lưới đó để tìm giải pháp
3. Trả về giải pháp dưới dạng một chuỗi hoặc 

   # integersums.py
   def add_it_up(n):
       try:
           result = sum(range(n + 1))
       except TypeError:
           result = 0
       return result
   

   660 nếu không có giải pháp nào

That is it. Bạn đã đi qua một giải pháp cho vấn đề bộ giải sudoku

Chủ đề thảo luận phỏng vấn

Giải pháp giải sudoku mà bạn vừa xem qua là một đoạn mã tốt cho một vấn đề phỏng vấn. Một phần của quá trình phỏng vấn có thể sẽ thảo luận về một số mã và quan trọng hơn là một số đánh đổi thiết kế mà bạn đã thực hiện. Hãy xem xét một vài trong số những đánh đổi đó

đệ quy

Quyết định thiết kế lớn nhất xoay quanh việc sử dụng đệ quy. Có thể viết một giải pháp không đệ quy cho bất kỳ vấn đề nào có một giải pháp đệ quy. Tại sao lại lựa chọn đệ quy thay vì một tùy chọn khác?

Đây là một cuộc thảo luận tranh luận không chỉ phụ thuộc vào vấn đề mà còn phụ thuộc vào các nhà phát triển liên quan đến việc viết và duy trì giải pháp. Một số vấn đề cho phép bản thân các giải pháp đệ quy khá sạch sẽ và một số thì không

Nói chung, các giải pháp đệ quy sẽ tốn nhiều thời gian hơn để chạy và sử dụng nhiều bộ nhớ hơn các giải pháp không đệ quy. Nhưng điều đó không phải lúc nào cũng đúng và quan trọng hơn, nó không phải lúc nào cũng quan trọng

Tương tự, một số nhóm nhà phát triển cảm thấy thoải mái với các giải pháp đệ quy, trong khi những người khác lại thấy họ kỳ lạ hoặc phức tạp không cần thiết. Khả năng bảo trì cũng ảnh hưởng đến quyết định thiết kế của bạn

Một cuộc thảo luận tranh luận tốt để có một quyết định như thế này là xung đột xung quanh hiệu quả. Giải pháp này cần thực hiện thi nhanh như thế nào?

Những yếu tố bên ngoài này có thể giúp bạn quyết định đâu là quyết định thiết kế tốt hơn. Đây là những chủ đề tuyệt vời để đưa ra trong một cuộc phỏng vấn khi bạn đang giải quyết một vấn đề hoặc thảo luận về mã. Một sản phẩm có thể có những nơi mà hiệu suất là quan trọng (ví dụ. thực hiện dò tia dựa trên thuật toán đồ họa) và những nơi không quan trọng (không hạn chế như phân tích cú pháp phiên bản trong khi cài đặt)

Đưa ra những chủ đề như thế này trong một cuộc phỏng vấn để thấy rằng bạn không chỉ nghĩ đến việc giải quyết một vấn đề hiện vật, mà bạn vẫn sẵn sàng và có thể đưa nó lên cấp độ tiếp theo và giải quyết một vấn đề

Khả năng đọc và khả năng bảo trì

Đôi khi, bạn nên chọn một giải pháp chậm hơn để tạo ra một giải pháp dễ làm việc hơn, khắc phục lỗi và mở rộng. Quyết định trong quá trình thử bộ giải sudoku để chuyển đổi cấu trúc dữ liệu sang dạng lưới là một trong những quyết định đó

Quyết định thiết kế rằng có thể làm chậm chương trình, nhưng trừ khi bạn đã đo lường được, bạn không biết. Ngay cả khi đúng như vậy, việc đặt cấu trúc dữ liệu vào một dạng phù hợp với vấn đề có thể làm cho mã dễ hiểu hơn

Hoàn toàn có thể viết một bộ giải hoạt động trên các chuỗi máy tính trực tuyến mà bạn được cung cấp để bắt đầu. Nó có thể nhanh hơn và có thể chiếm ít bộ nhớ hơn, nhưng

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Những bước đi sai lầm

Một điều khác cần thảo luận với người phỏng vấn, cho dù bạn đang viết mã trực tiếp hay thảo luận về mã bạn đã viết ngoại tuyến, là những sai lầm và sai lầm bạn đã thắc mắc trong quá trình thực hiện

Điều này ít rõ ràng hơn một chút và có thể hơi bất lợi, nhưng đặc biệt nếu bạn đang viết mã trực tiếp, thì việc thực hiện một bước để cấu trúc lại mã không đúng hoặc có thể tốt hơn là bạn có thể thấy mình đang làm . Thành viên ít lập trình có thể viết mã hoàn hảo ngay lần đầu tiên. Ít lập trình viên có thể viết mã tốt ngay lần đầu tiên

Các nhà phát triển viết mã giỏi, sau đó quay lại cấu trúc lại và chỉnh sửa nó. Ví dụ. lần phát triển đầu tiên của tôi 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

Bỏ qua rằng nó không xem xét 

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

# integersums.py
def add_it_up(n):
    try:
        result = sum(range(n + 1))
    except TypeError:
        result = 0
    return result

end

Đó là chuyến tham quan của bạn thông qua giải pháp giải sudoku. Có thêm thông tin về các định dạng để lưu trữ các câu đố và một danh sách về các câu đố sudoku mà bạn có thể kiểm tra thuật toán của mình

Đó là phần cuối của cuộc phụ lưu các vấn đề thực thi Python của bạn

Phần kết luận

Chúc mừng bạn đã làm việc thông qua tập hợp các vấn đề thực thi Python này. Bạn đã có một số hành động áp dụng các kỹ năng Python của mình và cũng đã dành thời gian suy nghĩ về cách bạn có thể trả lời trong các vấn đề phỏng vấn khác nhau.

Trong hướng dẫn này, bạn đã học cách

• Viết mã cho các kiểu phỏng vấn vấn đề
• Thảo luận về các giải pháp của bạn trong cuộc phỏng vấn
• Làm việc qua các chi tiết thường bị bỏ qua
• Nói về các quyết định thiết kế và sự đánh đổi

Hãy nhớ rằng, bạn có thể tải xuống mã khung cho những sự cố này bằng cách nhấp vào liên kết bên dưới

Vui lòng liên hệ trong phần nhận xét nếu bạn có bất kỳ câu hỏi nào hoặc đề xuất cho các vấn đề thực thi Python khác mà bạn muốn xem. Ngoài ra, hãy xem Lộ trình học tập “Phỏng vấn viết mã bằng Python của bạn” của chúng tôi để nhận thêm tài nguyên và nâng cao kỹ năng phỏng vấn Python của bạn