วิธี“ สร้างสรรค์” เพื่อกำหนดว่าจะเรียงลำดับอาร์เรย์หรือไม่


51

รับอาร์เรย์จำนวนเต็มเขียนโปรแกรมที่กำหนดว่าจะเรียงตามลำดับจากน้อยไปหามาก

โปรดจำไว้ว่านี่เป็นคำถามการหมุนรหัส

ฉันกำลังมองหาวิธีที่น่าสนใจที่สุดที่ผู้คนคิด

คำตอบที่มีผู้โหวตมากที่สุดเป็นผู้ชนะ

คำถามนี้ได้รับแรงบันดาลใจจากคำตอบ 'สร้างสรรค์' ที่ผู้สมัครให้สัมภาษณ์กับฉัน :)


โซลูชัน 'สร้างสรรค์' เป็นดังนี้:

  • เพราะสำหรับอาร์เรย์ที่เรียงลำดับ

    • องค์ประกอบทั้งหมดทางด้านซ้ายขององค์ประกอบใด ๆ จะต้องมีขนาดเล็กลง
    • องค์ประกอบทั้งหมดทางด้านขวาขององค์ประกอบใด ๆ จะต้องใหญ่กว่า

ดังนั้นให้เรียกใช้ลูปหลักสำหรับองค์ประกอบทั้งหมดและตรวจสอบเงื่อนไขสองข้อข้างต้นโดยการรันลูปซ้อนกันสองลูปภายในหนึ่งหลัก (หนึ่งสำหรับด้านซ้ายและอีกหนึ่งสำหรับด้านขวา)

ฉันช็อค !!


58
สิ่งนี้ไม่ซ้ำกัน ผู้ดำเนินรายการบางคนรู้สึกว่าจำเป็นต้องทำเครื่องหมายคำถามทุกคำถามซ้ำซ้อนกับคำถามอื่นโดยไม่ได้อ่าน นี่ไม่ใช่คำถามการเรียงลำดับเลย อ่านมัน
microbian

3
ในตอนท้ายของการประกวดฉันต้องการทราบวิธี "สร้างสรรค์" ด้วยเช่นกัน! :)
Vereos

16
ผู้ดูแล @micro Diamond ได้รับเลือกจากชุมชน คุณกำลังสับสนผู้ดูแลด้วยระบบสิทธิ์
Doorknob

3
@microbian คุณจ้างผู้ชายคนนั้นแล้วเหรอ?
VisioN

3
ถ้าเฉพาะ StackExchange API ที่อนุญาตให้เข้าถึงการเขียนฉันจะถามคำถาม "อาร์เรย์นี้เรียงลำดับหรือไม่" และนับ upvotes สำหรับคำตอบบวก / ลบ ..
Michael Foukarakis

คำตอบ:


77

ทับทิม

ทุกคนรู้: การเรียงลำดับช้ามากและใช้เวลาหลายรอบ (สิ่งที่ดีที่สุดที่คุณสามารถทำได้คือบางอย่างด้วยn log(n)) ดังนั้นจึงค่อนข้างง่ายในการตรวจสอบว่ามีการเรียงลำดับอาร์เรย์หรือไม่ สิ่งที่คุณต้องทำคือการเปรียบเทียบรันไทม์ของการเรียงลำดับอาเรย์และการเรียงลำดับอาเรย์

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
ขึ้นอยู่กับอัลกอริทึมการเรียงลำดับ การเรียงลำดับการผสานหรือการเรียงลำดับฮีปจะไม่แสดงความแตกต่างใด ๆ เลยโดยไม่ขึ้นกับว่าเรียงลำดับแล้วหรือไม่
Niklas B.

