Hướng dẫn how do you write a trapezoidal rule in python? - làm thế nào để bạn viết một quy tắc hình thang trong python?

Question

Chương trình này thực hiện quy tắc hình thang để tìm giá trị xấp xỉ của tích hợp số trong ngôn ngữ lập trình Python.

Trong chương trình Python này,

Enter lower limit of integration: 0
Enter upper limit of integration: 1
Enter number of sub intervals: 6
Integration result by Trapezoidal method is: 0.784241

4 và

Enter lower limit of integration: 0
Enter upper limit of integration: 1
Enter number of sub intervals: 6
Integration result by Trapezoidal method is: 0.784241

5 là giới hạn tích hợp thấp hơn và trên,

Enter lower limit of integration: 0
Enter upper limit of integration: 1
Enter number of sub intervals: 6
Integration result by Trapezoidal method is: 0.784241

6 là số khoảng thời gian phụ và chức năng

Enter lower limit of integration: 0
Enter upper limit of integration: 1
Enter number of sub intervals: 6
Integration result by Trapezoidal method is: 0.784241

7 được tích hợp bằng phương pháp hình thang được xác định bằng định nghĩa chức năng python

Enter lower limit of integration: 0
Enter upper limit of integration: 1
Enter number of sub intervals: 6
Integration result by Trapezoidal method is: 0.784241

8.Trapezoidal method is defined using python function definition

Enter lower limit of integration: 0
Enter upper limit of integration: 1
Enter number of sub intervals: 6
Integration result by Trapezoidal method is: 0.784241

8.

Nội dung chính Show

Mã nguồn Python: Quy tắc hình thang
Quy tắc hình thang - một bản tóm tắt
Tôi cần gì để thực hiện quy tắc hình thang?
Thiết lập môi trường và các công cụ
Một triển khai Python thuần túy
Tạo mảng mẫu đầu vào
Tạo các mẫu đầu ra
Nhận kết quả cuối cùng
Một triển khai ngây thơ
Một quy tắc hình thang thậm chí nhỏ hơn thực hiện
Điểm chuẩn các triển khai khác nhau của Quy tắc hình thang
Làm thế nào để bạn làm quy tắc hình thang trong Python?
Làm thế nào để bạn sử dụng công thức hình thang?

Mã nguồn Python: Quy tắc hình thang


# Trapezoidal Method

# Define function to integrate
def f(x):
    return 1/(1 + x**2)

# Implementing trapezoidal method
def trapezoidal(x0,xn,n):
    # calculating step size
    h = (xn - x0) / n
    
    # Finding sum 
    integration = f(x0) + f(xn)
    
    for i in range(1,n):
        k = x0 + i*h
        integration = integration + 2 * f(k)
    
    # Finding final integration value
    integration = integration * h/2
    
    return integration
    
# Input section
lower_limit = float(input("Enter lower limit of integration: "))
upper_limit = float(input("Enter upper limit of integration: "))
sub_interval = int(input("Enter number of sub intervals: "))

# Call trapezoidal() method and get result
result = trapezoidal(lower_limit, upper_limit, sub_interval)
print("Integration result by Trapezoidal method is: %0.6f" % (result) )

Đầu ra

Đầu ra của phương pháp hình thang trên chương trình Python là:Trapezoidal method Python program is:

Enter lower limit of integration: 0
Enter upper limit of integration: 1
Enter number of sub intervals: 6
Integration result by Trapezoidal method is: 0.784241

Bạn bị tắt bởi một yếu tố của hai. Thật vậy, quy tắc hình thang như được dạy trong lớp toán sẽ sử dụng một sự gia tăng như

s += h * (f(a + i*h) + f(a + (i-1)*h))/2.0

Enter lower limit of integration: 0
Enter upper limit of integration: 1
Enter number of sub intervals: 6
Integration result by Trapezoidal method is: 0.784241

9 đang trung bình chiều cao của hàm tại hai điểm liền kề trên lưới.

Vì mỗi hai hình thang liền kề có một cạnh chung, công thức trên yêu cầu đánh giá chức năng gấp đôi thường xuyên khi cần thiết.

Một triển khai hiệu quả hơn (gần với những gì bạn đã đăng), sẽ kết hợp các thuật ngữ phổ biến từ các lần lặp liền kề của

s += h * (f(a + i*h) + f(a + (i-1)*h))/2.0

0:

