"क्रिएटिव" तरीके यह निर्धारित करने के लिए कि कोई सरणी क्रमबद्ध है या नहीं

Question

पूर्णांक सरणी को देखते हुए, एक प्रोग्राम लिखें जो निर्धारित करता है कि क्या यह आरोही क्रम में क्रमबद्ध है।

याद रखें कि यह एक कोड ट्रोलिंग प्रश्न है।

मैं सबसे दिलचस्प तरीकों की तलाश कर रहा हूं जो लोग साथ आते हैं।

सबसे upvotes के साथ जवाब जीतता है।

यह सवाल एक 'रचनात्मक' समाधान से प्रेरित है जो एक उम्मीदवार ने मुझे एक साक्षात्कार में दिया :)

---

'रचनात्मक' समाधान कुछ इस तरह था:

• क्योंकि एक क्रमबद्ध सरणी के लिए

  • किसी भी तत्व के बाईं ओर के सभी तत्व छोटे होने चाहिए
  • किसी भी तत्व के दाईं ओर सभी तत्व बड़े होने चाहिए

इसलिए, सभी तत्वों के लिए एक मुख्य लूप चलाएं और मुख्य एक के अंदर दो नेस्टेड लूप चलाकर ऊपर की दो स्थितियों की जांच करें (एक बाईं ओर और एक दाएं तरफ के लिए)

मैं चौंक गया!!।

Comments

यह कोई डुप्लिकेट नहीं है। कुछ मॉडरेटर्स को यह जरूरी लगता है कि वह बिना पढ़े ही हर सवाल को दूसरों के सामने दोहराए। यह बिल्कुल छांटने वाला सवाल नहीं है। इसे पढ़ें।

— माइक्रोबियन

प्रतियोगिता के अंत में मैं "रचनात्मक" समाधान भी जानना चाहूंगा! :)

— वेरोस

@micro डायमंड मॉडरेटर्स चुने गए समुदाय हैं। आप विशेषाधिकार प्रणाली के साथ मध्यस्थों को भ्रमित कर रहे हैं।

— दरवाज़े

@microbian तो क्या आपने उस आदमी को काम पर रखा है?

— VisioN

यदि केवल StackExchange API ने लिखने की अनुमति दी है, तो मैं प्रश्न पूछूंगा "क्या यह सरणी क्रमबद्ध है?" और सकारात्मक / नकारात्मक उत्तरों पर निर्भर करता है ..

— माइकल फोकरिसिस

Answer 1

माणिक