4
@NiklasB ทับทิมใช้ quicksort ที่กล่าวว่าวิธีนี้จะยุ่งยากและให้ผลบวกผิดเมื่ออาร์เรย์ของอินพุตนั้นเกือบจะเรียงลำดับหรือมีแนวโน้มมากกว่าที่จะเป็น false negatives เมื่ออาร์เรย์นั้นถูกเรียงลำดับ (มันจะไม่น่าเป็นไปได้treference <= trunสำหรับทุกกรณี . ในทางทฤษฎีดูเหมือนว่าคุณจะได้รับค่าลบเชิงลบประมาณ 50% สำหรับกรณีที่เรียงลำดับ
Jason C

6
ความคิดที่น่าสนใจ แต่ไม่ได้กำหนด มันเกี่ยวกับดีเท่าที่จะทำได้สิบ push ups แล้ว pushups อีกสิบแล้วตัดสินใจว่าอาร์เรย์แรกถูกเรียงหรือไม่เพราะหนึ่ง sweat เพิ่มเติมในชุด pushups ที่สอง เราลืมรหัสที่เราเรียกใช้บนเครื่องมัลติทาสกิ้งหรือไม่? นอกจากนี้ในอาร์เรย์ขนาดเล็กมากชิ้นเวลาก็ไม่แม่นยำพอ +1 สำหรับความพยายามป่า!
LMSingh

1
@NiklasB Timsort (ตัวแปรของการผสาน) ทำงานในเวลาเชิงเส้นบนอาร์เรย์ที่เรียงลำดับ (และเรียงลำดับบางส่วน)
Bakuriu

3
@ JasonC - เป็นที่น่าสังเกตว่าสิ่งนี้ทำให้การดำเนินการข้างต้นน่าสงสัยมากขึ้น: มันอาศัยไม่เพียง แต่ความรู้ที่ว่าอัลกอริทึมการเรียงลำดับภายในของ ruby ​​เป็นแบบด่วน (ซึ่งไม่มีอยู่ในตัวของมันเอง ได้รับการปรับให้เหมาะสมสำหรับกรณีของข้อมูลที่เรียงลำดับแล้ว (ซึ่ง quicksort โดยค่าเริ่มต้นไม่ใช่: quicksort เป็นเพียง O (n log n) บนเคสโดยเฉลี่ย ... ประสิทธิภาพของเคสที่แย่ที่สุดคือ O (n ^ 2) และในการติดตั้งที่ไร้เดียงสา กรณีที่เลวร้ายที่สุดกำลังถูกเรียกใช้กับข้อมูลที่เรียงลำดับแล้ว)
Jules

52

จาวาสคริ

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 JQuery ไม่เพียงพอ
Pierre Arlaud

3
ฉันมีความคิดคล้าย ๆ กันที่จะขออาเรย์แล้วก็แจ้งทีละคน "นี่ใหญ่กว่านี้ไหม" และถ้าทั้งหมดเป็นจริงอาร์เรย์ก็จะถูกจัดเรียง
Zach Thacker

41

Java - ชุดย่อยแบบเรียกซ้ำ

ยินดีต้อนรับสู่ Stack Overflow! นี่เป็นคำถามแรกที่ยอดเยี่ยมเพราะมันมีแม้แต่ตัวเขียนรหัสมืออาชีพ ให้ฉันให้ข้อมูลพื้นหลังเล็กน้อยก่อนที่ฉันจะส่งรหัส:

การแยกแยะความแตกต่างอาจเป็นงานที่ยากเมื่อเหลือบมองครั้งแรก สำหรับชุดของความยาว n มี n! วิธีการสั่งซื้อที่เป็นไปได้ เหล่านี้เรียกว่าพีชคณิต หากอาร์เรย์ของคุณมีองค์ประกอบที่แตกต่างกันมีเพียงหนึ่งในความเป็นไปได้ที่จะถูกจัดเรียง! ในการหาอันที่เรียงคุณต้องร่อนผ่านพวกมันทั้งหมดจนกว่าคุณจะพบอันที่ถูกต้อง

อะไร? แน่นอนมันไม่ยากอย่างนั้น ...

อัลกอริทึมด้วย n! ความซับซ้อนใช้เวลานานสำหรับอินพุตที่มากขึ้น แต่ด้วยการทำงานเล็กน้อยเราสามารถแก้ไขได้และย้ายความซับซ้อนลงไปทั้งหมด นั่นยังคงเป็นเวลาที่อธิบาย แต่มันดีกว่าแฟกทอเรียล

ในการทำเช่นนี้เราจำเป็นต้องพิจารณาข้อเท็จจริงทางคณิตศาสตร์ต่อไปนี้: หากมีการจัดเรียงอาร์เรย์แล้วทุกชุดย่อย (เรียงลำดับค่อนข้าง) จะถูกจัดเรียงเช่นกัน คุณสามารถขอให้ผู้เชี่ยวชาญทางคณิตศาสตร์ทำการพิสูจน์อย่างเป็นทางการ แต่มันเป็นความจริงโดยสัญชาตญาณ ยกตัวอย่างเช่นสำหรับการตั้งค่าการย่อยที่เหมาะสม123 1 2 3 12 13 23คุณสามารถเห็นพวกเขาทั้งหมดได้รับคำสั่ง ทีนี้ถ้าเป็นต้นฉบับ213คุณก็มี2 1 3 21 23 13และทันทีที่คุณเห็นว่า21มันไม่เป็นระเบียบ

เหตุผลที่สำคัญคือเพราะมีจำนวนน้อยกว่า n! ส่วนย่อย อันที่จริงมีเซตย่อยเพียง 2 n -2 เท่านั้นที่เราต้องดู เราสามารถยกเว้นชุดที่มีทั้งอาร์เรย์ของตัวเลขดั้งเดิมรวมถึงชุดเปล่า

ถึงกระนั้น 2 n -2 ก็สามารถทำงานได้มากมาย เช่นเดียวกับสิ่งส่วนใหญ่ที่เกินเวลาพหุนามวิธีการแบ่งและพิชิตทำงานได้ดีที่นี่ วิธีที่ง่ายที่สุด? เรียกซ้ำ !

ขั้นตอนพื้นฐานง่าย ๆ สำหรับทุกชุดย่อยของอินพุตของคุณคุณสร้างชุดย่อยที่เล็กกว่า จากนั้นสำหรับแต่ละคนคุณทำสิ่งเดียวกัน เมื่อชุดย่อยของคุณมีขนาดเล็กลง 2 คุณเพียงแค่ตรวจสอบว่าชุดย่อยใดมีขนาดใหญ่กว่า เนื่องจากคุณย่อขนาดของชุดย่อยแต่ละครั้งจริง ๆ แล้วมันจะเร็วกว่าที่คุณคาดไว้

ข้อเท็จจริงสำคัญที่นี่คือคุณสามารถออกก่อนกำหนดได้ทันทีที่คุณพบชุดย่อยหนึ่งชุดที่ไม่เป็นระเบียบ คุณไม่ต้องค้นหาพวกเขาทั้งหมด ถ้ามีคนไม่ดีทั้งกลุ่มก็ไม่ดี นี่เป็นการพิจารณาความเร็วที่คุณไม่เห็นในคำตอบอื่น ๆ มากมาย

พอคุยกันได้รหัส!

ฉันทำสิ่งนี้ในJavaเนื่องจากเป็นภาษายอดนิยมและอ่านง่าย ความสง่างามของการเรียกซ้ำควรชัดเจน:

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;
    }
}

สำหรับบันทึกนั้นฉันเบื่อแล้วก็ฆ่ามันหลังจากรอ 15 นาทีสำหรับอาร์เรย์ 12 องค์ประกอบที่เรียงลำดับแล้ว มันจะทำ 11 องค์ประกอบในเวลาประมาณ 45 วินาที แน่นอนว่ามันจะออกก่อนหน้านี้จริงๆสำหรับการไม่เรียงลำดับดังนั้นนั่นคืออืมดี

อัปเดต: ในการรีบูตใหม่จะทำ 12 องค์ประกอบใน 13 นาที 13 ใช้เวลาเกือบ 3 ชั่วโมงและ 14 อยู่ที่ 20 ชั่วโมงและนับ


8
+1 นี่อาจเป็นอัลกอริทึมที่มีประสิทธิภาพน้อยที่สุดที่ฉันเคยเห็น ควรอยู่ที่ O (n! * 2 ^ (n!)) - ความซับซ้อน (อาจแย่กว่า)
Ral Zarek

6
ฉันแน่ใจว่าฉันเห็นว่าแย่ลง แต่มันก็ค่อนข้างแย่ ผมครึ่งใจพยายามที่จะตรวจสอบความซับซ้อน O(big)แต่ให้ขึ้นและเรียกมันว่า
Geobits

1
การนำเสนอโซลูชันที่มีประสิทธิภาพน้อยกว่าแม้ความพยายามที่ไร้เดียงสาของปัญหาพนักงานขายการเดินทางก็น่าประทับใจ!
recursion.ninja

3
เนื่องจากโอกาสที่อาร์เรย์เรียงลำดับ 12 องค์ประกอบมีเพียง 1 ใน 479 ล้านเท่านั้นมันไม่สำคัญว่าจะต้องใช้เวลาสักพักกว่าจะแน่ใจได้ว่าเป็นจริงหรือไม่ คุณไม่เคยมีโอกาสได้เห็นจริงในโลกแห่งความเป็นจริง ...
Jules

2
@Geobits ไม่มีปัญหา เรียกใช้อัลกอริธึมของ Victorและตอบว่า "ใช่" ที่พรอมต์แรก
Jason C

29

C ++ - วิธีการดุร้าย

ทุกคนรู้ว่าวิธีการเดรัจฉานบังคับเร็วที่สุดเสมอ

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];
  }
}

รูทีนที่แท้จริงยาวกว่า (ไปถึง std :: npos) แต่ฉัน จำกัด ไว้ที่ 30,000 ตัวอักษรในการโพสต์ที่นี่


ฉันชอบสิ่งนี้มาก
Jakob

3
นี่เป็นเหมือนวิธีการ "ใช้ทุกส่วนของควาย" เพื่อเรียกใช้คำสั่ง case
Jonathan Van Matre

นี่มันเจ๋งมาก. คลี่วงทั้งหมด!
McKay

ความคิดที่ดี !!!
bikram990

26

แจ้ง

Inform เป็นภาษาสำหรับการเขียนเกมเชิงโต้ตอบสำหรับล่าม Infocom Z-machine คลาสสิก เพื่อหลีกเลี่ยงสปอยเลอร์ฉันจะให้ผลลัพธ์ของโปรแกรมเป็นอันดับแรกจากนั้นจึงซอร์สโค้ด

แก้ไข: ฉันทำการแก้ไขเล็กน้อยเพื่ออนุญาตให้เพิ่มตัวเลขในอาร์เรย์และรวมคำอธิบายห้องที่มีเสน่ห์

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!" 

และพร้อมด้วยรหัสที่มา:

"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

ก่อนอื่นคุณต้องเรียกใช้รหัสการตั้งค่านี้

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

จากนั้นให้เก็บอาร์เรย์ไว้ในตัวแปรที่เรียกcodingใช้และเรียกใช้:

  very coding

                 many ruby
so algorithm


      wow

และคำตอบของคุณจะถูกพิมพ์ (จริงหรือเท็จ)

โปรดเพิ่มรหัส doge เพื่อประสิทธิภาพที่ดีที่สุด:

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

นี่เป็นวิธีที่ง่ายที่สุด


(ศิลปะ ASCII สร้างขึ้นโดยสคริปต์ที่ฉันเขียนขึ้นมาจากภาพนี้)


7
คุณลืม "ดังนั้นอัลกอริทึม" ตัวอย่าง Doge จริงมี 3 ประโยคก่อน "ว้าว" และใช่ฉันสนุกมากในงานปาร์ตี้
Pierre Arlaud

@ArlaudPierre Heh, ok, fixed: P
Doorknob

11
ดังนั้นความคิดเห็นการปรับปรุงมากมีประโยชน์มากมาย ว้าว.
Pierre Arlaud

คุณควรจะเขียนโปรแกรม BF ในรูป ASCII เหมือน doge ... แนวคิดคำถามใหม่ !!
TheDoctor

19

PHP

คุณจะรักความง่ายและความตรงไปตรงมาของวิธีแก้ปัญหาต่อไปนี้ แนวคิดโดยรวมและฟังก์ชั่นล้ำสมัยที่ใช้ในการเข้ารหัสชิ้นเอกนี้จะนำคุณไปสู่รายชื่อนักพัฒนาชั้นนำของโลกทันที

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 เนื่องจากคุณใช้แนวคิดเดียวกันกับคำตอบของฉันสำหรับคำถามการเรียงลำดับ
Victor Stafusa

4
สิ่งนี้จะได้ผลหรือไม่ถ้านาง Robertsเข้าสู่คุณค่า?
user80551

3
@ user80551 ใช่เพราะไม่มีโต๊ะที่เรียกว่านักเรียน
วงล้อประหลาด

3
@JanathanVanMatre แน่นอนว่าการรักษาความปลอดภัยเป็นหนึ่งในส่วนที่แข็งแกร่งที่สุดของรหัสนี้
VisioN

1
นี่คือคำตอบที่ฉันโปรดปรานในเว็บไซต์นี้; แต่สำหรับเครื่องหมายพิเศษฉันชอบที่จะเห็นคุณใช้ PDO เพื่อความปลอดภัย
alexandercannon

17

C # - พลังของสถิติ