f(a + i*h)/2.0 + f(a + i*h)/2.0 =  f(a + i*h)

để đi đến:

def trapezoidal(f, a, b, n):
    h = float(b - a) / n
    s = 0.0
    s += f(a)/2.0
    for i in range(1, n):
        s += f(a + i*h)
    s += f(b)/2.0
    return s * h

print( trapezoidal(lambda x:x**2, 5, 10, 100))

mang lại sản lượng

291.66875

Quy tắc hình thang là một phần của hầu hết các giáo trình khóa học liên quan đến toán học ngoài kia. Cho dù bạn đang nghiên cứu kỹ thuật, khoa học máy tính hay toán học thuần túy, bạn sẽ bắt gặp quy tắc hình thang (hoặc hình thang). Trong bài đăng này, chúng tôi sẽ học cách sử dụng Python để thực hiện và tự động hóa quy tắc hình thang!

Quy tắc hình thang - một bản tóm tắt

Quy tắc hình thang rất hữu ích nếu bạn cần ước tính khu vực dưới một đường cong cho một tập hợp các đầu vào và mẫu cho một hàm.

Thật thú vị, bạn không nhất thiết phải biết công thức của hàm. Tuy nhiên, bạn phải biết các đầu ra của hàm được lấy mẫu theo các khoảng thời gian đều đặn (chiều cao của hình thang).

Nếu bạn không quen thuộc hoặc không hoàn toàn hiểu quy tắc hình thang, hãy đọc bài viết trước của tôi về cách hiểu quy tắc hình thang. Nó đã giành chiến thắng mất nhiều thời gian và nó sẽ giúp bạn hiểu logic đằng sau quy tắc này!

Tôi cần gì để thực hiện quy tắc hình thang?

Trong bài đăng này, chúng tôi sẽ sử dụng Python để thực hiện quy tắc hình thang. Ngoài ra, sẽ thực hiện nó theo một vài cách khác nhau và so sánh mức độ hiệu quả của mỗi lần thực hiện.

Đối với mục đích của bài đăng này, tôi khuyên bạn nên cài đặt miniconda với phiên bản Python mới nhất có sẵn nếu bạn chưa có nó. Miniconda là một người quản lý môi trường Python cho phép bạn dễ dàng có các cài đặt Python khác nhau và các thư viện khác nhau.

Hướng dẫn how do you write a trapezoidal rule in python? - làm thế nào để bạn viết một quy tắc hình thang trong python?

Hình 1: Lời nhắc Anaconda trong thanh tìm kiếm Windows.

Thiết lập môi trường và các công cụ

Khi bạn đã cài đặt miniconda trong hệ thống của mình, bạn cần mở dòng lệnh nhắc nhở của Anaconda và tạo môi trường cho thử nghiệm của chúng tôi trong bài đăng này. Chỉ cần nhập các lệnh sau trong lời nhắc của Anaconda nhắc nhở:

conda create --name maths python=3.9
conda activate maths
conda install numpy

Để nhanh chóng giải thích các lệnh trên:

Dòng 1 tạo ra một môi trường Python mới có tên là Math Maths với Python 3.9. Rõ ràng, nếu có các phiên bản Python mới hơn vào thời điểm bạn đọc nó, hãy thoải mái thay đổi phiên bản.
```
s += h * (f(a + i*h) + f(a + (i-1)*h))/2.0
```
1 tải lên môi trường chúng tôi vừa tạo. Khi được kích hoạt, mọi công cụ hoặc thư viện chúng tôi cài đặt sẽ được thêm vào môi trường của Math Maths.
```
s += h * (f(a + i*h) + f(a + (i-1)*h))/2.0
```
2 sẽ nhận và cài đặt các thư viện/công cụ được chỉ định vào môi trường được kích hoạt. Trong trường hợp của chúng tôi, chúng tôi cần
```
s += h * (f(a + i*h) + f(a + (i-1)*h))/2.0
```
3L Library cho toán học.

Hy vọng rằng, tất cả các lệnh hoạt động tốt và bạn đã thiết lập tất cả! Nếu không, hãy bỏ một bình luận với các lỗi bạn có và tôi sẽ cố gắng giúp bạn.

Một triển khai Python thuần túy

