Cách sáng tạo của người Viking để xác định xem một mảng có được sắp xếp không


51

Cho một mảng số nguyên, viết chương trình xác định xem nó có được sắp xếp theo thứ tự tăng dần không.

Hãy nhớ rằng đây là một câu hỏi trolling mã.

Tôi đang tìm kiếm những cách thú vị nhất mà mọi người nghĩ ra.

Câu trả lời với hầu hết các chiến thắng.

Câu hỏi này được lấy cảm hứng từ một giải pháp 'sáng tạo' mà một ứng viên đã cho tôi trong một cuộc phỏng vấn :)


Giải pháp 'sáng tạo' là như thế này:

  • Bởi vì đối với một mảng được sắp xếp

    • tất cả các phần tử ở bên trái của bất kỳ phần tử nào phải nhỏ hơn
    • tất cả các yếu tố ở phía bên phải của bất kỳ yếu tố nào phải lớn hơn

Do đó, hãy chạy một vòng lặp chính cho tất cả các yếu tố và kiểm tra hai điều kiện trên bằng cách chạy hai vòng lặp lồng bên trong vòng lặp chính (một cho bên trái và một cho bên phải)

Tôi đã bị sốc!!.


58
Đây không phải là một bản sao. Một số người điều hành cảm thấy cần phải đánh dấu mọi câu hỏi trùng lặp với người khác mà không cần đọc nó. Đây không phải là một câu hỏi sắp xếp nào cả. Đọc nó.
microbian

3
Vào cuối cuộc thi, tôi cũng muốn biết giải pháp "sáng tạo"! :)
Vereos

16
Người điều hành @micro Diamond là cộng đồng được bầu. Bạn đang nhầm lẫn người điều hành với hệ thống đặc quyền.
Doorknob

3
@microbian Vậy bạn đã thuê anh chàng đó chưa?
VisioN

3
Nếu chỉ API StackExchange cho phép truy cập ghi, tôi sẽ đặt câu hỏi "Mảng này có được sắp xếp không?" và đếm số người ủng hộ cho câu trả lời tích cực / tiêu cực ..
Michael Foukarakis

Câu trả lời:


77

Hồng ngọc

Mọi người đều biết: sắp xếp rất chậm và mất nhiều chu kỳ (điều tốt nhất bạn có thể làm là một cái gì đó với n log(n)). Do đó, khá dễ dàng để kiểm tra nếu mảng được sắp xếp. Tất cả bạn phải làm là so sánh thời gian chạy sắp xếp mảng và sắp xếp mảng đã sắp xếp.

array = [1, 5, 4, 2, 3]

## measure the time needed to sort the array 1m times
tstart = Time.now
1000000.times {
  array.sort
}
trun = Time.now - tstart

## now do a reference measurement on a sorted array
array.sort!
tstart = Time.now
1000000.times {
  array.sort
}
treference = Time.now - tstart

## compare run times
if trun > treference
  print "array was not sorted"
else
  print "array was sorted"
end

19
Điều này phụ thuộc vào thuật toán sắp xếp mặc dù. Hợp nhất sắp xếp hoặc sắp xếp heap sẽ không hiển thị bất kỳ sự khác biệt nào, độc lập với việc mảng đã được sắp xếp hay chưa.
Niklas B.

4
@NiklasB. Ruby sử dụng quicksort . Điều đó nói rằng phương pháp này có thể gặp khó khăn và đưa ra kết quả dương tính khi mảng đầu vào gần như được sắp xếp, hoặc, nhiều khả năng là phủ định sai khi mảng được sắp xếp (sẽ rất khó xảy ra đối treference <= trunvới mọi trường hợp được sắp xếp, chỉ do các công cụ khác không xác định) . Về lý thuyết, có vẻ như bạn nhận được khoảng 50% âm tính giả cho trường hợp được sắp xếp?
Jason C

6
Suy nghĩ thú vị nhưng không mang tính quyết định. Nó tốt như một người có thể thực hiện mười lần đẩy và sau đó thêm mười lần đẩy và sau đó quyết định xem mảng đầu tiên có được sắp xếp hay không bởi vì người ta đổ mồ hôi nhiều hơn vào lần đẩy thứ hai. Có phải chúng ta đã quên, chúng ta chạy mã trên các máy đa tác vụ? Ngoài ra trên các mảng rất nhỏ, lát cắt thời gian đơn giản là không đủ chính xác. +1 cho một nỗ lực hoang dã!
LMSingh

1
@NiklasB. Timsort (một biến thể của sự hợp nhất) chạy trong thời gian tuyến tính trên các mảng được sắp xếp (và cũng được sắp xếp một phần).
Bakuriu

3
@JasonC - điều đáng chú ý là điều này làm cho việc triển khai ở trên trở nên đáng ngờ hơn: nó không chỉ dựa vào kiến ​​thức mà thuật toán sắp xếp nội bộ của ruby ​​là quicksort (mà bản thân nó không được ghi nhận và do đó là một điều đáng ngờ để dựa vào) được tối ưu hóa cho trường hợp dữ liệu đã được sắp xếp (mặc định quicksort không phải là: quicksort chỉ là O (n log n) trong trường hợp trung bình ... hiệu suất trong trường hợp xấu nhất của nó là O (n ^ 2) và trong một triển khai ngây thơ rằng trường hợp xấu nhất thực sự đang được gọi trên dữ liệu đã được sắp xếp).
Jules

52

Javascript

array = prompt("Give the array");
while (true) {
    sorted = prompt("Is it sorted?");
    if (/yes|Yes/.test(sorted)) {
        alert("The array is sorted.");
        break;
    } else if (/no|No/.test(sorted)) {
        alert("The array is not sorted.");
        break;
    } else {
        alert("Dear user:\n\nPlease refer to the manual (RTFM) to observe how to use the system accordingly to the defined business rules.\nNow, try again.");
    }
}

55
-1 không đủ JQuery.
Pierre Arlaud

3
Tôi đã có một ý tưởng tương tự sẽ yêu cầu mảng, và sau đó từng câu một "có lớn hơn cái này không?" Và nếu tất cả đều đúng, thì mảng được sắp xếp
Zach Thacker

41

Java - Các tập con đệ quy

Chào mừng bạn đến với Stack Overflow! Đây là một câu hỏi đầu tiên tuyệt vời, vì nó đánh bại ngay cả một số lập trình viên kỳ cựu. Hãy để tôi cung cấp cho bạn một chút thông tin cơ bản trước khi tôi đưa ra mã:

Xác định sự sắp xếp có thể là một nhiệm vụ khó khăn thoạt nhìn. Đối với bất kỳ tập hợp độ dài n, có n! cách có thể để đặt hàng nó. Chúng được gọi là hoán vị . Nếu mảng của bạn có các phần tử riêng biệt, chỉ một trong những khả năng đó được sắp xếp! Để tìm cái đã được sắp xếp, bạn phải chọn lọc tất cả chúng cho đến khi bạn tìm đúng (chỉ có thể) một cái, loại bỏ tất cả những cái khác.

Gì? Chắc chắn nó không phải là điều đó khó khăn ...

Thuật toán với n! sự phức tạp mất nhiều thời gian cho các đầu vào lớn hơn, nhưng với một chút công việc chúng ta có thể khắc phục điều đó, và chuyển xuống toàn bộ trật tự phức tạp. Đó vẫn là thời gian theo cấp số nhân, nhưng nó tốt hơn nhiều so với giai thừa.

Để làm điều này, chúng ta chỉ cần xem xét thực tế toán học sau: Nếu một mảng được sắp xếp, thì mỗi một tập hợp con (tương đối có thứ tự) của nó cũng được sắp xếp. Bạn có thể hỏi các chuyên gia về Toán học để có bằng chứng chính thức, nhưng điều đó là trực giác. Ví dụ, đối với tập hợp 123, các tập hợp con là 1 2 3 12 13 23. Bạn có thể thấy tất cả chúng được ra lệnh. Bây giờ nếu là bản gốc 213, bạn sẽ có 2 1 3 21 23 13, và ngay lập tức bạn có thể thấy điều đó 21không đúng.

Lý do điều này rất quan trọng là vì có ít hơn n! tập hợp con. Trong thực tế, chỉ có 2 n -2 tập con chúng ta cần xem xét. Chúng ta có thể loại trừ tập hợp chứa toàn bộ mảng số gốc, cũng như tập hợp trống.

Tuy nhiên, 2 n -2 có thể là rất nhiều công việc. Như với hầu hết mọi thứ vượt quá thời gian đa thức, một cách tiếp cận phân chia và chinh phục hoạt động tốt ở đây. Cách tiếp cận đơn giản nhất? Đệ quy !