สิ่งที่คุณต้องทำเพื่อแก้ปัญหานี้คือการกำหนดกรอบคำถามใหม่ในลักษณะที่ทำให้การแก้ปัญหาชัดเจน เพราะนี่เป็นคำถามประเภท "จริงเท็จ" สิ่งที่คุณถามเป็นหลักคือ "ฉันจะแน่ใจได้อย่างไร 100% ว่ามีการเรียงลำดับอาร์เรย์อย่างไร" หากคำหนึ่งปรากฏออกมาจากคำถามนั้นมันเป็นคำว่า "แน่นอน" วิธีที่ดีที่สุดในการวัดความเชื่อมั่นคืออะไร? คุณเข้าใจแล้ว: สถิติ

คำตอบอื่น ๆ ที่นี่ตรวจสอบเพียงเพื่อดูว่าอาร์เรย์จะเรียงในทิศทางเดียว โซลูชันนี้ทดสอบทั้งลำดับขึ้นและลงในเวลาเดียวกัน เคล็ดลับคือการใช้อาร์เรย์ที่มีขนาดเดียวกันกับที่คุณทราบแล้วว่ามีการเรียงลำดับ (ง่ายต่อการสร้างด้วยตัวคุณเอง) จากนั้นค้นหาว่าการเรียงลำดับของแต่ละอาร์เรย์นั้นมีความสัมพันธ์กันอย่างไร การคำนวณสัมประสิทธิ์สหสัมพันธ์เคนดัลล์เอกภาพเป็นวิธีที่ง่ายที่สุดในการทำสิ่งนี้:

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";
            }
        }
    }
}

เอาท์พุท:

Unsorted
Sorted
Sorted

ฟังก์ชั่นนี้ยังง่ายมากในการขยายฟังก์ชั่นการใช้งานเพราะมันไม่สำคัญที่จะเพิ่มฟังก์ชั่นเช่น "เรียงลำดับส่วนใหญ่" หรือ "เรียงลำดับมากกว่าไม่" หรือ "สุ่มโดยสมบูรณ์"

แก้ไข

เกือบลืมไปกว่าประสิทธิภาพของอัลกอริทึม นี่คือ O (7) มีหนึ่งในชื่อเมธอดหนึ่งรายการในแต่ละคีย์เวิร์ด "for" หนึ่งคำในการประกาศ "double" และสองคำในการใช้ตัวแปร "sortness" คุณสามารถปรับปรุงสิ่งนี้ได้ตลอดจนถึง O (0) (ซึ่งต่ำที่สุดเท่าที่จะทำได้) โดยเปลี่ยนชื่อฟังก์ชั่นเปลี่ยน double เป็นทศนิยมโดยแยก "sortness" เป็น "srtdnss" และแปลงลูปเป็น ในขณะที่ลูป


2
ฉันพยายามคำนวณความซับซ้อนซ้ำซากและกำหนดให้เป็น O (8) คุณกำลังส่งสัญญาณออกซึ่งฉันเชื่อว่าควรคำนึงถึงหากต้องการความซับซ้อน O (7) อย่างแท้จริงคุณอาจลองส่งคืน "เรียงจากน้อยไปมาก" / "ส่งเดช" แทนที่จะเป็น "เรียงลำดับ" / "ไม่เรียงลำดับ"
Geobits

@Geobits - ฉันดูอีกครั้งและแน่นอนว่าคุณถูกต้อง ฉันเดานี้แสดงให้เห็นว่ามีความซับซ้อนขั้นต่ำของ O (1) เมื่อส่งคืนสตริง นี่เป็นราคาเล็ก ๆ ที่ต้องจ่ายเพราะการส่งคืนบูลีนนั้นแย่เป็นสองเท่า
Comintern

1
+1 สำหรับการคำนวณ O () -1 สำหรับการไม่ใช้การคำนวณ Spearman rho ด้วยเพราะสอง correlations ดีกว่าหรือไม่ และ +1 สำหรับสถิติใน C # ซึ่งเป็นที่ชื่นชอบของนักสถิติที่พิสูจน์แล้ว
Jonathan Van Matre

โปรดบอกฉันว่าO(7)เรื่องตลกเป็นอย่างไร
mbatchkarov

@matchkarov - มันเป็นสัญกรณ์ O น้อย :-)
Comintern

16

ทับทิม

กลยุทธ์ต่อไปนี้จะเปิดเผยหากมีการเรียงลำดับอาเรย์:

  1. Aเป็นอาร์เรย์ (เรียงลำดับหรือไม่เรียงเช่น [1,2,3] หรือ [1,3,2])
  2. Pเป็นอาร์เรย์ที่เก็บพีชคณิตทั้งหมดของA
  3. ถ้าAถูกเรียงลำดับมันเป็นPสูงสุดหรือต่ำสุด(ซึ่งโดยทั่วไปเป็นรุ่นที่เรียงลำดับของAใน Ruby)

รุ่นออนไลน์สำหรับการทดสอบ

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

1
ฉันไม่คิดว่าฉันเข้าใจคำอธิบาย ถ้าอาร์เรย์อยู่เช่น [1, 9, 100] ดังนั้นค่าต่ำสุดคือ 1,1919 และค่าสูงสุดคือ 91100 แต่จำนวนที่เรียงคือ 19100 การเล่นกับเวอร์ชันออนไลน์สูงสุดคือ [100,9,1] และ min คือ [1,9,100] ฉันไม่เห็นว่ามีสิ่งใดที่ "แทนจำนวน"; ดูเหมือนว่าอาร์เรย์นั้นเพิ่งถูกสั่งให้ทำพจนานุกรม นี่คงเหมือนกันถ้าสมมุติว่าตัวเลขทั้งหมดมีเพียงหนึ่งหลัก
Joshua Taylor

"... ทั้งสูงสุดหรือต่ำสุด ... " ชอบมาก
microbian

@JoshuaTaylor: ขอบคุณสำหรับหัวขึ้น! ผมอยากจะอธิบายมันในทางที่เข้าใจได้ง่าย - ซึ่งจบลงด้วยการที่ผิดธรรมดา;) ฉันแก้ไขคำอธิบายของฉัน ...
เดวิดมานน์