Trong phần này, chúng tôi sẽ thực hiện quy tắc hình thang chỉ với Python và thư viện tiêu chuẩn của nó. Mặc dù đây sẽ là triển khai ít hiệu quả nhất, nhưng ít nhất là so với các đối tác Numpy, nhưng nó cung cấp một cái nhìn sâu sắc hơn về cách các loại thuật toán này được thực hiện. Vì vậy, tôi sẽ khuyên bạn nên gõ giải pháp này và hiểu các kỹ thuật được sử dụng ở đây!

Tạo mảng mẫu đầu vào

Để bắt đầu, chúng ta cần tạo một loạt các đầu ra cho chức năng mà chúng ta muốn ước tính khu vực với quy tắc hình thang. Để tóm tắt nhanh, nếu chúng ta muốn ước tính khu vực có N hình thang trong khoảng [A, B], thì chúng ta cần đầu ra cách nhau n+1.N trapeziums in the interval [a,b], then we need N+1 equally spaced outputs.

Hình 2: Mỗi đầu ra của hàm được phân tách bằng chiều cao của hình thang H hoặc DX.h, or dx.

Vì vậy, hãy để bắt đầu với việc tạo các đầu vào mẫu (các giá trị x).x values).

def get_input_samples(first_x, last_x, N):

    # Height of the trapeziums, or dx
    h = (last_x - first_x) / N
    return [first_x + i*h for i in range(N+1)]

Với các đầu vào đầu tiên và cuối cùng, A và B, hàm trên sẽ trả về danh sách các mẫu N+1 được đặt ngang bằng nhau bởi chiều cao của mỗi tam giác, H hoặc DX. Hơn nữa, phần tử đầu tiên sẽ là A và cuối cùng sẽ là b. Bạn có thể giải quyết nó về mặt toán học nếu bạn muốn.a and b, the function above will return a list of N+1 samples equally spaced by the height of each triangle, h or dx. Furthermore, the first element will be a and the last will be b. You can work it out mathematically if you want.

Tạo các mẫu đầu ra

Khi các đầu vào cách đều nhau được tính toán, việc có được mảng đầu ra là dễ dàng, như được hiển thị trong mã bên dưới.

def apply(f, inputs):
     """
     This will apply the function f on each
     elements of inputs.
     """
     return [f(x) for x in inputs]

Thật thú vị, hàm trên được gọi là

s += h * (f(a + i*h) + f(a + (i-1)*h))/2.0

4 vì nó áp dụng hàm

s += h * (f(a + i*h) + f(a + (i-1)*h))/2.0

5 cho mỗi phần tử trong danh sách

s += h * (f(a + i*h) + f(a + (i-1)*h))/2.0

6.

Phải thừa nhận rằng, mã này có thể khá lạ đối với người mới bắt đầu vì chúng tôi đang chuyển một chức năng như một đầu vào cho một chức năng khác, nhưng đó là một tính năng khá tốt của Python. Vì vậy, khi chúng tôi nói rằng chúng tôi áp dụng chức năng của mỗi đầu vào, điều đó chỉ đơn giản là chúng tôi gọi hàm đầu vào đó với từng phần tử của

s += h * (f(a + i*h) + f(a + (i-1)*h))/2.0

6List là một tham số.

Ví dụ, giả sử chúng tôi có danh sách các đầu vào

s += h * (f(a + i*h) + f(a + (i-1)*h))/2.0

8, thì nếu chúng tôi gọi

s += h * (f(a + i*h) + f(a + (i-1)*h))/2.0

9 sẽ trả về

f(a + i*h)/2.0 + f(a + i*h)/2.0 =  f(a + i*h)

0.

Nhận kết quả cuối cùng

Đặt hai và hai lại với nhau, giờ đây chúng ta có thể sử dụng các chức năng mà chúng tôi đã thực hiện để có được kết quả quy tắc hình thang cho một mảng các mẫu.

Để tóm tắt lại từ bài viết về việc giải thích quy tắc hình thang, đưa ra một tập hợp các mẫu cách đều nhau cho một hàm, quy tắc hình thang cho chúng ta biết như sau:

\int_{a}^{b}  f(x) dx \approx \frac{h}{2} \{f(a) + f(b) + 2[f(a+h)  +\cdots+f(a+(n-1)h)]\}

Hàm sau đây chỉ có điều đó: Nó lấy một mảng các mẫu và chiều cao của hình thang (chiều rộng của mỗi mẫu) và trả về ước tính tích hợp bằng quy tắc hình thang.