Các bước cơ bản là đơn giản. Đối với mỗi tập hợp con của đầu vào của bạn, bạn tạo các tập con nhỏ hơn . Sau đó, đối với mỗi người, bạn làm điều tương tự. Khi các tập con của bạn giảm xuống kích thước 2, bạn chỉ cần kiểm tra xem tập nào lớn hơn. Vì bạn thu nhỏ kích thước của các tập hợp con mỗi lần, nó thực sự diễn ra nhanh hơn bạn mong đợi.

Thực tế quan trọng ở đây là bạn có thể thoát khỏi đầu , ngay sau khi bạn tìm thấy một đơn tập hợp con ra khỏi trật tự. Bạn không cần phải tìm kiếm tất cả. Nếu một người xấu, cả nhóm xấu. Đây là một sự cân nhắc tốc độ mà bạn không thấy trong rất nhiều câu trả lời khác.

Nói đủ rồi, hãy có mã!

Tôi đã thực hiện điều này trong Java vì đây là ngôn ngữ phổ biến và dễ đọc. Sự thanh lịch của đệ quy nên rõ ràng:

import java.util.ArrayList;

public class SortChecker {

    static final Integer[] input = {1, 2, 3, 4, 5};

    public static void main(String[] args) {
        if(isSorted(input))
            System.out.println("The array is sorted properly.");
        else
            System.out.println("The array was not sorted properly.");
    }

    public static boolean isSorted(Integer[] in){
        if(in.length == 1)
            return true;
        if(in.length == 2)
            return (in[0] <= in[1]);
        ArrayList<Integer[]> subsets = getSubsets(in);
        for(Integer[] next : subsets){
            if(!isSorted(next))
                return false;
        }
        return true;
    }

    public static ArrayList<Integer[]> getSubsets(Integer[] in){
        ArrayList<Integer[]> subsets = new ArrayList<Integer[]>();
        int bitmasks = (1 << in.length) - 1;
        for (int i = 1; i < bitmasks; i++){
            ArrayList<Integer> subset = new ArrayList<Integer>(); 
            for (int j = 0; j < in.length; j++)
                if ((i & (1 << j)) > 0) 
                    subset.add(in[j]);          
            subsets.add(subset.toArray(new Integer[1]));
        }
        return subsets;
    }
}

Đối với hồ sơ, tôi đã chán và giết nó sau khi chờ 15 phút cho một mảng 12 phần tử được sắp xếp. Nó sẽ thực hiện 11 yếu tố trong khoảng 45 giây. Tất nhiên, nó thực sự không lối ra trước đó cho người không được sắp xếp, do đó nhân, um, tốt.

Cập nhật: Khi khởi động lại mới, nó thực hiện 12 yếu tố trong 13 phút. 13 mất gần 3 giờ, và 14 là 20 giờ và đếm.


8
+1 đây có lẽ là thuật toán kém hiệu quả nhất tôi từng thấy. Nên ở khoảng O (n! * 2 ^ (n!)) - Độ phức tạp (có thể tệ hơn).
Ral Zarek

6
Tôi chắc chắn rằng tôi đã nhìn thấy tồi tệ hơn, nhưng nó khá xấu. Tôi nửa vời cố gắng xác định sự phức tạp, nhưng đã từ bỏ và gọi nó O(big).
Geobits

1
Cung cấp một giải pháp ít hiệu quả hơn thì ngay cả nỗ lực ngây thơ của vấn đề nhân viên bán hàng du lịch cũng rất ấn tượng!
đệ

3
Vì cơ hội của một mảng 12 phần tử được sắp xếp chỉ là 1 trên 479 triệu, nên thực sự không có vấn đề gì phải mất một thời gian để chắc chắn rằng đó là một điều chắc chắn? Bạn thực sự không bao giờ có thể nhìn thấy một người trong thế giới thực ...
Jules

2
@Geobits Không có vấn đề. Chạy thuật toán của Victor và trả lời "có" tại dấu nhắc đầu tiên.
Jason C

29

C ++ - một phương pháp vũ phu

Mọi người đều biết rằng các phương pháp vũ phu luôn là nhanh nhất.

bool issorted(std::vector<int>& list)
{
  switch (list.size()) {
    case 0: case 1: return true;
    case 2: return list[0]<=list[1];
    case 3: return list[0]<=list[1] && list[1]<=list[2];
    case 4: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3];
    case 5: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4];
    case 6: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5];
    case 7: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6];
    case 8: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7];
    case 9: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8];
    case 10: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9];
    case 11: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10];
    case 12: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11];
    case 13: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12];
    case 14: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13];
    case 15: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14];
    case 16: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15];
    case 17: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16];
    case 18: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17];
    case 19: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18];
    case 20: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19];
    case 21: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20];
    case 22: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21];
    case 23: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22];
    case 24: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23];
    case 25: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24];
    case 26: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25];
    case 27: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26];
    case 28: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27];
    case 29: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28];
    case 30: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29];
    case 31: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30];
    case 32: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31];
    case 33: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32];
    case 34: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33];
    case 35: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34];
    case 36: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35];
    case 37: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36];
    case 38: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37];
    case 39: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37] && list[37]<=list[38];
    case 40: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37] && list[37]<=list[38] && list[38]<=list[39];
    case 41: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37] && list[37]<=list[38] && list[38]<=list[39] && list[39]<=list[40];
    case 42: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37] && list[37]<=list[38] && list[38]<=list[39] && list[39]<=list[40] && list[40]<=list[41];
    case 43: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37] && list[37]<=list[38] && list[38]<=list[39] && list[39]<=list[40] && list[40]<=list[41] && list[41]<=list[42];
    case 44: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37] && list[37]<=list[38] && list[38]<=list[39] && list[39]<=list[40] && list[40]<=list[41] && list[41]<=list[42] && list[42]<=list[43];
    case 45: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37] && list[37]<=list[38] && list[38]<=list[39] && list[39]<=list[40] && list[40]<=list[41] && list[41]<=list[42] && list[42]<=list[43] && list[43]<=list[44];
    case 46: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37] && list[37]<=list[38] && list[38]<=list[39] && list[39]<=list[40] && list[40]<=list[41] && list[41]<=list[42] && list[42]<=list[43] && list[43]<=list[44] && list[44]<=list[45];
    case 47: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37] && list[37]<=list[38] && list[38]<=list[39] && list[39]<=list[40] && list[40]<=list[41] && list[41]<=list[42] && list[42]<=list[43] && list[43]<=list[44] && list[44]<=list[45] && list[45]<=list[46];
    case 48: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37] && list[37]<=list[38] && list[38]<=list[39] && list[39]<=list[40] && list[40]<=list[41] && list[41]<=list[42] && list[42]<=list[43] && list[43]<=list[44] && list[44]<=list[45] && list[45]<=list[46] && list[46]<=list[47];
    case 49: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37] && list[37]<=list[38] && list[38]<=list[39] && list[39]<=list[40] && list[40]<=list[41] && list[41]<=list[42] && list[42]<=list[43] && list[43]<=list[44] && list[44]<=list[45] && list[45]<=list[46] && list[46]<=list[47] && list[47]<=list[48];
    case 50: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37] && list[37]<=list[38] && list[38]<=list[39] && list[39]<=list[40] && list[40]<=list[41] && list[41]<=list[42] && list[42]<=list[43] && list[43]<=list[44] && list[44]<=list[45] && list[45]<=list[46] && list[46]<=list[47] && list[47]<=list[48] && list[48]<=list[49];
    case 51: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37] && list[37]<=list[38] && list[38]<=list[39] && list[39]<=list[40] && list[40]<=list[41] && list[41]<=list[42] && list[42]<=list[43] && list[43]<=list[44] && list[44]<=list[45] && list[45]<=list[46] && list[46]<=list[47] && list[47]<=list[48] && list[48]<=list[49] && list[49]<=list[50];
    case 52: return list[0]<=list[1] && list[1]<=list[2] && list[2]<=list[3] && list[3]<=list[4] && list[4]<=list[5] && list[5]<=list[6] && list[6]<=list[7] && list[7]<=list[8] && list[8]<=list[9] && list[9]<=list[10] && list[10]<=list[11] && list[11]<=list[12] && list[12]<=list[13] && list[13]<=list[14] && list[14]<=list[15] && list[15]<=list[16] && list[16]<=list[17] && list[17]<=list[18] && list[18]<=list[19] && list[19]<=list[20] && list[20]<=list[21] && list[21]<=list[22] && list[22]<=list[23] && list[23]<=list[24] && list[24]<=list[25] && list[25]<=list[26] && list[26]<=list[27] && list[27]<=list[28] && list[28]<=list[29] && list[29]<=list[30] && list[30]<=list[31] && list[31]<=list[32] && list[32]<=list[33] && list[33]<=list[34] && list[34]<=list[35] && list[35]<=list[36] && list[36]<=list[37] && list[37]<=list[38] && list[38]<=list[39] && list[39]<=list[40] && list[40]<=list[41] && list[41]<=list[42] && list[42]<=list[43] && list[43]<=list[44] && list[44]<=list[45] && list[45]<=list[46] && list[46]<=list[47] && list[47]<=list[48] && list[48]<=list[49] && list[49]<=list[50] && list[50]<=list[51];
  }
}