हर कोई जानता है: छंटाई बहुत धीमी है और कई चक्र लेता है (सबसे अच्छा आप जो कर सकते हैं वह कुछ है 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

Comments

यह हालांकि छँटाई एल्गोरिथ्म पर निर्भर करता है। मर्ज सॉर्ट या हीप सॉर्ट किसी भी तरह से कोई अंतर नहीं दिखाएगा, यह स्वतंत्र है कि सरणी पहले से सॉर्ट की गई है या नहीं।

— निकल्स बी।

@NiklasB। रूबी क्विकर का उपयोग करती है । यही कारण है कि इस विधि कहा मुश्किल हो और जब इनपुट सरणी है झूठे सकारात्मक दे सकता है लगभग हल कर, या, अधिक संभावना है, मिथ्या नकारात्मक जब सरणी है छाँटे गए (इसके लिए बहुत संभावना नहीं होगा treference <= trunहर हल कर मामले के लिए, बस nondeterministic अन्य सामग्री की वजह से) । सिद्धांत रूप में, ऐसा लगता है कि आपको सॉर्ट किए गए मामले के लिए लगभग 50% झूठे नकारात्मक मिलेंगे?

— जेसन सी

दिलचस्प विचार लेकिन नियतात्मक नहीं। इसके बारे में के रूप में अच्छा के रूप में एक दस पुश अप कर सकता है और फिर दस और पुश अप और फिर तय करें कि पहले सरणी को हल किया गया था या नहीं, क्योंकि एक ने पुश अप के दूसरे सेट पर अधिक पसीना किया। क्या हम भूल गए, हम मल्टी-टास्किंग मशीनों पर कोड चलाते हैं? बहुत छोटे सरणियों पर भी, समय टुकड़ा बस पर्याप्त रूप से सटीक नहीं है। एक जंगली प्रयास के लिए हालांकि +1!

— LMSingh

@NiklasB। Timsort (विलय का एक प्रकार) क्रमबद्ध (और आंशिक रूप से क्रमबद्ध) सरणियों पर रैखिक समय में भी चलता है।

— बकुरीउ

@ जेसन - यह ध्यान देने योग्य है कि यह कार्यान्वयन को और भी अधिक संदिग्ध बना देता है: यह न केवल इस ज्ञान पर निर्भर करता है कि रूबी की आंतरिक छँटाई एल्गोरिथ्म क्विकरॉर्ट है (जो अपने आप में अनिर्दिष्ट है और इसलिए उस पर भरोसा करने के लिए एक संदिग्ध चीज़ है) लेकिन वह विशिष्ट कार्यान्वयन पहले से ही सॉर्ट किए गए डेटा के मामले के लिए अनुकूलित है (जो कि डिफ़ॉल्ट रूप से क्विकॉर्टर्ट नहीं है: एस्कॉर्ट औसत केस पर केवल ओ (एन लॉग एन) है ... इसका सबसे खराब मामला प्रदर्शन ओ (एन ^ 2) है और एक भोले कार्यान्वयन में है। सबसे बुरा मामला वास्तव में पहले से ही सॉर्ट किए गए डेटा पर बुलाया जा रहा है)।

— जूल्स

Answer 2

जावास्क्रिप्ट

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

Comments

-1 पर्याप्त नहीं JQuery।

— पियरे अरलाउड

मेरे पास एक समान विचार था जो सरणी के लिए पूछेगा, और फिर एक-एक करके "क्या यह इससे बड़ा है?" और अगर सभी सच हैं, तो सरणी को सॉर्ट किया जाता है

— Zach Thacker

Answer 3

जावा - पुनरावर्ती सब्सक्रिप्शन

ढेर अतिप्रवाह में आपका स्वागत है! यह एक उत्कृष्ट पहला प्रश्न है, क्योंकि यह कुछ दिग्गज कोडर्स को भी रोकता है। इससे पहले कि मैं सिर्फ कोड सौंप दूं, आपको पृष्ठभूमि की थोड़ी जानकारी दे दूं:

छंटनी का निर्धारण पहली नज़र में एक मुश्किल काम हो सकता है। लंबाई n के किसी भी सेट के लिए, n हैं! इसे ऑर्डर करने के संभावित तरीके। इन्हें क्रमपरिवर्तन कहा जाता है । यदि आपके सरणी में अलग-अलग तत्व हैं, तो उन संभावनाओं में से केवल एक ही क्रमबद्ध है! छांटे गए एक को खोजने के लिए, आपको उन सभी के माध्यम से झारना है जब तक कि आप सही (संभवतः केवल) एक को नहीं पाते हैं, अन्य सभी को छोड़ देते हैं।

क्या? निश्चित रूप से यह इतना कठिन नहीं है ...

N के साथ एल्गोरिदम! जटिलता बड़े इनपुट के लिए एक लंबा समय लेती है, लेकिन काम के एक बिट के साथ हम उस के आसपास प्राप्त कर सकते हैं, और जटिलता के एक पूरे क्रम को नीचे ले जा सकते हैं। यह अभी भी घातीय समय है, लेकिन यह तथ्यात्मक से बहुत बेहतर है।

ऐसा करने के लिए, हमें केवल निम्नलिखित गणितीय तथ्य पर विचार करने की आवश्यकता है: यदि एक सरणी को क्रमबद्ध किया जाता है, तो इसके हर (अपेक्षाकृत आदेशित) सबसेट को भी क्रमबद्ध किया जाता है। आप गणित के विशेषज्ञों से औपचारिक प्रमाण के लिए पूछ सकते हैं , लेकिन यह सहज रूप से सच है। उदाहरण के लिए, सेट के लिए 123, उचित उपसमूह हैं 1 2 3 12 13 23। आप देख सकते हैं कि वे सभी ऑर्डर किए गए हैं। अब अगर मूल था 213, तो आपके पास होगा 2 1 3 21 23 13, और तुरंत आप देख सकते हैं कि 21ऑर्डर से बाहर है।

यह कारण महत्वपूर्ण है क्योंकि n से कहीं कम हैं! सबसेट। वास्तव में, केवल 2 ^एन -2 सबसेट हैं जिन्हें हमें देखने की आवश्यकता है। हम मूल संख्याओं के पूरे सरणी के साथ-साथ खाली सेट वाले सेट को बाहर कर सकते हैं।

फिर भी, 2 ^एन -2 बहुत काम हो सकता है। अधिकांश चीजों के साथ जो बहुपद के समय से अधिक है, एक विभाजित और जीत का दृष्टिकोण यहां अच्छी तरह से काम करता है। सबसे सरल दृष्टिकोण? पुनरावृत्ति !

मूल कदम सरल हैं। आपके इनपुट के प्रत्येक सबसेट के लिए, आप छोटे सबसेट बनाते हैं । फिर उनमें से प्रत्येक के लिए, आप एक ही काम करते हैं। एक बार जब आपका सबसेट 2 आकार का हो जाता है, तो आप बस जांचते हैं कि कौन सा बड़ा है। चूंकि आप हर बार सबसेट के आकार को छोटा करते हैं, यह वास्तव में आपकी अपेक्षा से अधिक तेज होता है।

यहां महत्वपूर्ण तथ्य यह है कि आप जल्दी से बाहर निकल सकते हैं , जैसे ही आप ऑर्डर के बाहर एक सबसेट पाते हैं । आप उन सभी के माध्यम से खोज करने की जरूरत नहीं है । यदि एक बुरा है, तो पूरा समूह खराब है। यह एक गति पर विचार है जिसे आप इन अन्य उत्तरों में से एक में नहीं देखते हैं।

पर्याप्त बात करते हैं, चलो कोड है!

मैंने इसे जावा में किया है क्योंकि यह एक लोकप्रिय भाषा है और पढ़ने में आसान है। पुनरावृत्ति की भव्यता स्पष्ट होनी चाहिए:

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

रिकॉर्ड के लिए, मैं ऊब गया और इसे 12-तत्व सरणी के लिए 15 मिनट इंतजार करने के बाद मार दिया। यह लगभग 45 सेकंड में 11 तत्व करेगा। बेशक, यह वास्तव में करता है बाहर निकलने के पहले के लिए गैर अनुसार क्रमबद्ध हैं, ताकि, है उम, अच्छा।

अपडेट: एक ताजा रिबूट पर, यह 13 मिनट में 12 तत्व करता है। 13 में लगभग 3 घंटे लगते हैं, और 14 20 घंटे और गिनती में है।

Comments

+1 यह शायद सबसे कम कुशल एल्गोरिथम है जिसे मैंने कभी देखा है। O (n! * 2 ^ (n!)) के आसपास होना चाहिए - जटिलता (शायद बदतर)।

— राल जारेक

मुझे यकीन है कि मैं भी बदतर देखा है हूँ, लेकिन यह है बहुत बुरा। मैंने आधे-अधूरे मन से जटिलता निर्धारित करने की कोशिश की, लेकिन हार मान ली O(big)।

— फोब्र्स 28'14

ऐसा समाधान प्रदान करना जो कम कुशल हो, तब भी यात्रा सेल्समैन समस्या का भोला प्रयास प्रभावशाली होता है!

— पुनरावर्तन.निन्जा

जैसा कि 12 तत्व सरणी को छांटने का मौका 479 मिलियन में केवल 1 है, यह वास्तव में कोई फर्क नहीं पड़ता कि यह पूरी तरह से निश्चित होने में कुछ समय लेता है कि निश्चित रूप से है? आप वास्तव में वास्तविक दुनिया में एक को देखने की संभावना नहीं रखते हैं ...

— जूल्स

@Geobits कोई समस्या नहीं है। पहले संकेत पर विक्टर के एल्गोरिथ्म को चलाएं और "हां" का जवाब दें।

— जेसन सी

Answer 4

सी ++ - एक क्रूर बल विधि

हर कोई जानता है कि जानवर बल के तरीके हमेशा सबसे तेज होते हैं।

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 पर जाती है), लेकिन मैं यहाँ पोस्ट करने में 30000 वर्णों तक सीमित हूँ।