Enter lower limit of integration: 0
Enter upper limit of integration: 1
Enter number of sub intervals: 6
Integration result by Trapezoidal method is: 0.784241

0

Nếu bạn chỉ đơn giản muốn ước tính đạo hàm của một hàm giữa hai điểm, chúng ta có thể xác định một hàm để thực hiện điều đó với quy tắc hình thang:

Enter lower limit of integration: 0
Enter upper limit of integration: 1
Enter number of sub intervals: 6
Integration result by Trapezoidal method is: 0.784241

1

Vì vậy, được đưa ra một đối tượng giống như hàm

f(a + i*h)/2.0 + f(a + i*h)/2.0 =  f(a + i*h)

1 (như lambdas), các điểm mẫu đầu tiên và cuối cùng (

f(a + i*h)/2.0 + f(a + i*h)/2.0 =  f(a + i*h)

2 và

f(a + i*h)/2.0 + f(a + i*h)/2.0 =  f(a + i*h)

3) và số lượng hình thang

f(a + i*h)/2.0 + f(a + i*h)/2.0 =  f(a + i*h)

4,

f(a + i*h)/2.0 + f(a + i*h)/2.0 =  f(a + i*h)

5 sẽ trả về ước tính bằng cách sử dụng quy tắc hình thang. Voilà!

Ví dụ,

f(a + i*h)/2.0 + f(a + i*h)/2.0 =  f(a + i*h)

6 trả về ước tính đáng kinh ngạc là 1.7724538509055154. Hy vọng, bạn có thể thấy ước tính này tốt như thế nào nếu bạn biết bất cứ điều gì về tích phân của \ int _ {-\ infty}^{\ infy} e^{-x^{2}} dx.\int_{-\infty}^{\infty} e^{-x^{2}} dx.

Một triển khai ngây thơ

Bất kỳ học giả hoặc nhà khoa học dữ liệu nào cũng sẽ đặt câu hỏi về việc triển khai Python Pure Pure, và tự hỏi tại sao chúng tôi không sử dụng Numpy, một thư viện được xây dựng cho toán học nặng.

Cắt theo đuổi, chúng ta có thể sử dụng các mảng và chức năng Numpy để tạo ra việc triển khai nhanh hơn chức năng

f(a + i*h)/2.0 + f(a + i*h)/2.0 =  f(a + i*h)

5:

Enter lower limit of integration: 0
Enter upper limit of integration: 1
Enter number of sub intervals: 6
Integration result by Trapezoidal method is: 0.784241

2

Thật thú vị, hàm trên không giống như

f(a + i*h)/2.0 + f(a + i*h)/2.0 =  f(a + i*h)

5, nhưng nó sử dụng Numpy để tạo các mảng đầu vào và đầu ra. Lưu ý rằng hàm đầu vào

f(a + i*h)/2.0 + f(a + i*h)/2.0 =  f(a + i*h)

1 cần xử lý toàn bộ đầu vào mảng numpy! Vì vậy, hãy gắn bó với các chức năng numpy.

Cuối cùng, để tính toán tích phân tương tự như triển khai Python Pure Pure Python sẽ là

def trapezoidal(f, a, b, n):
    h = float(b - a) / n
    s = 0.0
    s += f(a)/2.0
    for i in range(1, n):
        s += f(a + i*h)
    s += f(b)/2.0
    return s * h

print( trapezoidal(lambda x:x**2, 5, 10, 100))

0. Lưu ý cách hàm đầu vào sử dụng

def trapezoidal(f, a, b, n):
    h = float(b - a) / n
    s = 0.0
    s += f(a)/2.0
    for i in range(1, n):
        s += f(a + i*h)
    s += f(b)/2.0
    return s * h

print( trapezoidal(lambda x:x**2, 5, 10, 100))

1, xử lý toàn bộ mảng numpy cùng một lúc, làm cho nó hiệu quả hơn. Không cần phải nói, nó trả về ước tính tương tự.

Một quy tắc hình thang thậm chí nhỏ hơn thực hiện

Bạn có tin rằng chúng ta có thể thực hiện tất cả các triển khai trên chỉ trong ba dòng mã không? Do Numpy cung cấp cho chúng tôi chức năng

def trapezoidal(f, a, b, n):
    h = float(b - a) / n
    s = 0.0
    s += f(a)/2.0
    for i in range(1, n):
        s += f(a + i*h)
    s += f(b)/2.0
    return s * h