Thói quen thực tế dài hơn (đến std :: npose), nhưng tôi bị giới hạn ở 30000 ký tự khi đăng ở đây.


Tôi thực sự thích điều này.
Jakob

3
Điều này giống như cách tiếp cận "sử dụng mọi phần của con trâu" cho các báo cáo trường hợp.
Jonathan Van Matre

Điều này thật tuyệt. Bỏ tất cả các vòng lặp!
McKay

ý nghĩ tuyệt vời !!!
bikram990

26

Thông báo

Inform là ngôn ngữ để viết các trò chơi viễn tưởng tương tác cho trình thông dịch Z-machine Infocom cổ điển. Để tránh những kẻ phá hoại, tôi đưa ra kết quả của chương trình trước, sau đó là mã nguồn.

Chỉnh sửa: Tôi đã thực hiện một sửa đổi nhỏ để cho phép thêm số vào mảng và bao gồm một mô tả phòng duyên dáng.

Sorted
An Interactive Fiction by Jonathan Van Matre
Release 1 / Serial number 140301 / Inform 7 build 6G60 (I6/v6.32 lib 6/12N) SD

Sorting Room
You are in the Sorting Room, a sterile expanse of pure white. Translucent
lucite walls leak a lambent clinical light into the spotless room.

You can see a safe (closed), a flask of poison, a radioactive isotope 
attached to a radiation detector that triggers a hammer, an array (empty) 
and Erwin Schrodinger here.

>open safe
You open the safe.

>put flask in safe
(first taking the flask of poison)

You put the flask of poison into the safe.

>put isotope in safe
(first taking the radioactive isotope attached to a radiation detector 
 that triggers a hammer)

You put the isotope detector assembly into the safe, carefully placing 
the hammer next to the fragile glass of the flask of poison.

>get array
Taken.

>put numeral 1 in array
(first taking the numeral 1)

You put the numeral 1 into the array.

>put 2 in array
(first taking the numeral 2)

You put the numeral 2 into the array.

>put 3 in array
(first taking the numeral 3)

You put the numeral 3 into the array.

>examine array
In the array are a numeral 3, a numeral 2 and a numeral 1.

>put array in safe
You put the array into the safe.

>ask Erwin about whether the array is sorted
Erwin grumbles and complains, "You haven't finished the experiment" 

>close safe
You close the safe.

>ask Erwin about whether the array is sorted
Erwin beams and proudly announces, "Indeterminate!" 

Và theo đây là mã nguồn:

"Sorted" by Jonathan Van Matre

The Sorting Room is a room. "You are in the Sorting Room, a sterile expanse of pure white. Translucent lucite walls leak a lambent clinical light into the spotless room."
The safe is a container. The safe is in the Sorting Room. The safe is openable. The safe is closed.
There is a flask of poison in the Sorting Room.
There is a radioactive isotope attached to a radiation detector that triggers a hammer in the Sorting Room.
There is an array in the Sorting Room. The array is a container.
There is a numeral 1 in the Sorting Room. The numeral 1 is undescribed.
There is a numeral 2 in the Sorting Room. The numeral 2 is undescribed.
There is a numeral 3 in the Sorting Room. The numeral 3 is undescribed.
There is a numeral 4 in the Sorting Room. The numeral 4 is undescribed.
There is a numeral 5 in the Sorting Room. The numeral 5 is undescribed.
There is a numeral 6 in the Sorting Room. The numeral 6 is undescribed.
There is a numeral 7 in the Sorting Room. The numeral 7 is undescribed.
There is a numeral 8 in the Sorting Room. The numeral 8 is undescribed.
There is a numeral 9 in the Sorting Room. The numeral 9 is undescribed.
In the Sorting Room is a man called Erwin Schrodinger.
Understand the command "ask" as something new.
Understand "ask [someone] about [text]" as asking it about.
After inserting the isotope into the safe:
    If the safe encloses the flask, say "You put the isotope detector assembly into the safe, carefully placing the hammer next to the fragile glass of the flask of poison.";
Instead of asking Erwin about something:
    If the safe is closed and the safe encloses the flask and the safe encloses the array and the safe encloses the isotope, say "Erwin beams and proudly announces, 'Indeterminate!' ";
    Otherwise say "Erwin grumbles and complains, 'You haven't finished the experiment' ";

21

Doge Ruby

Trước tiên, bạn phải chạy mã thiết lập này

class Array;alias ruby sort;end
def self.method_missing x,*a;x;end
def very x;$a=x;end
def many x;$b=$a.send x;end
def wow;puts $a==$b;end

Sau đó, chỉ cần lưu trữ mảng trong một biến được gọi codingvà chạy:

  very coding

                 many ruby
so algorithm


      wow

Và câu trả lời của bạn sẽ được in (đúng hoặc sai).

Vui lòng thêm mã doge để có hiệu suất tối ưu:

#~! SET DOGE=1 PERFORMANCE=OPTIMAL ONERROR=nil PIC=
#                    ***=*                                                       
#                    **===*                                                      
#                    ***=-=&                                   &&**&             
#                    **==--=                                  ***===*            
#                   &***=---*                               $*=------*&          
#                   &***=---=*                             $**=----;;=&          
#                   &**==----=&                           &*===---;;;-*          
#                   &**==----=*                          &**=-==--;;;;=          
#                   ****=-----=*                       &&*==--=---;;;;-          
#                   **===------=&                     $&*==-------;;;;-          
#                   **===-------=*&$$                &*==------;;;;;;;-          
#                   **==----==-====***&&&&&&&&$$    &*==-;;---;;;;;;;;-&         
#                  &*=---=====================*******=---;---;;;;;;;-;;=         
#                  *=======*=========================---;;--;;;;;;;;;;;*         
#                  *===***=======================------;;--;;""""";;;;;=         
#                  *=*****========================;--;;;;--;;""""";;;;;*         
#                &*********====-----===============;;;;;----;"","";-;;-&         
#               ***********====----================-;;;;----;",,";;----          
#             &************===---====================-;;;;;;",,"";----=          
#            &*************===---=====================-;;;;",,,";-----*          
#            ******=*******===--=======================--;",,,"";-----&          
#           &**************==--=========================-;"","";----;-           
#          ****************==---====****=====-===========--;";;-;;;";=           
#         ****************==----==*******===--=============--;----;--=           
#        &*****=;"";==***===----==*******===----=============------;-=$          
#        &&&***;"",,"-**====---==********=====-===============----;;;-&          
#       &&&&&*=-;;";";*==========****=***======--=========***==---;;;-&          
#      $&&&&&&=="",,,-===**=======***==-;-=================**===--;;;;*          
#      &&&&&&&-="",,"==***==***======-",,,";=-===================--";;=          
#      &&&&&**=-""";==****=***===---;"-=-,,,"--===================-;;;=&         
#     &&&&&&***--;=***********=---;,,-*",,,,,"--==================--;--*         
#     &&&&&***=*=*************=-;;","=-,,,,,,"-====================----=$        
#    &&&&&&*******************==--","-;,,,,,"-====*****=============-===&        
#   $&&&&&&******************===---",";"""";=******************=====-===*        
#   &&&&&&&&&*****************======--;;--==********************=========&       
#  &&&&&&&&&&&******=**********===========*==*****&&************=========*       
#  &&&&&&&&*=---;--==**********==============*********************=======*&      
#  &&&&&&&-""""";;"";=**********==**=========*****&&&**************=======*      
# &&&&&&&*,,,,,,,,,,,"-****&************=*******&&&&&&&************========&     
# &&**&&&=,,,,,,,,,,,,;*&&&&***********************&&&&&&***********=======*     
# &&&*&&&*",,,,,,,,,,,;*&&&*************&&**********&**************========*&    
#&&&&&&&&-"",,,,,,,,,,-*&&&**********&**&&&&&&&******************==========**    
#&&&&&&&*=,,,,,,,,,,,"-***************&&&&&&&&&*****************====--======*&   
#&&***&&*=;,,,,,,,,,";=*==*****************&&&***************=======--=======&   
#*&&&&**=-;",,,,,,"";-=*********=**&*********&&**************=======--======**   
#&&&&&**=-""",,,,,"";==**==***===**********************======***===---=======*&  
#&&&&&**=-;"""""","";;=-===*======*********************==******====----======*&  
#*&&&&**=-;""""""""";=-============*****************==*********====---==--===**  
#&&&&&***=",,,,,,"""";--=============*******==****************====----=--====**& 
#&&&&&****"",,,,,,,,,;-=========--===****====******************====--==-======*& 
#&&&&&&&&*-"",,,,,,,,,"--==--;"""";====**===********************======--======** 
#&&&&&&***=-;",,,,,,,,,,,;",,,""";-=======********************===-------=======* 
#&&&&&&&****=;""""""""",,,"""";;--==**====*******************=====--------=====* 
# &&&&&&&***=-;;;;;;;;;"";;;;;---==***====*****************=====--=--------====*$
# &&&&&&*****=-;-----=--------=====*=======****************====-==---------=====&
#  &&&&&******==-==-=============***========*************======----=--------====&
#  &&&&************==========================***********=====----------------===*
#  $&&&&***************====================***********=*======-------------=--==*
#   &&*&************=====================**************======--------------=====*
#   &******************=================**************=========-----------======*
#    &***********=*****================************==========------;-------=====*
#    &*****************================***********=============---------========*
#     &*************===================**********==***========--------========***
#      **************==================********====**===*=====--------=======****
#      &************=============================*****=*=====--------=======*****
#       &****=*******=============================**============--=======*=******
#       $*****=====**===========================***===================**********&
#        &*****=====================-====-====*=*=====*=======--==***************
#         &*****===========---==--===============**=**=*========*****************
#          &*****====---=---------========********======***===*******************
#           *****=======-=-------======*******=**==****==*==*********************
#           $***======================******===**********************************
#            &***===================*******==***=******************************=&
#             &***=========-=========*************==***************************=&
#              ******===*=======*=*****************==*************************==&
#~! END

Đây là cách dễ dàng nhất.


(nghệ thuật ASCII được tạo bởi một kịch bản tôi đã viết, xuất phát từ hình ảnh này .)


7
Bạn đã quên "thuật toán". Một mẫu doge thực sự có 3 câu trước "wow". Và vâng, tôi rất vui trong các bữa tiệc.
Pierre Arlaud

@ArlaudPierre Heh, được rồi, đã sửa: P
Doorknob

11
Vì vậy, nhận xét, rất cải thiện, nhiều hữu ích. Ồ
Pierre Arlaud

Bạn nên viết một chương trình BF trong hình ascii giống như một doge ... ý tưởng câu hỏi mới !!
TheDoctor

19

PHP

Bạn sẽ thích sự dễ dàng và đơn giản của giải pháp sau đây. Khái niệm tổng thể và các chức năng tiên tiến được sử dụng trong kiệt tác mã hóa này sẽ ngay lập tức đưa bạn đến danh sách ưu tú của các nhà phát triển hàng đầu của Thế giới.

function is_sorted($input) {
    mysql_connect('localhost', 'name', 'password');
    mysql_select_db('database');

    mysql_query('
        CREATE TEMPORARY TABLE sorting_table (
          `value` int NOT NULL
        )');

    foreach ($input as $value) {
        mysql_query('INSERT INTO sorting_table VALUES (' . $value . ')');
    }

    $i = 0;
    $result = 'SORTED';
    $query = mysql_query('SELECT * FROM sorting_table ORDER BY value ASC');
    while ($value = reset(mysql_fetch_row($query))) {
        if ($input[$i++] != $value) {
            $result = 'NOT SORTED';
            break;
        }
    }

    mysql_query('DROP TABLE sorting_table');

    return $result;
}

print is_sorted(array(10, 20, 30, 40, 50));

+1 Bởi vì bạn đang sử dụng cùng một khái niệm về câu trả lời của tôi cho câu hỏi sắp xếp
Victor Stafusa

4
Điều này sẽ làm việc nếu bà Roberts nhập các giá trị?
dùng80551

3
@ user80551 có vì không có bảng gọi là sinh viên
ratchet freak

3
@JonathanVanMatre Bảo mật chắc chắn là một trong những mặt mạnh nhất của mã này.
VisioN

1
Đây là câu trả lời yêu thích mới của tôi trên trang web này; nhưng để có thêm điểm, tôi rất muốn thấy bạn sử dụng PDO để bảo mật
alexandercannon

17

C # - Sức mạnh của thống kê

Những gì bạn thực sự cần làm để giải quyết điều này là đóng khung lại câu hỏi theo cách làm cho giải pháp rõ ràng. Bởi vì đây về cơ bản là một câu hỏi loại "đúng-sai", điều bạn chủ yếu hỏi là "làm thế nào tôi có thể chắc chắn 100% rằng mảng được sắp xếp?" Nếu một từ bật ra khỏi câu hỏi đó, đó là từ "nhất định". Cách tốt nhất để đo lường sự chắc chắn là gì? Bạn đã nhận nó: số liệu thống kê.

Các câu trả lời khác ở đây chỉ kiểm tra xem mảng được sắp xếp theo một hướng . Giải pháp này kiểm tra cả thứ tự tăng dần và giảm dần cùng một lúc. Mẹo nhỏ là lấy một mảng có cùng kích thước mà bạn đã biết được sắp xếp (dễ dàng tự tạo một mảng) và sau đó tìm hiểu thứ tự của mỗi mảng tương quan với nhau như thế nào. Tính hệ số tương quan xếp hạng Kendall tau là cách dễ nhất để làm điều này:

using System;

namespace Homework
{
    class Example
    {
        static void Main(string[] args)
        {
            int[] n1 = { 23, 50, 16, 57, 19, 60, 40, 7, 30, 54 };
            int[] n2 = { 7, 16, 19, 23, 30, 40, 50, 54, 57, 60 };
            int[] n3 = { 60, 57, 54, 50, 40, 30, 23, 19, 16, 7 };

            Console.WriteLine(isSorted(n1));
            Console.WriteLine(isSorted(n2));
            Console.WriteLine(isSorted(n3));
        }

        static string isSorted(int[] a)
        {
            double t = 0;
            int n = a.Length;

            //Build a 'known' sorted array.
            int[] k = new int[n];
            for (int i = 1; i < n; i++)
            {
                k[i] = i;
            }

            //Find the Kendall's tau coefficient.
            //First the numerator...
            for (int i = 1; i < n; i++)
            {
                for (int j = 0; j < i; j++)
                {
                    t += Math.Sign(a[i] - a[j]) * Math.Sign(k[i] - k[j]);
                }
            }
            //...then the denominator.
            int d = n * (n-1) / 2;
            //This gives the correlation coefficient.
            double sortedness = t / d;
            //1 is perfect correlation (ascending), -1 is perfectly non-correlated (descending).
            if (Math.Abs(sortedness) == 1)
            {
                return "Sorted";
            }
            else
            {
                return "Unsorted";
            }
        }
    }
}

Đầu ra:

Unsorted
Sorted
Sorted

Chức năng này cũng rất dễ dàng để mở rộng chức năng của, vì sẽ rất tầm thường khi thêm chức năng như "Được sắp xếp chủ yếu" hoặc "Sắp xếp nhiều hơn không" hoặc "Hoàn toàn ngẫu nhiên".

Biên tập

Hầu như quên đi quá hiệu quả của thuật toán. Đây là O (7). Có một trong tên phương thức, một trong mỗi từ khóa "cho", một trong khai báo "nhân đôi" và hai trong cách sử dụng biến "sắp xếp". Bạn có thể cải thiện điều này xuống tận O (0) (mức thấp nhất có thể) bằng cách đổi tên hàm, thay đổi số kép thành số thập phân, từ chối "sắp xếp" thành "srtdnss" và chuyển đổi các vòng lặp thành trong khi các vòng lặp.


2
Tôi đã tính toán lại sự phức tạp và xác định nó là O (8). Bạn đang xử lý đầu ra mà tôi tin rằng nên tính đến. Để có độ phức tạp O (7) thực sự, bạn có thể cân nhắc trả về "tăng dần" / "haphazard", thay vì "sắp xếp" / "chưa sắp xếp".
Geobits

@Geobits - Tôi đã xem lại, và tất nhiên bạn đúng. Tôi đoán điều này cho thấy rằng có độ phức tạp tối thiểu là O (1) khi trả về chuỗi. Đây là một cái giá nhỏ phải trả, bởi vì trả lại một boolean là xấu gấp đôi.
Comitern

1
+1 cho phép tính O (). -1 vì cũng không tính được Spearman rho, vì không có hai mối tương quan nào tốt hơn một? Và +1 cho số liệu thống kê trong C #, yêu thích đã được chứng minh của các nhà thống kê.
Jonathan Van Matre

Xin vui lòng cho tôi biết đây O(7)là một trò đùa
mbatchkarov

@mbatchkarov - Đó là ký hiệu O nhỏ. :-)
Comitern

16

Hồng ngọc

Chiến lược tiếp theo cuối cùng sẽ tiết lộ nếu một mảng được sắp xếp:

  1. Một mảng là một mảng (được sắp xếp hoặc chưa được sắp xếp, ví dụ [1,2,3] hoặc [1,3,2])
  2. P là một mảng chứa tất cả các hoán vị của A
  3. Nếu A được sắp xếp, nó là tối đa hoặc tối thiểu của P (về cơ bản là các phiên bản được sắp xếp của A trong Ruby)

Phiên bản trực tuyến để thử nghiệm.

class Array
   def is_sorted?
      permutations = permutation.to_a
      self == permutations.max || self == permutations.min
   end
end

1
Tôi không nghĩ rằng tôi hiểu lời giải thích. Nếu mảng là, ví dụ: [1, 9, 100], thì min là 10019 và max là 91100, nhưng số được sắp xếp là 19100. Chơi với phiên bản trực tuyến, max là [100,9,1] và min là [1,9,100]. Tôi không thấy bất cứ điều gì đang được "đại diện bởi một số"; có vẻ như các mảng chỉ được sắp xếp theo thứ tự từ vựng. Điều này sẽ giống nhau, tôi cho rằng, nếu tất cả các số chỉ là một chữ số.
Joshua Taylor

"... hoặc tối đa hoặc tối thiểu ..." yêu thích nó.
microbian

@JoshuaTaylor: Cảm ơn bạn đã ủng hộ! Tôi muốn giải thích nó một cách dễ hiểu - kết cục là hoàn toàn sai;) Tôi đã sửa lại mô tả của mình ...
David Herrmann

2
@JoshuaTaylor các phương thức ruby ​​Array # max và #min chọn phần tử lớn nhất và nhỏ nhất liên quan đến các toán tử <và>. Trên Mảng, <và> thực hiện sắp xếp từ điển. [1,9,100] là cực tiểu của tất cả các hoán vị được đặt hàng là 1, 9 và 100 theo thứ tự từ điển.
Karl Damgaard Asmussen

Đó gần như là chất lượng sản xuất.
primo

12

C # - giải pháp không xác định

Mã này có thể hoạt động.

static bool isSorted(int[] s)
{
    var rnd = new Random();
    for (var i = 0; i < s.Length * s.Length * s.Length; i++)
    {
        var i1 = rnd.Next(0, s.Length);
        var i2 = rnd.Next(0, s.Length);
        if (i1 < i2 && s[i1] > s[i2] || i1 > i2 && s[i1] < s[i2])
            return false; // definitely not sorted
    }
    return true; // probably sorted
}

8
Nếu bạn đặt số lần lặp là -n ^ 2 * ln (1-p), bạn có thể đảm bảo với xác suất p rằng tất cả các kết hợp sẽ được kiểm tra!
Hannesh

Và giá trị nào của p là hợp lệ để giải pháp này được chấp nhận là "mã làm việc nhưng trolling"? :)
fejesjoco

2
Từ stackoverflow.com/questions/2580933 , cơ hội tính toán sai so sánh do các tia vũ trụ sẽ là 0,0000018 (1,8e-6) mỗi giây. Vì vậy, nếu: 1) bạn có thể tìm ra một lần lặp mất bao lâu, 2) Chúng ta có thể sử dụng công thức của @Hannesh để tính xác suất và sau đó giải hệ phương trình để tìm số lần lặp khiến giải pháp của bạn không thể phân biệt được với phương pháp isSort tiêu chuẩn.
Xantix

11

Con trăn

Nếu danh sách được sắp xếp, mọi số đều nhỏ hơn hoặc bằng số tiếp theo. Do đó, việc loại bỏ số nhiều nhất bên trái sẽ mang lại giá trị trung bình, nếu không danh sách không được sắp xếp. Chúng tôi sẽ đặt điều này trong một vòng lặp để kiểm tra từng số

def is_sorted(lst):
    def _avg(lst):
        return sum(lst)/(1.0*len(lst))
    for i in range(len(lst)-1):
        if _avg(lst[i:]) > _avg(lst[i+1:]):
            return False
    return True

is_sort ([1,2,3]) #True
is_sort ([3,2,1]) #False
is_sort ([1,4,3,2,0,3,4,5]) #False


Người đọc quan sát sẽ nhận thấy rằng nó không hoạt động chính xác như thế.
is_sort ([1,4,3,2,0,3,4,11]) #False
is_sort ([1,4,3,2,0,3,4,12]) #True
is_sort ([1,2 , 1,2,1,2,1,2,99]) #True


9

Bash

mkdir -p nums
mynums=(1 2 3 4)
for i in "${mynums[@]}"
do
     touch "nums/$i"
done

result=`ls -v nums`
resultarray=(${result})
for i in "${!resultarray[@]}"
do
    if [ ${resultarray[$i]} != ${mynums[$i]} ]; then
        echo "not sorted!"
        rm -rf nums/*
        exit 1
    fi
done
echo "sorted!"
rm -rf nums/*

chạm vào một tệp cho mỗi phần tử trong mảng, ls thư mục và so sánh kết quả ls với mảng ban đầu.

Tôi không giỏi lắm với bash, tôi chỉ muốn thử thôi :)


Rất vui, điều này giả định rằng thư mục "./nums" đã tồn tại. Có lẽ một "mkdir -p nums" ở đâu đó?
camelthemammel

Ồ, vâng điều đó có ý nghĩa: P
Zach Thacker

8

C #

Khái niệm "nhỏ hơn" hay "lớn hơn" rất nhiều trong năm 2013 . Lập trình viên thực sự chỉ sử dụng modulotoán tử!

private static void Main()
{
    List<int> list = new List<int> { 1, 5, 7, 15, 22};
    List<int> list2 = new List<int> { 1, 5, 15, 7, 22 };

    bool a = IsSorted(list); // true
    bool b = IsSorted(list2); // false
}

private static bool IsSorted(List<int> list)
{
    for(int i = 0; i % list.Count != list.Count() - 1; i++)
    {
        if (list[i] % list[i + 1] != list[i] &&
            list[i] != list[i + 1])
        {
            return false;
        }
    }
    return true;
}

Nếu cùng một số xuất hiện hai lần thì sao? Sau đó liệt kê [i]% danh sách [i + 1] == 0.
Simon

@Simon ơi! Thật vậy, tôi đoán hai số giống hệt nhau được sắp xếp. Đã thêm một so sánh cho trường hợp cạnh này. Đẹp tìm thấy.
Pierre-Luc Pineault

5
Vui mừng khi biết rằng {0, -1, 2} là một danh sách được sắp xếp.
Pierre Arlaud

9
@ArlaudPierre Nếu bạn muốn trở thành một lập trình viên 2014 thực sự, bạn phải gạt bỏ mọi thứ tiêu cực. Thế giới là tích cực, thế giới là tuyệt đối, thế giới là modulo!
Pierre-Luc Pineault

1
Vì bạn không thích khái niệm "lớn hơn" và "nhỏ hơn", thật đáng tiếc, bạn phải bao gồm những dấu hiệu nhỏ hơn và lớn hơn. Bạn nên sử dụng mảng hơn là danh sách.
Ông Lister

8

Scala

Kiểm tra nếu một mảng được sắp xếp là dễ dàng! Chỉ cần kiểm tra nếu phần tử đầu tiên nhỏ hơn phần tử thứ hai. Sau đó sắp xếp phần còn lại và xem nếu chúng bằng nhau.

Thật không may, sắp xếp là một vấn đề khó khăn. Không có nhiều thuật toán nổi tiếng hoặc hiệu quả để sắp xếp một mảng; trong thực tế, đó là một điểm mù lớn trong tình trạng kiến ​​thức khoa học máy tính hiện nay. Vì vậy, tôi đề xuất một thuật toán đơn giản: xáo trộn mảng và sau đó kiểm tra xem nó đã được sắp xếp chưa, như đã nêu, có dễ không! Tiếp tục xáo trộn cho đến khi nó được sắp xếp.

object Random {
  def isSorted(list: List[Int]): Boolean = {
    if (list.size <= 1) {
      true
    } else {
      sort(list.tail) == list.tail && list.head <= list.tail.head
    }
  }

  def sort(list: List[Int]): List[Int] = {
    val rand = new scala.util.Random()
    var attempt = list
    do {
      attempt = rand.shuffle(attempt)
    } while (!isSorted(attempt))
    attempt
  }

  def main(args: Array[String]): Unit = {
    println(isSorted(List(1, 2, 3)))
    println(isSorted(List(1, 3, 2)))
    println(isSorted(List(1, 2, 3, 4, 5, 6, 7, 8)))
  }
}

Tôi giả sử kết quả này là "đúng, sai, đúng". Nó đã chạy được một lúc rồi ...


8

Một mảng các số nguyên được sắp xếp có thuộc tính mà mọi mảng con (giả sử các phần tử n đến m của mảng) cũng là một mảng các số nguyên được sắp xếp. Điều này rõ ràng ngụ ý rằng phương pháp tốt nhất là một hàm RECURSIVE:

bool isSorted_inner(const std::vector<int> &array, int start, int length){
    if (length == 2){
        if (array[start] < array[start+1]){
            return true;
        }else{
            return false;
        }
    }else{
        return isSorted_inner(array, start, length-1) && isSorted_inner(array, start+1, length-1);
    }
}

bool isSorted(const std::vector<int> &array){
    return isSorted_inner(array, 0, array.size());
}

Nó có thể không phải là phương pháp nhanh nhất nhưng nó không phải là một thử nghiệm RẤT CHÍNH XÁC về việc một danh sách có được sắp xếp hay không. Nó cũng cực kỳ dễ đọc và hiểu mã này bởi vì nó sử dụng mô hình CHỨC NĂNG, và do đó không có sự khủng khiếp của các vòng lặp thay đổi trạng thái và lặp lại.

Tôi hy vọng đây sẽ là thông tin hữu ích cho bạn.


6

C # - sự gia tăng dài nhất

Đối với một mảng được sắp xếp, độ dài của chuỗi tăng dài nhất bằng với độ dài của mảng. Tôi đã sao chép thuật toán từ đây , chỉ sửa đổi nó thành không giảm thay vì tăng.

static bool isSorted(int[] s)
{
    return s.Length == LongestIncreasingSeq(s);
}

static public int LongestIncreasingSeq(int[] s)
{
    int[] l = new int[s.Length];  // DP table for max length[i]
    int[] p = new int[s.Length];  // DP table for predeccesor[i]
    int max = int.MinValue;

    l[0] = 1;

    for (int i = 0; i < s.Length; i++)
        p[i] = -1;

    for (int i = 1; i < s.Length; i++)
    {
        l[i] = 1;
        for (int j = 0; j < i; j++)
        {
            if (s[j] <= s[i] && l[j] + 1 > l[i])
            {
                l[i] = l[j] + 1;
                p[i] = j;
                if (l[i] > max)
                    max = l[i];
            }
        }
    }
    return max;
}

6

Stonescript (c) LMSingh - 0 trừ (4102 palindromed).

Sau đây được viết bằng Stonescript (c), một ngôn ngữ có bản quyền và được sử dụng bởi tôi từ nhiều thế kỷ trước, tức là vào thời xa xưa trước khi midgetframes. LƯU Ý: Nó là tiền thân của tiếng Phạn.

1. Find a very straight stick in the jungle.  
2. Sum up all the values of the array elements and find that many equal sized stones.  
3. Line up all the values of the array along the side of straight stick from step 1. Each value is to be represented by number of stones for each array element like so...  

Ví dụ về một mảng có 8 phần tử. Sắp xếp theo thứ tự giảm dần :-)

o
oo
oo
oooo
ooooo
ooooo
ooooo
oooooo
ooooooo
oooooooo
========
12345678

- Mã tiếp tục.

4. E-ball-uate. (In Shakespearean English that means Eye ball it.)  
  4.1 Run your eye from array position 1 top towards array position 8 top.  
  4.2 If it looks sorted, then it is.  
  4.2.1 Start jumping up and down and thumping chest.  
  4.2.2 Go to happy end.  
  4.3 If something isn't quite right, like in case of example below then it isn't.  
  4.3.1 Kick the stones in frustration and anger! Cuz it really is not sorted!  
  4.3.2 Go to sad end.  

Ví dụ về một mảng có 8 phần tử. Không được sắp xếp :-(

o
oo
oo
oo o
ooooo
ooooo
ooooo
oooooo
ooooooo
oooooooo
========
12345678

- Mã tiếp tục.

5. Sad end.  
  5.1 Eat an apple.  
  5.2 Fall from grace to next line.  
6. Happy end.  

= - = - = - = - = - =
Khi tối ưu hóa hơn nữa, bước 4 lá đấm có thể được thay thế bằng các lá đấm sau.
= - = - = - = - = - =

4. Roll a stone from top of position 1 towards top of position 8, pushing the rolling stone towards the top stone for each position while moving to the right.  
  4.1 If rolling stone reaches the position 8 then it's sorted.  
  4.1.1 Start jumping up and down and thumping chest.  
  4.1.2 Go to happy end.  
  4.2 If the rolling stone gets stuck in a trough, then it isn't.  
  4.3.1 Kick the stones in frustration and anger!  
  4.3.2 Go to sad end.  

= - = - = - = - = - =
Đối với bạn tất cả các thám tử mã và trình gỡ lỗi sức mạnh ngoài kia, tôi đã cố tình thêm một lỗi trong biến thể thứ hai ở trên của bước 4. Bạn có thể tìm thấy nó không?


3
Tôi đã tìm thấy lỗi - tất cả 4.3.*phải là4.2.*
Timtech

4

Javascript

Đây là điều khiến bạn sốc về "sự sáng tạo":

  • Bởi vì đối với một mảng được sắp xếp

    * all the elements on the left side of any element must be smaller 
    * all the elements on the right side of any element must be bigger
    
  • Do đó, hãy chạy một vòng lặp chính cho tất cả các yếu tố và kiểm tra hai điều kiện trên bằng cách chạy hai vòng lặp lồng bên trong vòng lặp chính (một cho bên trái và một cho bên phải)

Vì vậy, tôi đưa ra một triển khai javascript của thuật toán được mô tả:

function checkArraySorted(array) {
  for (a = 0; a < array.length; a++) {
    for (b = 0; b < a; b++) {
       if (array[b] > array[a]) return false;
    }
    for (b = a + 1; b < array.length; b++) {
       if (array[b] < array[a]) return false;
    }
  }
  return true;
}

Hãy kiểm tra nó:

checkArraySorted([]);
> true

checkArraySorted([1]);
> true

checkArraySorted([1, 2]);
> true

checkArraySorted([2, 1]);
> false

checkArraySorted([1, 2, 3]);
> true

checkArraySorted([1, 2, 3, 4]);
> true

Có vẻ để làm việc hoàn hảo! Nó có độ phức tạp O(n²), lý tưởng cho một thuật toán nên có O(n), nhưng bằng cách thực hiện O(n²)nó trở nên hiệu quả hơn, vì đây là thước đo hiệu quả, do đó O(n²)hiệu quả hơn O(n).


Tôi không có ý sử dụng 'giữa'. Vòng lặp lồng đầu tiên là từ 0 đến a và vòng thứ hai được cho là từ +1 đến chiều dài. BTW, 1,2,3 nên được sắp xếp, phải không?
microbian

@microbian Ok, chỉnh sửa.
Victor Stafusa

4

C

Sau đây, "được sắp xếp" có nghĩa là "được sắp xếp theo thứ tự tăng dần".

Một mảng không được sắp xếp iff a[i]>a[i+1]

Vì vậy, nếu chúng ta cho phép x=a[i]-a[i+1], xsẽ là tích cực nếu mảng không được sắp xếp.

Để kiểm tra xmức độ dương tính, chúng ta có thể chia nó thành hai phần: xkhông âm tính và xkhông bằng không

Một thử nghiệm đơn giản cho dù xâm tính là chúng tôi kiểm tra xem x*xcó bằng không x*abs(x). Điều kiện này phải là sai nếu xlà âm (-1)*(-1)==1.

Để kiểm tra 0, chúng ta có thể sử dụng một kiểm tra đơn giản khác: 0./(float)xkhông phải là Số iff xbằng không.

Vì vậy, đây là toàn bộ mã: (giả sử mảng có 5 phần tử)

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main() {
    int i, a[5];
    for(i=0;i<5;i++) scanf("%d",&a[i]);
    int sorted=1;
    for(i=0;i<4;i++) {
        int x=a[i]-a[i+1];
        if(x*x==x*abs(x)&&!isnan(0./(float)x)) {
            sorted=0;
            break;
        }
    }
    puts(sorted?"sorted":"not sorted");
    return 0;
}

Trên thực tế, kiểm tra cho a[i]-a[i+1] > 0đã có vấn đề. Đừng cần phải làm tất cả những thứ đó.
n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

Làm những việc không cần thiết là toàn bộ vấn đề về mã, phải không? (Và bạn có ý gì khi gặp vấn đề?)
ace_HongKongInependence

1
Ký hiệu tràn số nguyên là UB. Ngay cả khi chúng tôi xác định hành vi bao quanh, nếu chúng tôi thực hiện INT_MAX - INT_MIN thì kết quả sẽ là số âm (thay thế [i] ​​bằng INT_MAX và [i + 1] bằng INT_MIN).
n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

Vì đó chỉ là một vấn đề bài tập về nhà, chúng ta hãy giả sử rằng giáo viên sẽ không đưa ra quá nhiều con số cực đoan.
ace_HongKongInependence

ĐỒNG Ý. Chỉ là tôi thích troll + là ác.
n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

4

Đó là tất cả về cách chắc chắn bạn muốn được. Vì không có sự chắc chắn nào được đưa ra nên sau đây thực sự là hiệu suất khá tốt. Mã dưới đây cho một dự đoán tốt, nhưng nếu bạn chắc chắn bạn nên lặp lại chức năng một vài lần. Nếu bạn muốn thực sự chắc chắn, bạn nên chạy nó trong một vòng lặp và thực hiện nó hàng tá lần. Khả năng mở rộng hoàn hảo!

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

static const int size = 100;

int issorted(int *array, int size)
{
    int idx = random() % size;
    return (array[idx] >= array[0]);
}

void check_array(int *array, int size)
{
    if (issorted(array, size)) {
        puts("The array is sorted but I am not 100% sure.");
    } else {
        puts("The array is definitely not sorted in ascending order.");
    }
}

int main(void)
{
    int *array = malloc(sizeof(int) * size);
    int i = 0;

    srand(time(NULL));

    for (i = 0; i < size; i++) {
        array[i] = random();
    }

    check_array(array, size);

    for (i = 0; i < size; i++) {
        array[i] = i + 1;
    }

    check_array(array, size);
    free(array);

    return 0;
}

Đây không phải là một điều trị?


4

C

int is_sorted(int *T, int n)
{
return false;
}

Hoạt động với xác suất 1- (1 / n!) Và độ phức tạp O (1). Rõ ràng là phương pháp tốt nhất cho các mảng ngẫu nhiên rất lớn.

Vì độ phức tạp chỉ là O (1), để ước tính tốt hơn, hãy chạy hai lần.


3

C

Hàm này không chỉ cho bạn biết nếu mảng được sắp xếp. Nó cho bạn biết có bao nhiêu yếu tố ở đúng nơi. Nó có thể được sử dụng cho bất kỳ loại dữ liệu.

Lưu ý tầm quan trọng của việc sử dụng tên biến mô tả để làm cho mã của bạn dễ theo dõi. Mặt khác, chúng ta không cần khai báo biến i, vì nó nhất định được khai báo ở một nơi khác trong chương trình.

int sortcheck(array_to_be_checked[10])
{
  int number_of_elements_in_right_place=0;

  for (i = 1; i = 10; i++)
    number_of_elements_in_right_place += i == array_to_be_checked[i];

  return number_of_elements_in_right_place;
}

Chỉnh sửa: Đây là một cách tốt hơn cho các mảng lớn hơn. Ưu điểm của việc này là nó tương tự như cách con người kiểm tra.

int sortcheck(array_to_be_checked[32767])
{
  i=rand(); j=rand();
  while( (array_to_be_checked[i] > array_to_be_checked[j]) = (i > j) ) 
  {
    printf("I think it's sorted");
    i=rand(); j=rand();
  };
  printf("It wasn't sorted");
}

1
"Chúng tôi không cần khai báo biến i, vì nó nhất định được khai báo ở một nơi khác trong chương trình." đáng cười
Jonathan Van Matre

@JonathanVanMatre Cảm ơn nhưng không có nghĩa là điều duy nhất sai với mã này.
Cấp sông St

3

JavaScript + số liệu thống kê nhiều hơn

Tôi thích giải pháp được đề xuất bởi @Cominterm rất nhiều. Nhưng so sánh với một danh sách đã được sắp xếp? Như thế là gian lận!

Thay vào đó, tôi tính toán tự động tương quan của mảng (tương quan giữa mảng và mảng trái dịch chuyển một vị trí). Sau đó, tôi xáo trộn mảng rất nhiều lần và mỗi lần so sánh nó là tự tương quan mới với tự động tương quan ban đầu. Nếu mảng được sắp xếp, tự động tương quan ban đầu sẽ là cao nhất trong hầu hết thời gian!

http://jsfiddle.net/dB8HB/

Phần thưởng: Nếu giá trị p của bạn <0,05, đầu ra sẽ tự động hóa nhiệm vụ tuyên bố rằng mảng được sắp xếp cho bạn. Nhiều hơn những gì bạn có thể yêu cầu?

Bonus2: Mặc dù việc triển khai này sử dụng các hàm mảng O (n) của JavaScript để thuận tiện, cách tiếp cận có thể sử dụng lấy mẫu để chạy trong thời gian không đổi!

<form name="out"><textarea name="put" cols="80" rows="3">Press the button</textarea></form> 
<button onclick="startstop();">The button</button>
<script>
var iid=input=0, my=document.forms, isit={'true':0.5,'false':0.5}, ownAutocorr;
function startstop(){
     if(iid){
        clearInterval(iid);
        if(1 - isit.true / (isit.true+isit.false)<0.05){my.out.put.value+="\nYour array is sorted! (p<0.05)";}
        iid=input=0;isit={'true':0.5,'false':0.5}
     }
     else   {
        input=JSON.parse("["+prompt("Comma separated integers")+"]");
        ownAutocorr=pearsonCorrelation(input,cloneShiftArray(input));
        iid=setInterval(trial,50);
    }
}

function trial(){

 var newArr=shuffle(input.slice(0));
 var newAutocorr=pearsonCorrelation(newArr,cloneShiftArray(newArr));
 isit[newAutocorr<ownAutocorr]++;
 my.out.put.value="Your array is sorted with probability " + (isit.true / (isit.true+isit.false)).toFixed(2);
}

function cloneShiftArray(oldArr){
    var newArr=oldArr.slice(0); //clone the array
    var len=oldArr.length;
    //shift the array one
    for(var l=0;l<len-1;l++){
     //performance is important so we'll use bitwise operators
     newArr[l]^=newArr[l+1];
     newArr[l+1]^=newArr[l];
     newArr[l]^=newArr[l+1];
    }
    newArr[l]+=newArr[l-1   ];
    return newArr;
}
function pearsonCorrelation(p1, p2) { //Borrowed from teh interwebs
  var len = p1.length;
  var sum1=sum2=sum1Sq=sum2Sq=pSum = 0;
  for (var l = 0; l < len; l++) sum1 += p1[l];
  for (var l = 0; l < len; l++) sum2 += p2[l];
  for (var l = 0; l < len; l++) sum1Sq += Math.pow(p1[l], 2);
  for (var l = 0; l < len; l++) sum2Sq += Math.pow(p2[l], 2);
  for (var l = 0; l < len; l++) pSum += p1[l] * p2[l];
  var num = pSum - (sum1 * sum2 / len);
  var den = Math.sqrt((sum1Sq - Math.pow(sum1, 2) / len) *
      (sum2Sq - Math.pow(sum2, 2) / len));
  if (den == 0) return 0;
  return num / den;
}
function shuffle(array) {//also borrowed
  var currentIndex = array.length, temporaryValue, randomIndex;
  while (0 !== currentIndex) {
    randomIndex = Math.floor(Math.random() * currentIndex);
    currentIndex -= 1;
    temporaryValue = array[currentIndex];
    array[currentIndex] = array[randomIndex];
    array[randomIndex] = temporaryValue;
  }
  return array;
}
</script>

3

JavaScript / SVG - sunDialsort

Giải pháp này không sử dụng các bộ so sánh <, <=,> hoặc> =. Tôi đã cố gắng làm cho nó đọc giống như một hàm sắp xếp nhất có thể.

phương pháp

  • Vẽ các giá trị dưới dạng các chấm dọc theo một vòng cung.
  • Đối với một mảng tăng dần, mỗi giá trị sẽ làm cho tổng chiều rộng của bản vẽ rộng hơn và không làm giảm X bắt đầu (ngoại trừ: hai giá trị giống hệt nhau).
  • Khi chiều rộng không thể thu hẹp a! = Sẽ đủ,
  • Vì X không thể tăng == sẽ đủ.
  • để sửa cho hai giá trị giống hệt nhau, mỗi dấu chấm thực sự là một dòng, có độ dài tăng dần. Trong đó độ dài đơn vị nhỏ hơn 1 / số giá trị.

Trolling

Tôi đã thêm những khuôn mặt sau đây trong suốt hành trình đọc mã rất tệ này.

  • Hàm có thể trông giống như sắp xếp mảng, đặt tên là sunDialsort (thưởng viết hoa xấu)
  • sử dụng tham chiếu lit-geek cho tất cả các tên biến
  • đã sử dụng búa regex để đếm số phần tử trong mảng
  • đã sử dụng một hộp cảnh báo
  • giải pháp cho trường hợp cạnh trong đó 2 biến liên tiếp có cùng số lượng mã gấp đôi (một lớp lót có thể đã sắp xếp nó), đặt nhiều mã này sớm để gây nhầm lẫn cho mục đích của hàm.
  • thay vì tìm min và max tìm số dài nhất và làm tròn đến sức mạnh tiếp theo của mười, hy vọng điều này sẽ khiến mọi người bỏ qua mùi hương.

xml

<body>
<svg id="dial" height="400" width="400" transform=""></svg>
</body>

chức năng

sunDialsort = function (values)
{
    var twas = values.toString();  
    var brillig = twas.match(/,/g).length + 1; //<1>
    //find the sig figs we are working with (longest number)
    var and = [], the = 0;
    for (var jabberwock = 0; jabberwock < twas.length; jabberwock++)
    {
        switch (twas.charAt(jabberwock))
        {
        case ("."):
            break; //dont count
        case (","):
            and.push(the);
            the = 0;
            break;
        default:
            the++;
        }
    }
    and.push(the);
    var slithy = Math.max.apply(Math, and);
    //assume did/toves based on number of characters
    var toves = Math.pow(10, slithy);
    var did = toves * -1;
    console.log(did + "," + toves + "," + brillig);
    //for each number make a horizontal svg line of length (jabberwock*acuuracy)     
    var gyre = 1 / brillig;
    var gimble, wabe, all, mimsy, were, borogoves, mome, raths;
    var outgrabe = true;
    for (jabberwock = 0; jabberwock < brillig; jabberwock++)
    {
        gimble = document.createElementNS('http://www.w3.org/2000/svg', 'path');
        gimble.setAttribute("stroke", "blue"); //green is not a creative colour
        gimble.setAttribute("d", "M0 20 h " + (jabberwock * gyre));
        wabe = (values[jabberwock] - did) / (toves - did);
        mimsy = 90 - (wabe * 180);
        gimble.setAttribute("transform", "rotate(" + mimsy + ")");
        document.getElementById("dial").appendChild(gimble);
        borogoves = document.getElementById("dial").getBBox();
        if (mome)
        {
            raths = (borogoves.width != all && were == borogoves.x);
            console.log("test " + raths);
            all = borogoves.width;
            if (!raths)
            {
                outgrabe = false
            }
        }
        else
        {
            were = borogoves.x;
            all = borogoves.width;
            mome = true;
        }
    }
    return outgrabe
};
alert(sunDialsort([1, 2, 3, 3, 4341, 556]));

Nếu bất cứ ai muốn kiểm tra thì có một phiên bản ở đây với tên biến có thể đọc được. http://jsfiddle.net/outRideACrisis/r8Awy/


3

C

Vì tìm kiếm nhị phân chỉ hoạt động trên các mảng được sắp xếp, để kiểm tra xem một mảng có được sắp xếp hay không, tất cả những gì chúng ta cần làm là xác minh rằng tìm kiếm nhị phân hoạt động cho tất cả các thành phần của mảng. Nếu không tìm thấy phần tử nào, chúng ta biết mảng không được sắp xếp.

Tất cả các đối số dòng lệnh được truyền phải là số nguyên thập phân mà không có số 0 đứng đầu.

#include <stdlib.h>
#include <string.h>

int compar(const void *a, const void *b) {
  char *const *sa = a, *const *sb = b;
  int cmp = strlen(*sa) - strlen(*sb);
  if (cmp == 0) cmp = strcmp(*sa, *sb);
  if (cmp == 0) cmp = sa - sb;
  return cmp;
}

int main(int argc, char *argv[]) {
  if (argc-- && argv++) {
    for (int i = 0; i != argc; i++) {
      if (bsearch(argv+i, argv, argc, sizeof *argv, compar) != argv+i) {
        return 1;
      }
    }
  }
  return 0;
}

3

Javascript

a = prompt("Please enter the data");
r = prompt("Does your array arouse moral distaste and contempt?");
if ((/yes/i).test(r))
  alert("The array is sordid.");

1
{ 69 , 313 , 187 , 31338 }
Geobits

2

C

  • Tạo một bản sao của mảng
  • sắp xếp các bản sao theo thứ tự giảm dần
  • kiểm tra xem mảng này có ngược lại với mảng đã cho không
    #include<stdio.h>
    #include<stdlib.h>
    #include <stddef.h>
    #include<string.h>
    int main(){
     int arr[100],i,j,temp;
     int a[] = {1,2,3,4,5,6,7,8,9,10};
     char b[256];

     printf("Loading the program please wait...");
      int s = sizeof(a)/sizeof(a[0]);
     for(i=0; i<999999999; i++);//best way to make the program more realistic
     system("cls");

     for(i=0;i<s; i++ )
     arr[i] = a[i];

     for(i=0;i<s;i++){
          for(j=i;j<s;j++){
               if(arr[i] < arr[j]){
               temp=arr[i];
               arr[i]=arr[j];
               arr[j]=temp;
               }
           }
     } //sorting array in descending order

     int p = 0;
     for(i=0; i<s; i++)
     {
         if (a[s-i-1] != arr[i])
         p++;
     }

     if(p>0)
     printf("No");
     else
     printf("yes");
     getch();


     }

2

Toán học

Thuật toán này có vẻ hoạt động, nhưng nó hơi chậm. Có thể có nhiều cách nhanh hơn để sắp xếp nhưng tôi không tìm thấy chúng.

  1. Thực hiện một thứ tự ngẫu nhiên của danh sách và kiểm tra xem nó theo thứ tự (với OrderedQ).
  2. Nếu có, dừng lại. Nếu không, lặp lại bước 1.

Đoạn mã sau đã sắp xếp danh sách chỉ trong hơn 18 giây.

a = {23, 50, 16, 57, 19, 60, 40, 7, 30, 54};
n = 1;
Timing[While[! OrderedQ[a], a = RandomSample[a]; n++]]
n
a

{18.581763, Null}
8980699
{7, 16, 19, 23, 30, 40, 50, 54, 57, 60}


Nhiệm vụ là kiểm tra xem đầu vào đã được sắp xếp chưa.
Ilmari Karonen

Đây là ý tưởng thiết yếu đằng sau giải pháp của tôi (mặc dù, tôi sử dụng thời gian bậc hai OrderedQchỉ dành cho những cuộc vui) với phần kiểm tra được thêm vào cuối "bây giờ chúng tôi đã có một sắp xếp, đó có phải là những gì chúng tôi bắt đầu không?"
gian hàng

2

JavaScript

function isSorted(arr) {
    if (arr.length === 1 && typeof arr[0] !== 'number' || arr[0].toString().indexOf('.') !== -1 || arr[0] > (-1 >>> 0) || arr[0] !== arr[0] || arr[0] === Infinity) {
        // Return false in the case of one non-number element.
        // isSorted returns false for arrays containing non-numbers for consistency
        // with PHP, but that doesn’t work for one element, so that’s the purpose
        // of this check.
        return false;
    }

    var obj = {};
    var i;

    for (i = arr.length; i--;)
        obj[arr[i]] = true;

    for (var x in obj)
        if (arr[++i] != x) return false;

    return true;
}

Chức năng này có thể trả về falsekhông chính xác, nhưng không phải trên các trình duyệt hiện đại; bạn có thể kiểm tra điều này và cung cấp dự phòng chậm hơn (như được mô tả trong câu hỏi) nếu cần:

var isModern = /chrome/i.test(typeof navigator === 'object' && navigator.userAgent);

if (!isModern) {
    isSorted = function() {
        // I develop on good browsers, so the implementation is left as an exercise
        // to the reader if he or she wants to support outdated browsers.
    };
}

Họ nói rằng điều này mang lại kết quả không thể đoán trước về những con số âm, nhưng điều thực sự quan trọng là bạn dự đoán được mọi thứ tốt như thế nào.


2
Tôi ước Chrome sẽ xáo trộn các thuộc tính đối tượng để ngăn mọi người làm những việc như thế này
Bergi

2

Java (Khoảng cách Levenshtein)

Trong triển khai này, tôi sao chép mảng ban đầu và sắp xếp thể hiện nhân bản. Sau đó, khoảng cách Levenshtein được tính toán. Nếu nó bằng 0, thì mảng ban đầu đã được sắp xếp.

Lưu ý: Việc triển khai getLevenshteinDistance () được lấy từ Jakarta Commons Lang và được sửa đổi để hoạt động trên int [] thay vì CharSequence.

import java.util.Arrays;

public class CheckSorting {

    public boolean isSorted(int[] array) {
        int[] sortedArray = Arrays.copyOf(array, array.length);
        Arrays.sort(sortedArray);

        return CheckSorting.getLevenshteinDistance(array, sortedArray) == 0;
    }

    public static int getLevenshteinDistance(int[] s, int[] t) {
        int n = s.length;
        int m = t.length;

        if (n == 0) {
            return m;
        } else if (m == 0) {
            return n;
        }

        if (n > m) {
            int[] tmp = s;
            s = t;
            t = tmp;
            n = m;
            m = t.length;
        }

        int p[] = new int[n + 1];
        int d[] = new int[n + 1];
        int _d[];

        int i;
        int j;

        int t_j;

        int cost;

        for (i = 0; i <= n; i++) {
            p[i] = i;
        }

        for (j = 1; j <= m; j++) {
            t_j = t[j - 1];
            d[0] = j;

            for (i = 1; i <= n; i++) {
                cost = s[i - 1] == t_j ? 0 : 1;
                d[i] = Math.min(Math.min(d[i - 1] + 1, p[i] + 1), p[i - 1] + cost);
            }

            _d = p;
            p = d;
            d = _d;
        }
        return p[n];
    }
}
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.