2
@JoshuaTaylor วิธี ruby ​​Array # max และ #min เลือกองค์ประกอบที่ใหญ่ที่สุดและเล็กที่สุดโดยคำนึงถึงตัวดำเนินการ <และ> ในอาร์เรย์ <และ> ใช้การเรียงลำดับพจนานุกรม [1,9,100] เป็นจำนวนขั้นต่ำของการเรียงสับเปลี่ยนทั้งหมดของ 1, 9 และ 100 ในการเรียงลำดับพจนานุกรม
Karl Damgaard Asmussen

เกือบคุณภาพการผลิต
primo

12

C # - โซลูชันที่ไม่ได้กำหนดค่า

รหัสนี้อาจใช้งานได้

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 ^ 2 * ln (1-p) คุณสามารถมั่นใจได้ว่ามีความน่าจะเป็น p ที่จะตรวจสอบชุดค่าผสมทั้งหมด!
Hannesh

และค่าใดของ p ที่ถูกต้องสำหรับวิธีการนี้ที่จะยอมรับว่าเป็น "รหัสการทำงาน แต่หมุนรอบ" :)
fejesjoco

2
จากstackoverflow.com/questions/2580933โอกาสของการคำนวณผิดเนื่องจากรังสีคอสมิกจะเท่ากับ 0.0000018 (1.8e-6) ทุกวินาที ดังนั้นถ้า: 1) คุณสามารถคิดได้ว่าการวนซ้ำใช้เวลานานแค่ไหน 2) เราสามารถใช้สูตรของ @Hannesh เพื่อคำนวณความน่าจะเป็นจากนั้นจึงแก้ระบบสมการเพื่อหาจำนวนการวนซ้ำที่ทำให้โซลูชันของคุณแยกไม่ออกจาก มาตรฐาน isSorted วิธี
Xantix

11

หลาม

หากรายการถูกเรียงลำดับทุกหมายเลขจะน้อยกว่าหรือเท่ากับจำนวนถัดไป ดังนั้นการลบจำนวนซ้ายสุดจะทำให้ค่าเฉลี่ยสูงขึ้นมิฉะนั้นรายการจะไม่ถูกจัดเรียง เราจะใส่นี่ในการวนรอบเพื่อตรวจสอบแต่ละหมายเลข

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_sorted ([1,2,3]) #True
is_sorted ([3,2,1]) #False
is_sorted ([1,4,3,2,0,3,4,5]) #False


ผู้อ่านช่างสังเกตจะสังเกตเห็นว่ามันไม่ทำงานอย่างนั้น
is_sorted ([1,4,3,2,0,3,4,11]) #False
is_sorted ([1,4,3,2,0,3,4,12]) #True
is_sorted ([1,2 , 1,2,1,2,1,2,99]) #True


9