print( trapezoidal(lambda x:x**2, 5, 10, 100))

2, chúng tôi có thể trực tiếp dựa vào Numpy để áp dụng quy tắc hình thang trên một tập hợp các mẫu! Mã dưới đây cho thấy cách.

Enter lower limit of integration: 0
Enter upper limit of integration: 1
Enter number of sub intervals: 6
Integration result by Trapezoidal method is: 0.784241

3

def trapezoidal(f, a, b, n):
    h = float(b - a) / n
    s = 0.0
    s += f(a)/2.0
    for i in range(1, n):
        s += f(a + i*h)
    s += f(b)/2.0
    return s * h

print( trapezoidal(lambda x:x**2, 5, 10, 100))

3 sẽ sử dụng việc thực hiện chính quy tắc hình thang của Numpy. Tuy nhiên, vì nó được thực hiện trong mã gốc, với các thói quen được tối ưu hóa cao, nó sẽ hút các phương pháp khác được thể hiện trong bài đăng này về hiệu quả!

Rõ ràng,

def trapezoidal(f, a, b, n):
    h = float(b - a) / n
    s = 0.0
    s += f(a)/2.0
    for i in range(1, n):
        s += f(a + i*h)
    s += f(b)/2.0
    return s * h

print( trapezoidal(lambda x:x**2, 5, 10, 100))

4 sẽ trả về ước tính giống như những người khác.

Điểm chuẩn các triển khai khác nhau của Quy tắc hình thang

Khi tôi tò mò về việc biết các triển khai Numpy đã tốt hơn bao nhiêu từ các Python Pure Python, tôi quyết định đánh giá tất cả các chức năng quy tắc hình thang mà chúng tôi đã tạo trong bài đăng này. Ngoài ra, tất cả chúng đều ước tính tích phân cho cùng một hàm, cụ thể là f (x) = e^{-x^{2}}. Tuy nhiên, tôi đã thay đổi các điểm đầu vào đầu tiên và cuối cùng (giới hạn tích phân

f(a + i*h)/2.0 + f(a + i*h)/2.0 =  f(a + i*h)

2,

f(a + i*h)/2.0 + f(a + i*h)/2.0 =  f(a + i*h)

3) và số lượng hình thang

f(a + i*h)/2.0 + f(a + i*h)/2.0 =  f(a + i*h)

4.f(x) = e^{-x^{2}}. However, I’ve changed the first and last input points (the integral bounds

f(a + i*h)/2.0 + f(a + i*h)/2.0 =  f(a + i*h)

2,

f(a + i*h)/2.0 + f(a + i*h)/2.0 =  f(a + i*h)

3), and the number of trapeziums

f(a + i*h)/2.0 + f(a + i*h)/2.0 =  f(a + i*h)

4.

Đầu vào {a, b, n}	`def trapezoidal(f, a, b, n): h = float(b - a) / n s = 0.0 s += f(a)/2.0 for i in range(1, n): s += f(a + ih) s += f(b)/2.0 return s h print( trapezoidal(lambda x:x**2, 5, 10, 100))` 8 Python thuần túy	`def trapezoidal(f, a, b, n): h = float(b - a) / n s = 0.0 s += f(a)/2.0 for i in range(1, n): s += f(a + ih) s += f(b)/2.0 return s h print( trapezoidal(lambda x:x**2, 5, 10, 100))` 9naive numpy Naive Numpy	`291.66875` 0numpy tất cả các cách Numpy all the way
`291.66875` 1	50,4 Pha	38,6 Pha	48,8 Pha
`291.66875` 2	507 Pha	46 Pha	58,7 Pha
`291.66875` 3	4,89 ms	113 Pha	140 Pha
`291.66875` 4	9,93 ms	188 Pha	229 Pha
`291.66875` 5	26,1 ms	928 Pha	1,03 ms

Điểm chuẩn của ba triển khai quy tắc hình thang: Python, Naive Numpy và

291.66875

6.

Không có gì đáng ngạc nhiên, việc triển khai Python Pure Pure Python rất chậm so với các đối tác vô cùng. Trong trường hợp số lượng hình thang lớn, chúng ta thấy sự chậm lại 20 lần.

Vì vậy, không có gì bất ngờ theo nghĩa đó. Tuy nhiên, tôi đã giả định sai rằng chức năng

291.66875