Comments

मुझे वास्तव में पसंद है।

— जैकब

यह दृष्टिकोण "भैंस के हर हिस्से का उपयोग" मामले को बयान की तरह है।

— जोनाथन वान मैट्रे

यह कमाल का है। सभी छोरों को अनियंत्रित करें!

— मैकै

महान विचार!!!

— bikram990

Answer 5

सूचित करना

सूचित क्लासिक इन्फोकॉम Z- मशीन दुभाषिया के लिए इंटरैक्टिव कल्पना खेल लिखने के लिए एक भाषा है। से बचने के लिए विफल, मैं अपने कार्यक्रम के परिणाम तो स्रोत कोड दे रहा हूँ पहले।

संपादित करें: मैं सरणी के नंबर शामिल करने की अनुमति के लिए एक छोटा सा संशोधन किया, और एक आकर्षक कमरे विवरण शामिल थे।

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

Answer 6

डॉगी रूबी

सबसे पहले आपको यह सेटअप कोड चलाना होगा

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 कला एक स्क्रिप्ट द्वारा उत्पन्न की गई थी जिसे मैंने लिखा था, इस चित्र से ली गई है ।)

Comments

आप "इतना एल्गोरिथ्म" भूल गए। एक असली कुत्ते के नमूने में "वाह" से पहले 3 वाक्य हैं। और हां, मैं पार्टियों में बहुत मजेदार हूं।

— पियरे अरलाउड

@ArlaudPierre हे, ठीक है, ठीक किया: पी

— दरवाज़े

तो टिप्पणी, बहुत सुधार, कई उपयोगी। वाह।

— बजे पियरे अरलाउड

तुम एक बीएफ कार्यक्रम ascii एक doge की तरह आकार में लिखा होना चाहिए ... नया सवाल विचार !!

— डॉक्टर

Answer 7

पीएचपी

आप निम्नलिखित समाधान की सहजता और सरलता को पसंद करेंगे। समग्र अवधारणा और कोडिंग की इस कृति में उपयोग किए जाने वाले अत्याधुनिक कार्य आपको तुरंत दुनिया के शीर्ष डेवलपर्स की कुलीन सूची में लाएंगे।

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

Comments

+1 क्योंकि आप छँटाई वाले प्रश्न

— विक्टर स्टैफ़ुसा

यदि श्रीमती रॉबर्ट्स मूल्यों में प्रवेश करती हैं तो क्या यह काम करेगा ?

— user80551

@ user80551 हाँ क्योंकि छात्रों को कोई तालिका नहीं है

— शाफ़्ट फ्रीक

@JonathanVanMatre निश्चित रूप से सुरक्षा इस कोड के सबसे मजबूत पक्षों में से एक है।

— VisioN

इस वेबसाइट पर यह मेरा नया पसंदीदा उत्तर है; लेकिन अतिरिक्त निशानों के लिए मैं आपको सुरक्षा के लिए एक पीडीओ का उपयोग करते हुए देखना पसंद करूंगा

— एलेक्सैंडरकनॉन

Answer 8

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) है। विधि नाम में एक है, "प्रत्येक में" कीवर्ड के लिए, एक "डबल" घोषणा में, और दो चर "सॉर्टेडनेस" के उपयोग में है। आप इस फ़ंक्शन को O (0) (जो आप जा सकते हैं जितना कम है) में सुधार कर सकते हैं, फ़ंक्शन का नाम बदलकर, डबल को दशमलव में बदलकर, "srtdnss" के लिए "सॉर्टेडनेस" को हटा दें, और छोरों के लिए कनवर्ट करें जबकि छोरों।

Comments

मैंने श्रमसाध्यता को जटिलता से पुनर्गठित किया और इसे O (8) के रूप में निर्धारित किया। आप आउटपुट को दूर कर रहे हैं, जो मेरा मानना ​​है कि इसमें कारक होना चाहिए। वास्तव में ओ (7) जटिलता होने के लिए, आप "सॉर्ट किए गए" / "अनसेंडेड" के बजाय "आरोही" / "हैफर्ड" लौटने पर विचार कर सकते हैं।

— जिओबिट्स

@Geobits - मैंने इसे फिर से देखा, और निश्चित रूप से आप सही हैं। मुझे लगता है कि यह दर्शाता है कि स्ट्रिंग्स को वापस करते समय ओ (1) की एक न्यूनतम जटिलता है। यह हालांकि भुगतान करने के लिए एक छोटी सी कीमत है, क्योंकि एक बूलियन को वापस करना दोगुना बुरा है।

— कॉमिनेन्ट

ओ के लिए +1 () गणना। -1 एक स्पीयरमैन आरएच की गणना नहीं करने के लिए, क्योंकि एक से दो सहसंबंध बेहतर नहीं हैं? और सांख्यिकीविदों के सिद्ध पसंदीदा C # में आँकड़ों के लिए +1।

— जोनाथन वान मैट्रे

कृपया मुझे बताएं कि O(7)बात एक मजाक है

— mbatchkarov

@mbatchkarov - यह थोड़ा हे अंकन है। :-)

— कॉमिन्टर्न

Answer 9

माणिक

यदि किसी सरणी को क्रमबद्ध किया जाता है, तो निम्नलिखित रणनीति अंततः प्रकट करेगी:

1. एक सरणी हो (या तो सॉर्ट की गई हो या अनसर्ट की गई हो, जैसे [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

Comments

मुझे नहीं लगता कि मैं स्पष्टीकरण को समझता हूं। यदि सरणी है, उदाहरण के लिए, [1, 9, 100], तो न्यूनतम 10019 है और अधिकतम 91100 है, लेकिन क्रमबद्ध संख्या 19100 है। ऑनलाइन संस्करण के साथ खेलना, अधिकतम [100,9,1] और मिनट है। [1,9,100] है। मैं यह नहीं देखता कि कुछ भी कहाँ "एक संख्या द्वारा दर्शाया जा रहा है"; ऐसा लगता है कि सरणियों को केवल शाब्दिक रूप से आदेश दिया जा रहा है। यह वही होगा, मुझे लगता है, यदि सभी संख्याएं केवल एक अंक हैं।

— जोशुआ टेलर

"... या तो अधिकतम या न्यूनतम ..." इसे प्यार करता था।

— माइक्रोबियन

@JoshuaTaylor: हेड-अप के लिए धन्यवाद! मैं इसे आसानी से समझने योग्य तरीके से समझाना चाहता था - जो अंत में गलत होने पर समाप्त हो गया;) मैंने अपना विवरण सही किया ...

— डेविड हेरमैन

@JoshuaTaylor माणिक तरीके Array # max और #min <और> ऑपरेटरों के संबंध में सबसे बड़े और सबसे छोटे तत्व का चयन करें। Arrays पर <और> लेक्सोग्राफिक सॉर्टिंग लागू करते हैं। [1,9,100] लेक्सिकोग्राफिक ऑर्डर में 1, 9 और 100 के सभी ऑर्डर किए गए क्रमपरिवर्तन की मिनीमा है।

— कार्ल डमगार्ड असमसन

यह लगभग उत्पादन की गुणवत्ता है।

— प्रिमो

Answer 10

सी # - गैर-नियतात्मक समाधान

यह कोड शायद काम करता है।

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
}

Comments

यदि आप पुनरावृत्तियों की संख्या को -n ^ 2 * ln (1-p) पर सेट करते हैं, तो आप p की संभावना के साथ सुनिश्चित कर सकते हैं कि सभी संयोजनों की जाँच की जाएगी!

— हन्नेश

और इस समाधान के लिए "वर्किंग कोड लेकिन ट्रोलिंग" के रूप में स्वीकार किए जाने के लिए पी के कौन से मूल्य मान्य हैं? :)

— fejesjoco

से stackoverflow.com/questions/2580933 , ब्रह्मांडीय किरणों की वजह से किसी तुलना के गलत अनुमान का मौका ०.०००००१८ (1.8e -6) हर दूसरे होगा। इसलिए यदि: 1) आप यह पता लगा सकते हैं कि पुनरावृत्ति कितना समय लेती है, 2) संभावना की गणना करने के लिए हम @ ह्ननेश फार्मूला का उपयोग कर सकते हैं, और फिर समीकरणों की प्रणाली को हल करने के लिए पुनरावृत्तियों की संख्या का पता लगा सकते हैं जो आपके समाधान को एक से अप्रतिस्पर्धी बनाते हैं। मानक है विधि विधि।

— Xantix

Answer 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

Answer 12

दे घुमा के

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 परिणाम की तुलना मूल सरणी से करें।

मैं बैश के साथ बहुत अच्छा नहीं हूं, मैं सिर्फ यह कोशिश करना चाहता था :)

Comments

अच्छा है, यह मानता है कि निर्देशिका "./nums" पहले से मौजूद है। शायद एक "mkdir -p अंक" कहीं?

— कैमेल्टेमममेल

ओह, हाँ जो समझ में आता है: P

— Zach Thacker

Answer 13

सी#

"छोटा" या "बड़ा" की धारणाएं 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;
}

Comments

यदि एक ही संख्या दो बार दिखाई दे तो क्या होगा? फिर सूची [i]% सूची [i + 1] == 0.

— शमौन

@Simon ओह हो! वास्तव में, मुझे लगता है कि दो समान संख्याएँ क्रमबद्ध हैं। इस बढ़त मामले के लिए एक तुलना जोड़ा गया। अच्छा लगा।

— पियरे-ल्यूक पाइनएट

यह जानकर खुशी हुई कि {0, -1, 2} एक क्रमबद्ध सूची है।

— पियरे अरलाउड

@ArlaudPierre यदि आप एक वास्तविक 2014 प्रोग्रामर बनना चाहते हैं, तो आपको हर उस चीज़ को अलग रखना होगा जो नकारात्मक है। दुनिया सकारात्मक है, दुनिया निरपेक्ष है, दुनिया modulo है!

— पियरे-ल्यूक पाइनयाल्ट

चूंकि आपको "बड़ा" और "छोटा" की धारणा पसंद नहीं है, यह शर्म की बात है कि आपको उन कम-से-कम और अधिक-से-अधिक संकेतों को शामिल करना पड़ा। आपको सूचियों के बजाय सरणियों का उपयोग करना चाहिए था।

— श्री लिस्टर

Answer 14

स्काला

एक सरणी छँटाई है अगर जाँच आसान है! बस जांचें कि क्या पहला तत्व दूसरे से कम है। फिर बाकी को छांटें और देखें कि क्या वे समान हैं।

दुर्भाग्य से, छँटाई एक कठिन समस्या है। किसी सरणी को सॉर्ट करने के लिए कई प्रसिद्ध या कुशल एल्गोरिदम नहीं हैं; वास्तव में यह कंप्यूटर विज्ञान के ज्ञान की वर्तमान स्थिति में एक विशाल अंधा-धब्बा है। इसलिए मैं एक सरल एल्गोरिथ्म का प्रस्ताव देता हूं: सरणी को फेरबदल करें और फिर जांचें कि क्या यह क्रमबद्ध है, जो पहले से ही कहा गया है, आसान है! इसे हल करने तक हिलाते रहें।

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

मैं इस आउटपुट को "सच्चा, झूठा, सच्चा" मानता हूं। अभी कुछ समय से चल रहा है ...

Answer 15

पूर्णांकों की एक क्रमबद्ध सरणी में ऐसी संपत्ति होती है जो हर उप-सरणी (ए तत्वों के माध्यम से n कहती है) भी पूर्णांकों की एक क्रमबद्ध सरणी होती है। यह स्पष्ट रूप से निहित है कि सबसे अच्छा तरीका एक 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 प्रतिमान का उपयोग करता है, और इसलिए यह राज्य के बदलते और पुनरावृत्त छोरों से मुक्त है।

मुझे उम्मीद है कि यह आपके लिए उपयोगी जानकारी होगी।

Answer 16

सी # - सबसे लंबे समय तक बढ़ रही है

एक सॉर्ट किए गए एरे के लिए, सबसे लंबे समय तक बढ़ने वाली लेन्स की लंबाई एरे की लंबाई के बराबर होती है। मैंने एल्गोरिथ्म को यहां से कॉपी किया , केवल इसे संशोधित करने के बजाय गैर-घटते बढ़ने के लिए संशोधित किया।

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

Answer 17

स्टोन्सस्क्रिप्ट (c) एलएमएससिंह - 0 माइनस (4102 palindromed)।

निम्नलिखित Stonescript (c) में लिखा गया है, एक भाषा कॉपीराइट और मेरे द्वारा कई शताब्दियों पहले, जिसका उपयोग मिडजेटफ़्रेम से पहले पुराने समय में किया गया था। नोट: यह संस्कृत का एक अग्रदूत है।

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.  

= - = - = - = - = - =
आप के लिए सभी कोड sleuths और पावर डिबगर्स वहाँ से बाहर है, मैं जानबूझकर कदम 4 के ऊपर दूसरे बदलाव में एक बग जोड़ा गया है। क्या आप इसे पा सकते हैं?

Comments

मुझे बग मिला - सब कुछ 4.3.*होना चाहिए4.2.*

— टिमटेक

Answer 18

जावास्क्रिप्ट

इसने आपको "रचनात्मकता" के बारे में हैरान कर दिया:

• क्योंकि एक क्रमबद्ध सरणी के लिए

  * 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)।

Comments

मेरा मतलब 'मध्य' का उपयोग करना नहीं था। पहला नेस्टेड लूप 0 से ए तक था, और दूसरा एक + 1 से लंबाई तक माना जाता था। BTW, 1,2,3 सॉर्ट किया जाना चाहिए, है ना?

— माइक्रोबियन

@microbian Ok, संपादित किया गया।

— विक्टर स्टैफुसा

Answer 19

सी

इसके बाद, "क्रमबद्ध" का अर्थ है "बढ़ते क्रम में क्रमबद्ध"।

किसी सरणी को 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नॉट एक नंबर iff 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;
}

Comments

दरअसल, परीक्षण के लिए a[i]-a[i+1] > 0पहले से ही समस्याग्रस्त है। उन सभी प्रकार के सामानों को करने की आवश्यकता नहीं है।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

अनावश्यक सामान करना कोड ट्रोलिंग का पूरा बिंदु है, है ना? (और समस्याग्रस्त से आपका क्या अभिप्राय है?)

— ace_HongKongI डिपेंडेंस

हस्ताक्षरित पूर्णांक अतिप्रवाह UB है। यहां तक ​​कि अगर हम व्यवहार के चारों ओर लपेट को परिभाषित करते हैं, अगर हम INT_MAX - INT_MIN करते हैं, तो परिणाम एक नकारात्मक संख्या होगी (INT_MAX के साथ [i] और INT_MIN के साथ एक [i + 1]।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

चूंकि यह केवल एक होमवर्क समस्या है, इसलिए मान लें कि शिक्षक इतने अधिक संख्या में नहीं देगा।

— ace_HongKongInd डिपेंडेंस

ठीक। बस मैं ट्रोल + बुराई करना पसंद करता हूं।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

Answer 20

यह आप कितना निश्चित होना चाहते हैं। चूंकि कोई निश्चितता नहीं दी गई थी, वास्तव में काफी अच्छा प्रदर्शन बुद्धिमान है। नीचे दिया गया कोड एक अच्छा अनुमान देता है, लेकिन यदि आप सुनिश्चित हैं कि आपको एक दो बार फ़ंक्शन दोहराना चाहिए। यदि आप वास्तव में निश्चित होना चाहते हैं , तो आपको इसे लूप में चलाना चाहिए और इसे एक दर्जन बार करना चाहिए। बिल्कुल सही मापनीयता!

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

क्या यह एक इलाज नहीं है?

Answer 21

सी

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

संभावना 1- (1 / n!) और जटिलता ओ (1) के साथ काम करता है। जाहिर है बहुत बड़ी यादृच्छिक सरणियों के लिए सबसे अच्छी विधि।

चूंकि जटिलता केवल ओ (1) है, बेहतर अनुमान के लिए, दो बार चलाएं।

Answer 22

सी

यह फ़ंक्शन केवल आपको बताता है कि सरणी सॉर्ट की गई है या नहीं। यह बताता है कि कितने तत्व सही जगह पर हैं। इसका उपयोग किसी भी प्रकार के डेटा के लिए किया जा सकता है।

अपने कोड का अनुसरण करना आसान बनाने के लिए वर्णनात्मक चर नामों का उपयोग करने के महत्व पर ध्यान दें। दूसरी ओर, हमें चर को घोषित करने की आवश्यकता नहीं है, क्योंकि यह कार्यक्रम में कहीं और घोषित होने के लिए बाध्य है।

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

Comments

"हमें चर को घोषित करने की आवश्यकता नहीं है, क्योंकि यह कार्यक्रम में कहीं और घोषित होने के लिए बाध्य है।" हंसने लायक था।

— जोनाथन वान मैट्रे

@JonathanVanMatre धन्यवाद, लेकिन यह इस कोड के साथ केवल एक चीज गलत है।

— लेवल रिवर सेंट

Answer 23

जावास्क्रिप्ट + अधिक आँकड़े

मुझे @Cominterm द्वारा सुझाए गए समाधान बहुत पसंद आए। लेकिन पहले से ही सॉर्ट की गई सूची से तुलना? यह बेइमानी है!

इसके बजाय, मैं सरणी के स्वतःसंबंध की गणना करता हूं (सरणी और सरणी के बीच सहसंबंध एक स्थिति को स्थानांतरित कर दिया गया)। फिर, मैं बहुत बार सरणी फेरबदल करता हूं और हर बार तुलना करता हूं कि यह नए ऑटोक्रेलेशन को मूल ऑटोकैरेलेशन के लिए है। यदि सरणी को सॉर्ट किया गया था, तो मूल ऑटोक्रेलेशन सबसे अधिक बार होगा!

http://jsfiddle.net/dB8HB/

बोनस: यदि आपका पी-मान <0.05 है, तो आउटपुट यह दावा करने के कार्य को स्वचालित कर देगा कि सरणी आपके लिए क्रमबद्ध है। आपके द्वारा और अधिक क्या पूछा जा सकता है?

Bonus2: हालाँकि यह कार्यान्वयन सुविधा के लिए JavaScript के O (n) सरणी फ़ंक्शंस का उपयोग करता है, दृष्टिकोण निरंतर समय में चलाने के लिए नमूने का उपयोग कर सकता है!

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

Answer 24

जावास्क्रिप्ट / एसवीजी - सनडायर्सॉर्ट

यह समाधान <, <=,> या> = तुलनाकर्ताओं का उपयोग नहीं करता है। मैंने इसे संभव के रूप में एक छोटे से समारोह की तरह पढ़ने का प्रयास किया है।

तरीका

• एक आर्क के साथ डॉट्स के रूप में मूल्यों को प्लॉट करें।
• आरोही सरणी के लिए प्रत्येक मान ड्राइंग की कुल चौड़ाई को व्यापक बना देगा और शुरुआती X को कम नहीं करेगा (अपवाद: दो समान मान)।
• के रूप में चौड़ाई सिकुड़ नहीं सकती है! = पर्याप्त होगा;
• जैसा कि एक्स नहीं बढ़ सकता है == पर्याप्त होगा।
• दो समान मूल्यों को ठीक करने के लिए प्रत्येक डॉट वास्तव में बढ़ती हुई लंबाई की एक रेखा है। जहां यूनिट की लंबाई 1 / मान से कम है।

ट्रोलिंग

मैंने इस बहुत बुरे कोड को पढ़ने की यात्रा के साथ निम्नलिखित चेहरे-हथेलियों को जोड़ा है।

• फ़ंक्शन सरणी को छाँटने के लिए इसकी तरह लग सकता है, इसे नाम दिया गया है sunDialsort (बोनस खराब कैपिटलाइज़ेशन)
• सभी चर नामों के लिए लिट-गीक संदर्भ का उपयोग किया
• सरणी में तत्वों की संख्या की गणना करने के लिए रेगेक्स हथौड़ा का उपयोग किया
• एक चेतावनी बॉक्स का उपयोग किया
• किनारे के मामले के लिए समाधान जहां 2 लगातार चर समान हैं कोड की मात्रा दोगुनी है (एक लाइनर इसे सॉर्ट कर सकता है), फ़ंक्शन के उद्देश्य को भ्रमित करने के लिए इस कोड के बहुत सारे डाल दिया।
• मिनट और अधिकतम खोजने के बजाय सबसे लंबी संख्या का पता लगाएं और दस की अगली शक्ति तक गोल करें, उम्मीद है कि यह लोगों को गंध से फेंक देगा।

एक्सएमएल

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

Answer 25

सी

एक बाइनरी खोज केवल सॉर्ट किए गए सरणियों पर काम करती है, यह जांचने के लिए कि क्या कोई सरणी सॉर्ट की गई है, हम सभी को यह सत्यापित करने की आवश्यकता है कि बाइनरी खोज सरणी के सभी तत्वों के लिए काम करती है। यदि यह किसी भी तत्व को खोजने में विफल रहता है, तो हमें पता है कि सरणी सॉर्ट नहीं की गई है।

कमांड लाइन तर्क पारित सभी प्रमुख शून्य के बिना दशमलव पूर्णांक होना चाहिए।

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

Answer 26

जावास्क्रिप्ट

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.");

Comments

{ 69 , 313 , 187 , 31,338 }

— Geobits

Answer 27

सी

• सरणी की प्रतिलिपि बनाएँ
• अवरोही क्रम में कॉपी छाँटें
• जांचें कि क्या यह सरणी दिए गए सरणी का उल्टा है

    #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();


     }

Answer 28

मेथेमेटिका

यह एल्गोरिदम काम करने लगता है, लेकिन यह थोड़ा धीमा है। छाँटने के तेज़ तरीके हो सकते हैं लेकिन मैंने उन्हें नहीं पाया है।

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, नल}
8980699
{7, 16, 19, 23, 30, 40, 50, 54, 57, 60}

Comments

कार्य यह जांचना था कि क्या इनपुट पहले से ही सॉर्ट किया गया है।

— इल्मरी करोनें

मेरे समाधान के पीछे यह आवश्यक विचार है (हालांकि, मैं OrderedQअंत में जोड़े गए चेक के साथ एक द्विघात समय का उपयोग करता हूं) "अब जब हमने एक सॉर्ट किया है, तो क्या यह हमारे साथ शुरू हुआ है?"

— बूथ

Answer 29

जावास्क्रिप्ट

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

वे कहते हैं कि यह नकारात्मक संख्याओं पर अप्रत्याशित परिणाम देता है, लेकिन यह वास्तव में क्या है कि आप चीजों की भविष्यवाणी करने में कितने अच्छे हैं।

Comments

काश क्रोम लोगों को इस तरह की चीजों को करने से रोकने के लिए ऑब्जेक्ट गुणों को फेरबदल करता ...

— बर्गी

Answer 30

जावा (लेवेंसाइटिन दूरी)

इस कार्यान्वयन में, मैं मूल सरणी को क्लोन करता हूं और क्लोन किए गए उदाहरण को सॉर्ट करता हूं। फिर, लेवेंसहाइट दूरी की गणना की जाती है। यदि यह शून्य है, तो मूल सरणी को सॉर्ट किया गया था।

नोट: getLevenshteinDistance () कार्यान्वयन जकार्ता कॉमन्स लैंग से लिया गया है और इसे CharSequence के बजाय int [] पर काम करने के लिए संशोधित किया गया है।

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