ทุบตี

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/*

แตะที่ไฟล์สำหรับแต่ละองค์ประกอบในอาร์เรย์ ls ไดเรกทอรีและเปรียบเทียบผลลัพธ์ ls กับอาร์เรย์เดิม

ฉันไม่ค่อยดีกับทุบตีฉันแค่อยากลองทำ :)


สิ่งที่ดีนี้ถือว่าไดเรกทอรี "./nums" มีอยู่แล้ว อาจจะเป็น "mkdir -p nums" ที่ไหนสักแห่ง?
camelthemammel

โอ้ใช่แล้วมีเหตุผล: P
Zach Thacker

8

C #

ความคิดของ "ขนาดเล็ก" หรือ "ใหญ่กว่า" มีมาก 2013 โปรแกรมเมอร์จริงใช้ตัวmoduloดำเนินการเท่านั้น!

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;
}

เกิดอะไรขึ้นถ้าหมายเลขเดียวกันปรากฏขึ้นสองครั้ง จากนั้นระบุ [i]% รายการ [i + 1] == 0
Simon

@Simon Oh ho! แน่นอนฉันเดาว่ามีตัวเลขที่เหมือนกันสองตัวเรียงกัน เพิ่มการเปรียบเทียบสำหรับเคสขอบนี้ ยินดีที่ได้พบ
Pierre-Luc Pineault

5
ดีใจที่ได้ทราบว่า {0, -1, 2} เป็นรายการที่เรียงลำดับแล้ว
Pierre Arlaud

9
@ArlaudPierre หากคุณต้องการเป็นโปรแกรมเมอร์ 2014 ตัวจริงคุณต้องละทิ้งทุกอย่างที่เป็นลบ โลกเป็นบวกโลกสมบูรณ์แน่นอนโลกโมดูโล่!
Pierre-Luc Pineault

1
เนื่องจากคุณไม่ชอบแนวคิดของ "ใหญ่กว่า" และ "เล็กกว่า" มันเป็นความอัปยศที่คุณต้องรวมสัญญาณที่น้อยกว่าและยิ่งใหญ่กว่า คุณควรใช้อาร์เรย์แทนรายการ
Mr Lister

8

สกาล่า

ตรวจสอบว่าเรียงลำดับเป็นเรื่องง่าย! ตรวจสอบว่าองค์ประกอบแรกน้อยกว่าองค์ประกอบที่สองหรือไม่ จากนั้นเรียงลำดับส่วนที่เหลือและดูว่ามันเท่ากันหรือไม่

น่าเสียดายที่การเรียงลำดับเป็นปัญหาที่ยาก อัลกอริธึมที่รู้จักกันดีหรือมีประสิทธิภาพไม่มากนักสำหรับการเรียงลำดับอาเรย์ ในความเป็นจริงมันเป็นจุดบอดขนาดใหญ่ในสถานะปัจจุบันของความรู้ด้านวิทยาศาสตร์คอมพิวเตอร์ ดังนั้นฉันจึงเสนออัลกอริธึมง่ายๆ: สลับอาเรย์แล้วตรวจสอบว่ามันเรียงแล้วซึ่งตามที่ระบุไว้แล้วนั้นเป็นเรื่องง่าย! เดินเรื่อย ๆ จนกระทั่งมันเรียง

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)))
  }
}

ฉันถือว่าผลลัพธ์นี้ "จริงเท็จเท็จ" มันกำลังทำงานมาระยะหนึ่งแล้ว ...


8

อาร์เรย์ที่เรียงลำดับของจำนวนเต็มมีคุณสมบัติที่ทุก ๆ อาร์เรย์ย่อย (พูดว่าองค์ประกอบ n ถึง 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());
}

มันอาจไม่ใช่วิธีที่เร็วที่สุด แต่เป็นการทดสอบที่ถูกต้องมากไม่ว่าจะเรียงลำดับรายการหรือไม่ นอกจากนี้ยังง่ายต่อการอ่านและเข้าใจรหัสนี้อย่างไม่น่าเชื่อเพราะใช้กระบวนทัศน์แบบ FUNCTIONAL ดังนั้นจึงไม่มีความน่าสะพรึงกลัวของการเปลี่ยนแปลงสถานะและลูปซ้ำ ๆ

ฉันหวังว่าข้อมูลนี้จะเป็นประโยชน์สำหรับคุณ


6

C # - ลำดับที่เพิ่มขึ้นที่ยาวที่สุด

สำหรับอาร์เรย์ที่เรียงลำดับความยาวของลำดับที่เพิ่มขึ้นที่ยาวที่สุดจะเท่ากับความยาวของอาร์เรย์ ฉันคัดลอกอัลกอริทึมจากที่นี่เพียงแก้ไขให้ไม่ลดลงแทนที่จะเพิ่มขึ้น

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 ลบ (4102 palindromed)

ต่อไปนี้เขียนใน Stonescript (c) ภาษาที่มีลิขสิทธิ์และใช้งานมาหลายศตวรรษก่อนเช่นในสมัยก่อนหน้า midgetframes หมายเหตุ: มันเป็นสารตั้งต้นของสันสกฤต

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...  

ตัวอย่างของอาร์เรย์ที่มี 8 องค์ประกอบ เรียงตามลำดับจากมากไปน้อย :-)

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

- รหัสต่อไป

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.  

ตัวอย่างของอาร์เรย์ที่มี 8 องค์ประกอบ ไม่เรียงลำดับ :-(

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

- รหัสต่อไป

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

= - = - = - = - = - =
ในการปรับให้เหมาะสมเพิ่มเติมใบหมัดขั้นตอนที่ 4 สามารถถูกแทนที่ด้วยใบหมัดต่อไปนี้
= - = - = - = - = - =

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.  

= - = - = - = - = - =
สำหรับคุณนักสืบรหัสและ debuggers อำนาจออกมีฉันได้ตั้งใจเพิ่มข้อผิดพลาดในรูปแบบที่สองข้างต้นของขั้นตอนที่ 4 คุณสามารถหาได้หรือไม่


3
ฉันพบข้อผิดพลาด - ทั้งหมด4.3.*ควรเป็น4.2.*
Timtech

4

จาวาสคริ

นี่คือสิ่งที่ทำให้คุณตกใจกับ "ความคิดสร้างสรรค์":

  • เพราะสำหรับอาร์เรย์ที่เรียงลำดับ

    * 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
    
  • ดังนั้นให้เรียกใช้ลูปหลักสำหรับองค์ประกอบทั้งหมดและตรวจสอบเงื่อนไขสองข้อข้างต้นโดยการรันลูปซ้อนกันสองลูปภายในหนึ่งหลัก (หนึ่งสำหรับด้านซ้ายและอีกหนึ่งสำหรับด้านขวา)

ดังนั้นฉันจะใช้จาวาสคริปต์ของอัลกอริทึมที่อธิบายไว้:

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;
}

ให้ทดสอบ

checkArraySorted([]);
> true

checkArraySorted([1]);
> true

checkArraySorted([1, 2]);
> true

checkArraySorted([2, 1]);
> false

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

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

ดูเหมือนว่าจะทำงานได้อย่างสมบูรณ์แบบ! มันมีความซับซ้อนของO(n²)เหมาะสำหรับขั้นตอนวิธีการที่ควรจะเป็นO(n)แต่ด้วยการทำO(n²)มันจะกลายเป็นมีประสิทธิภาพมากขึ้นตั้งแต่นี้เป็นมาตรการที่มีประสิทธิภาพเพื่อให้มีประสิทธิภาพมากขึ้นกว่าO(n²)O(n)


ฉันไม่ได้ตั้งใจจะใช้ 'กลาง' ลูปที่ซ้อนกันแรกจาก 0 ถึง a และอันที่สองควรจะมาจาก + 1 ถึงความยาว ควรจะเรียงลำดับ BTW 1,2,3 ใช่ไหม
microbian

@microbian Ok แก้ไขแล้ว
Victor Stafusa

4

C

ต่อจากนี้ "เรียงลำดับ" หมายถึง "เรียงตามลำดับจากน้อยไปมาก"

อาร์เรย์จะไม่ถูกจัดเรียง iff a[i]>a[i+1]

ดังนั้นถ้าเราปล่อยx=a[i]-a[i+1]มันxจะเป็นบวกถ้าสมมุติไม่ได้เรียง

เพื่อทดสอบxว่าเป็นบวกเราสามารถแบ่งมันออกเป็นสองส่วน: xไม่ใช่ลบและxไม่เป็นศูนย์

การทดสอบอย่างง่ายว่าxค่าลบคือว่าเราทดสอบว่าx*xเท่ากับx*abs(x)หรือไม่ สภาพนี้ควรจะเป็นเท็จถ้าเป็นลบเนื่องจากx(-1)*(-1)==1

ในการทดสอบศูนย์เราสามารถใช้การทดสอบทั่วไปอื่น ๆ : 0./(float)xไม่ใช่ตัวเลขถ้าxมีค่าเป็นศูนย์

ดังนั้นนี่คือรหัสทั้งหมด: (สมมติว่าอาร์เรย์มี 5 องค์ประกอบ)

#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;
}

ที่จริงแล้วการทดสอบa[i]-a[i+1] > 0มีปัญหาอยู่แล้ว ไม่จำเป็นต้องทำทุกสิ่งเหล่านั้น
n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

การทำสิ่งที่ไม่จำเป็นเป็นจุดรวมของการหมุนรหัสใช่ไหม? (และคุณหมายถึงอะไรด้วยปัญหา?)
ace_HongKongIndependence

1
จำนวนเต็มมากเกินที่ลงนามคือ UB แม้ว่าเราจะกำหนดพฤติกรรมโดยรอบหากเราใช้ INT_MAX - INT_MIN ผลลัพธ์จะเป็นจำนวนลบ (แทนที่ [i] ด้วย INT_MAX และ [i + 1] ด้วย INT_MIN)
n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

เนื่องจากมันเป็นปัญหาการบ้านเท่านั้นสมมติว่าครูจะไม่ให้ตัวเลขมากที่สุด
ace_HongKong การพึ่งพากัน

ตกลง. แค่ว่าฉันชอบหมุนรอบ + เป็นคนชั่ว
n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

4

มันคือทั้งหมดที่เกี่ยวกับความมั่นใจที่คุณต้องการ เนื่องจากไม่มีความแน่นอนได้รับต่อไปนี้เป็นจริงประสิทธิภาพค่อนข้างดีฉลาด รหัสด้านล่างให้การคาดเดาที่ดี แต่ถ้าคุณแน่ใจว่าคุณควรทำฟังก์ชั่นซ้ำสองสามครั้ง หากคุณต้องการที่จะแน่ใจจริงๆคุณควรใช้มันในวงและทำมันโหล ความยืดหยุ่นที่สมบูรณ์แบบ!

#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;
}

นี่ไม่ใช่การรักษาใช่ไหม


4

C

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

ทำงานร่วมกับความน่าจะเป็น 1- (1 / n!) และความซับซ้อน O (1) เห็นได้ชัดว่าวิธีที่ดีที่สุดสำหรับอาร์เรย์สุ่มขนาดใหญ่มาก

เนื่องจากความซับซ้อนเป็นเพียง O (1) สำหรับการประเมินที่ดีกว่าให้รันสองครั้ง


3

C

ฟังก์ชั่นนี้ทำมากกว่าแค่บอกคุณว่าอาเรย์นั้นถูกเรียง มันบอกคุณว่ามีองค์ประกอบหลายอย่างในที่ที่เหมาะสม สามารถใช้กับข้อมูลประเภทใดก็ได้

สังเกตความสำคัญของการใช้ชื่อตัวแปรอธิบายเพื่อให้โค้ดของคุณง่ายต่อการติดตาม ในทางกลับกันเราไม่จำเป็นต้องประกาศตัวแปร i เนื่องจากมันถูกผูกไว้กับการประกาศที่อื่นในโปรแกรม

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;
}

แก้ไข: นี่เป็นวิธีที่ดีกว่าสำหรับอาร์เรย์ขนาดใหญ่ ข้อดีของสิ่งนี้คือมันคล้ายกับวิธีที่มนุษย์จะตรวจสอบ

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
"เราไม่จำเป็นต้องประกาศตัวแปร i เนื่องจากมันถูกผูกไว้กับการประกาศที่อื่นในโปรแกรม" ก็คุ้มค่าที่จะหัวเราะ
Jonathan Van Matre

@JanathanVanMatre ขอบคุณ แต่มันไม่ได้เป็นเพียงสิ่งเดียวที่ผิดกับรหัสนี้
เลเวลริเวอร์เซนต์

3

JavaScript + สถิติเพิ่มเติม

ฉันชอบโซลูชันที่ @Cominterm แนะนำมาก แต่เมื่อเปรียบเทียบกับรายการที่เรียงลำดับแล้ว? นั่นคือการโกง!

แต่ฉันคำนวณความสัมพันธ์ของอาเรย์อัตโนมัติ (ความสัมพันธ์ระหว่างอาเรย์กับอาเรย์นั้นเปลี่ยนไปหนึ่งตำแหน่ง) จากนั้นฉันสลับสุ่มหลาย ๆ ครั้งและแต่ละครั้งจะเปรียบเทียบความสัมพันธ์อัตโนมัติใหม่กับความสัมพันธ์ดั้งเดิม ถ้าเรียงลำดับแล้วค่าเริ่มต้นอัตโนมัติจะเป็นค่าสูงสุดเวลาส่วนใหญ่!

http://jsfiddle.net/dB8HB/

โบนัส: ถ้าค่า p ของคุณ <0.05 ผลลัพธ์จะทำงานโดยอัตโนมัติโดยอ้างว่ามีการเรียงลำดับอาร์เรย์สำหรับคุณ สิ่งเพิ่มเติมที่คุณสามารถขอ?

โบนัส 2: แม้ว่าการใช้งานนี้จะใช้ฟังก์ชันอาร์เรย์ O (n) ของ JavaScript เพื่อความสะดวก แต่วิธีการอาจใช้การสุ่มตัวอย่างเพื่อให้ทำงานได้ในเวลาที่แน่นอน!

<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

วิธีนี้ไม่ได้ใช้ <, <=,> หรือ> = comparators ฉันพยายามทำให้มันอ่านน้อยเหมือนฟังก์ชั่นเรียงลำดับเท่าที่จะทำได้

วิธี

  • เขียนค่าเป็นจุดตามส่วนโค้ง
  • สำหรับอาร์เรย์จากน้อยไปมากแต่ละค่าจะทำให้ความกว้างโดยรวมของรูปวาดกว้างขึ้นและไม่ลด X เริ่มต้น (ยกเว้น: สองค่าที่เหมือนกัน)
  • เนื่องจากความกว้างไม่สามารถลดขนาด a! = จะเพียงพอ
  • ในฐานะที่เป็น X ไม่สามารถเพิ่ม == จะพอเพียง
  • เพื่อแก้ไขค่าที่เหมือนกันสองค่าแต่ละจุดเป็นเส้นจริงซึ่งมีความยาวเพิ่มขึ้น โดยที่ความยาวของหน่วยน้อยกว่า 1 / จำนวนค่า

หลอก

ฉันได้เพิ่มใบหน้าฝ่ามือต่อไปนี้ตลอดการเดินทางเพื่ออ่านโค้ดที่แย่มากนี้

  • ฟังก์ชั่นอาจดูเหมือนว่ามันจะเรียงลำดับอาร์เรย์ชื่อ sunDialsort (โบนัสตัวพิมพ์ใหญ่ที่ไม่ดี)
  • ใช้การอ้างอิง lit-geek สำหรับชื่อตัวแปรทั้งหมด
  • ใช้ค้อน regex เพื่อนับจำนวนขององค์ประกอบในอาร์เรย์
  • ใช้กล่องเตือน
  • วิธีแก้ปัญหาสำหรับกรณีขอบที่ 2 ตัวแปรติดต่อกันจะเท่ากันสองเท่าของจำนวนรหัส (ซับเดียวสามารถจัดเรียงมัน) ใส่จำนวนมากของรหัสนี้ก่อนที่จะสับสนวัตถุประสงค์ของฟังก์ชั่น
  • แทนที่จะค้นหาขั้นต่ำและสูงสุดหาจำนวนที่ยาวที่สุดและปัดขึ้นสู่พลังต่อไปของสิบหวังว่าสิ่งนี้จะทำให้ผู้คนแตกตื่น

XML

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

ฟังก์ชัน

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]));

หากใครต้องการทดสอบมีรุ่นที่นี่พร้อมชื่อตัวแปรที่อ่านได้ http://jsfiddle.net/outRideACrisis/r8Awy/


3

C

เนื่องจากการค้นหาแบบไบนารี่ใช้งานได้กับอาร์เรย์ที่เรียงลำดับเท่านั้นเพื่อตรวจสอบว่ามีการเรียงลำดับอาร์เรย์ทั้งหมดที่เราต้องทำคือตรวจสอบว่าการค้นหาแบบไบนารีทำงานได้กับองค์ประกอบทั้งหมดของอาร์เรย์ หากไม่พบองค์ประกอบใด ๆ เรารู้ว่าอาร์เรย์นั้นไม่ได้ถูกจัดเรียง

อาร์กิวเมนต์ของบรรทัดคำสั่งที่ส่งจะต้องเป็นจำนวนเต็มทศนิยมโดยไม่มีเลขศูนย์นำหน้า

#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;
}


2

C

  • ทำสำเนาของอาร์เรย์
  • จัดเรียงสำเนาตามลำดับจากมากไปน้อย
  • ตรวจสอบว่าอาเรย์นี้เป็นสิ่งที่ตรงกันข้ามของอาเรย์ที่กำหนด
    #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

มาติกา

อัลกอริทึมนี้ดูเหมือนจะทำงานได้ แต่มันช้าไปหน่อย อาจมีวิธีการเรียงลำดับที่เร็วขึ้น แต่ฉันไม่พบพวกเขา

  1. ใช้การเรียงลำดับแบบสุ่มของรายการและตรวจสอบว่าเป็นไปตามลำดับ (พร้อมOrderedQ)
  2. ถ้าเป็นเช่นนั้นหยุด มิฉะนั้นให้ทำซ้ำขั้นตอนที่ 1

รหัสต่อไปนี้เรียงลำดับรายการในเวลาเพียง 18 วินาที

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}


ภารกิจคือตรวจสอบว่าอินพุตถูกเรียงลำดับแล้ว
Ilmari Karonen

นี่เป็นแนวคิดที่สำคัญที่อยู่เบื้องหลังโซลูชันของฉัน (แม้ว่าฉันจะใช้กำลังสองเวลาOrderedQสำหรับ funsies) ด้วยการเพิ่มการตรวจสอบในตอนท้าย "ตอนนี้ที่เราได้จัดเรียงหนึ่งมันคือสิ่งที่เราเริ่มต้นด้วย"
บูธตาม

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;
}

ฟังก์ชันนี้อาจส่งคืนfalseอย่างไม่ถูกต้อง แต่ไม่ใช่ในเบราว์เซอร์สมัยใหม่ คุณสามารถตรวจสอบสิ่งนี้และให้ทางเลือกที่ช้ากว่า (ตามที่อธิบายไว้ในคำถาม) หากจำเป็น:

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.
    };
}

พวกเขาบอกว่าสิ่งนี้ให้ผลลัพธ์ที่คาดเดาไม่ได้กับจำนวนลบ แต่จริงๆแล้วมันขึ้นอยู่กับว่าคุณเก่งแค่ไหนในการทำนายสิ่งต่าง ๆ


2
ฉันหวังว่า Chrome จะสลับคุณสมบัติของวัตถุเพื่อป้องกันไม่ให้ผู้คนทำสิ่งนี้…
Bergi

2

Java (ระยะทาง Levenshtein)

ในการใช้งานนี้ฉันโคลนอาร์เรย์ดั้งเดิมและเรียงลำดับอินสแตนซ์ที่โคลน จากนั้นคำนวณหาระยะทางของ Levenshtein ถ้ามันเป็นศูนย์แล้วอาร์เรย์เดิมก็ถูกจัดเรียง

หมายเหตุ: การใช้งาน getLevenshteinDistance () นำมาจาก Jakarta Commons Lang และปรับเปลี่ยนให้ทำงานบน int [] แทน 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];
    }
}
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.