7 sẽ nhanh hơn so với bộ mở rộng ngây thơ của chúng tôi. Như chúng ta có thể thấy, cả hai chức năng gần như đã đi đến ngón chân về hiệu quả, nhưng

291.66875

7 không thua đối tác Numpy ngây thơ một chút trong mỗi kịch bản. Tôi thậm chí gấp đôi ba lần kiểm tra nó!

Đi để cho bạn thấy: Điểm chuẩn của bạn trước khi đưa ra bất kỳ giả định nào!

TL;DR

Chúng tôi đã thấy trong bài viết này dễ dàng như thế nào khi thực hiện quy tắc hình thang hoàn toàn trong Python.

Hơn nữa, nhiệm vụ này thậm chí còn trở nên dễ dàng hơn (và hiệu quả hơn) khi sử dụng thư viện số như Numpy.

Điểm chuẩn cho chúng ta thấy rằng, trong trường hợp xấu nhất, việc triển khai Python Pure Pure đã thực hiện tồi tệ hơn hai mươi lần so với việc triển khai Numpy. Ngoài ra, họ cũng cho chúng ta thấy rằng một Numpy ngây thơ, thực hiện quy tắc hình thang với các mảng và chức năng numpy trong các dòng Python, đã thực sự hoạt động tốt hơn chức năng ____57 của Numpy (một chút).

Tôi có nghĩ rằng việc thực hiện Python Pure Pure là vô ích không? Không, hoàn toàn ngược lại. Biết cách sử dụng Python để thực hiện các phương pháp toán học là hữu ích; Nó cung cấp cho bạn một cái nhìn sâu sắc về những gì mọi người phải làm khi viết cùng một thứ bằng các ngôn ngữ khác. Nó sẽ làm tôi ngạc nhiên nếu Numpy thực sự thực hiện cùng một công thức trong mã gốc (C/C ++), với một số tối ưu hóa.

Trên thực tế, nó chắc chắn hữu ích khi biết làm thế nào một cái gì đó được thực hiện. Nó giúp bạn hiểu một khái niệm tốt hơn!

Tôi đã bỏ lỡ bất cứ điều gì? Phát hiện ra bất kỳ sai lầm trong văn bản hoặc mã? Bạn có câu hỏi nào không? Vui lòng đăng một bình luận bên dưới và tôi sẽ cố gắng hết sức để trả lời càng sớm càng tốt!

Làm thế nào để bạn làm quy tắc hình thang trong Python?

Quy tắc hình thang được thực hiện trong một hàm Python riêng biệt lấy hàm toán học chung \ (f (x) \) làm đối số, cùng với dữ liệu đầu vào cho vấn đề: giới hạn tích hợp \ (a \) và \ (b \) vàtham số độ phân giải số \ (n \).

Làm thế nào để bạn sử dụng công thức hình thang?

Làm thế nào để áp dụng quy tắc hình thang ?..

Bước 1: Lưu ý số lượng các giao dịch phụ, "N" và các khoảng "A" và "B" ..

Bước 2: Áp dụng công thức để tính toán chiều rộng khoảng thời gian phụ, h (hoặc) △ x = (b - a)/n ..

Bước 3: Thay thế các giá trị thu được trong công thức quy tắc hình thang để tìm diện tích gần đúng của đường cong đã cho,.

programming python Trapezoidal rule Java Trapezoidal rule code Integral Python Trapezoidal rule formula

Hướng dẫn how do you write a trapezoidal rule in python? - làm thế nào để bạn viết một quy tắc hình thang trong python?

Chương trình này thực hiện quy tắc hình thang để tìm giá trị xấp xỉ của tích hợp số trong ngôn ngữ lập trình Python.

Mã nguồn Python: Quy tắc hình thang

Đầu ra

Quy tắc hình thang - một bản tóm tắt

Tôi cần gì để thực hiện quy tắc hình thang?

Thiết lập môi trường và các công cụ

Một triển khai Python thuần túy

Tạo mảng mẫu đầu vào

Tạo các mẫu đầu ra

Nhận kết quả cuối cùng

Một triển khai ngây thơ

Một quy tắc hình thang thậm chí nhỏ hơn thực hiện

Điểm chuẩn các triển khai khác nhau của Quy tắc hình thang

TL;DR

Làm thế nào để bạn làm quy tắc hình thang trong Python?

Làm thế nào để bạn sử dụng công thức hình thang?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội