51

একটি পূর্ণসংখ্যার অ্যারে দেওয়া, এমন একটি প্রোগ্রাম লিখুন যা নির্ধারণ করে যে এটি ক্রমবর্ধমান ক্রমে সাজানো আছে কিনা।

মনে রাখবেন এটি একটি কোড ট্রোলিং প্রশ্ন।

আমি সবচেয়ে আকর্ষণীয় উপায়গুলি খুঁজছি যা লোকেরা সামনে আসে।

বেশিরভাগ আপভোটের উত্তর জিতেছে।

এই প্রশ্নটি একটি 'ক্রিয়েটিভ' সমাধান দ্বারা অনুপ্রাণিত যা কোনও প্রার্থী আমাকে একটি সাক্ষাত্কারে দিয়েছিলেন :)

'সৃজনশীল' সমাধানটি এরকম কিছু ছিল:

বাছাই করা অ্যারের জন্য কারণ

যে কোনও উপাদানটির বাম দিকের সমস্ত উপাদান অবশ্যই ছোট হতে হবে

যে কোনও উপাদানটির ডানদিকে থাকা সমস্ত উপাদান অবশ্যই বড় হতে হবে

অতএব, সমস্ত উপাদানগুলির জন্য একটি প্রধান লুপ চালান এবং মূল একের ভিতরে দুটি নেস্ট লুপ চালিয়ে উপরের দুটি শর্তটি পরীক্ষা করুন (একটি বাম দিকে এবং একটি ডান পাশের জন্য)

আমি শোকাগ্রস্থ ছিলাম!!.

popularity-contest code-trolling

— microbian
সূত্র

58

এটি কোনও সদৃশ নয়। কিছু মডারেটর প্রতিটি প্রশ্ন এটি না পড়ে অন্যকে নকল করে চিহ্নিত করা প্রয়োজন বলে মনে করেন। এটি মোটেও বাছাই করার প্রশ্ন নয়। এটি পড়ুন।

— মাইক্রোবিয়ান

3

প্রতিযোগিতা শেষে আমি "সৃজনশীল" সমাধানটিও জানতে চাই! :)

— Vereos

16

@ মাইক্রো ডায়মন্ড মডারেটররা সম্প্রদায় নির্বাচিত are আপনি সুবিধাপ্রাপ্ত সিস্টেমের সাথে মডারেটরদের বিভ্রান্ত করছেন।

— ডুরকনব

3

@ মাইক্রোবিয়ান তাই আপনি কি লোকটিকে ভাড়া করেছেন?

— ভিজিওন

3

যদি কেবল স্ট্যাক এক্সচেঞ্জ এপিআইকে লেখার অ্যাক্সেসের অনুমতি দেওয়া হয় তবে আমি প্রশ্নটি জিজ্ঞাসা করি "এটি কি অ্যারেটি সাজানো হয়েছে?" এবং ইতিবাচক / নেতিবাচক উত্তরের উপর ভিত্তি করে গণনা করুন ..

— মাইকেল ফৌকারাকিস

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

এটি যদিও বাছাই করা অ্যালগরিদমের উপর নির্ভর করে। অ্যারে ইতিমধ্যে বাছাই করা হয়েছে কিনা তা ছাড়াই মার্জ বাছাই করা বা হিপ সাজানোর ক্ষেত্রে কোনও পার্থক্য দেখাবে না।

— নিক্লাস বি।

4

@NiklasB। রুবি কুইকোর্ট ব্যবহার করে । যে এই পদ্ধতি বলেন বিভ্রান্তিকর হতে এবং যখন ইনপুট অ্যারের হয় মিথ্যা positives দিতে পারে প্রায় সাজানো, বা, সম্ভাবনা বেশি, মিথ্যা নেগেটিভ যখন অ্যারের হয় সাজানো (এটা জন্য খুব অসম্ভাব্য হবে treference <= trunযে সাজানো ক্ষেত্রে জন্য শুধু nondeterministic অন্যান্য উপাদান কারণে) । তত্ত্বগতভাবে মনে হচ্ছে আপনি সাজানো ক্ষেত্রে প্রায় 50% মিথ্যা নেতিবাচক পেতে চান?

— জেসন সি

6

আকর্ষণীয় চিন্তাভাবনা কিন্তু নির্বিচারবাদী নয়। এটি প্রায় দশটি পুশ আপ করতে পারে এবং তারপরে আরও দশটি পুশ আপ করতে পারে এবং তারপরে সিদ্ধান্ত নেওয়া হবে যে প্রথম অ্যারেটি বাছাই করা হয়েছে কিনা তা নয় কারণ একজন পুশ আপসের দ্বিতীয় সেটটিতে আরও বেশি গিলেছে। আমরা কি ভুলে গেছি, আমরা বহু-টাস্কিং মেশিনগুলিতে কোড চালাই? খুব ছোট অ্যারেতেও, সময় স্লাইস কেবল পর্যাপ্ত সঠিক নয়। বন্য প্রয়াসের জন্য যদিও +1!

— এলএমএসিংহ

1

@NiklasB। টিমসোর্ট (মার্জ্টের একটি বৈকল্পিক) সাজানো (এবং আংশিকভাবে বাছাই করা) অ্যারেগুলিতে রৈখিক সময়ে চলে।

— বাকুরিউ

3

@ জেসনসি - এটি লক্ষ করার মতো যে এটি বাস্তবায়নকে আরও সন্দেহজনক করে তুলেছে: এটি কেবল এই জ্ঞানের উপরই নির্ভর করে না যে রুবির অভ্যন্তরীণ বাছাই অ্যালগরিদম হল চিকুইসকোর্ট (যা নিজেই অনির্ধারিত এবং সুতরাং নির্ভর করার জন্য একটি সন্দেহজনক জিনিস) তবে নির্দিষ্ট প্রয়োগটি ইতিমধ্যে সাজানো ডেটা (যেটি ডিফল্টরূপে কুইকোর্টে হয় না) ক্ষেত্রে কুইকোর্টটি কেবল ও (এন লগ এন) এর ক্ষেত্রে অনুকূল হয় ... এর নিকৃষ্টতম পারফরম্যান্স হ'ল (এন ^ 2) এবং একটি নির্বিকার প্রয়োগে ইতিমধ্যে বাছাই করা ডেটাতে প্রকৃতপক্ষে সবচেয়ে খারাপ পরিস্থিতি আহ্বান করা হচ্ছে)।

— জুলাইস

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 নয় ery

— পিয়েরে আরলাড

3

আমার অনুরূপ ধারণা ছিল যা অ্যারের জন্য জিজ্ঞাসা করবে, এবং তারপরে একে একে প্রম্পট "এটি এর চেয়ে বড় এটি?" এবং যদি সমস্ত সত্য হয়, তবে অ্যারে বাছাই করা হয়েছে

— Zach Thacker

41

জাভা - পুনরাবৃত্তিযোগ্য সাবসেটস

স্ট্যাক ওভারফ্লোতে স্বাগতম! এটি একটি দুর্দান্ত প্রথম প্রশ্ন, কারণ এটি এমনকি কিছু প্রবীণ কোডারকে স্টাম্প করে। আমি কেবল কোডটি হস্তান্তর করার আগে আপনাকে কিছুটা পটভূমি তথ্য দেই:

বাছাই করা নির্ধারণ করা প্রথম নজরে একটি কঠিন কাজ হতে পারে। দৈর্ঘ্যের যে কোনও সেটের জন্য এন রয়েছে! এটি অর্ডার করার সম্ভাব্য উপায়। এগুলিকে ক্রমানুসরণ বলা হয় । যদি আপনার অ্যারেতে পৃথক উপাদান থাকে তবে কেবলমাত্র সেই সম্ভাবনার মধ্যে একটির সাজানো হয়েছে! বাছাই করা একটিটি সন্ধান করতে, আপনি অন্যটি বাদ দিয়ে সঠিক (সম্ভবত কেবলমাত্র) একজনকে না পাওয়া পর্যন্ত আপনাকে সেগুলির মধ্যে সমস্তকে তদারক করতে হবে।

কি? নিশ্চয় তা না হয় যে হার্ড ...

এন সঙ্গে অ্যালগরিদম! জটিলতা বৃহত্তর ইনপুটগুলির জন্য দীর্ঘ সময় নেয়, তবে কিছুটা কাজের সাহায্যে আমরা এটিটি পেতে পারি এবং জটিলতার পুরো ক্রমটি সরিয়ে নিতে পারি। এটি এখনও ক্ষতিকারক সময়, তবে এটি ফ্যাকটোরিয়াল থেকে অনেক ভাল ।

এটি করার জন্য, আমাদের কেবল নিম্নলিখিত গাণিতিক সত্যটি বিবেচনা করা দরকার: যদি একটি অ্যারে বাছাই করা হয়, তবে এর প্রতিটি (অপেক্ষাকৃত আদেশিত ) সাবসেটগুলি পাশাপাশি সাজানো হয়। আপনি গণিতে বিশেষজ্ঞদের একটি আনুষ্ঠানিক প্রমাণের জন্য জিজ্ঞাসা করতে পারেন , তবে এটি স্বজ্ঞাত সত্য। উদাহরণস্বরূপ, সেটটির জন্য 123, যথাযথ উপগ্রহগুলি 1 2 3 12 13 23। আপনি দেখতে পারেন সেগুলি সমস্ত অর্ডার করা হয়েছে। এখন যদি আসলটি থাকে তবে 213আপনার থাকতে হবে 2 1 3 21 23 13এবং এখনই আপনি দেখতে পাচ্ছেন যে এটির 21ক্রম বাইরে রয়েছে।

এটির কারণটি গুরুত্বপূর্ণ কারণটি এন এর চেয়ে অনেক কম রয়েছে! সাব-সেট নির্বাচন। প্রকৃতপক্ষে, আমাদের কেবলমাত্র দুটি ^এন -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 বা এলিমেন্টে সাজানো 12 মিনিটের জন্য অপেক্ষা করার পরে এটি মেরে ফেলেছি। এটি প্রায় 45 সেকেন্ডের মধ্যে 11 উপাদানগুলি করবে। অবশ্যই এটি প্রথমে প্রস্থান করে অ-বাছাইয়ের জন্য, সুতরাং এটি হ'ল ভাল।

আপডেট: একটি তাজা পুনরায় বুট করার সময়, এটি 13 মিনিটের মধ্যে 12 টি উপাদান করে। 13 প্রায় 3 ঘন্টা সময় নেয়, এবং 14 20 ঘন্টা এবং গণনা হয়।

— Geobits
সূত্র

8

+1 এটি সম্ভবত আমি দেখা সবচেয়ে কম দক্ষ অ্যালগরিদম। ও (এন! * 2 ^ (এন!)) এর কাছাকাছি হওয়া উচিত - জটিলতা (সম্ভবত আরও খারাপ)।

— রাল জেরেক

6

আমি নিশ্চিত যে আমি খারাপ দেখা করেছি, কিন্তু এটা হয় বেশ খারাপ। আমি অর্ধ-হৃদয় দিয়ে জটিলতা নির্ধারণ করার চেষ্টা করেছি, কিন্তু ছেড়ে দিয়েছি এবং এটি বলেছি O(big)।

— জিওবিটস

1

এমন একটি সমাধান সরবরাহ করা যা কম দক্ষ হয় তবে ভ্রমণের বিক্রয়কর্মী সমস্যারও নিষ্পাপ প্রচেষ্টা চিত্তাকর্ষক!

— recursion.ninja

3

যেহেতু একটি 12 এলিমেন্ট অ্যারে বাছাই করার সুযোগটি 479 মিলিয়ন মধ্যে মাত্র 1, এটি সত্যই নিশ্চিত যে এটি নিশ্চিত যে এটি অবশ্যই কিছুটা সময় নিতে পারে? আপনি সত্যিকারের পৃথিবীতে আর কখনও দেখার সম্ভাবনা নেই ...

— জুলিউস

2

@ জিওবিটস কোন সমস্যা নেই ভিক্টরের অ্যালগরিদম চালান এবং প্রথম প্রম্পটে "হ্যাঁ" উত্তর দিন।

— জেসন সি 14

29

সি ++ - একটি নিষ্ঠুর বল পদ্ধতি

প্রত্যেকেই জানে যে ব্রুট ফোর্স পদ্ধতি সর্বদা দ্রুততম।

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

আসল রুটিনটি দীর্ঘ (এটি স্টাডি :: এনপোসে যায়) তবে আমি এখানে পোস্ট করার ক্ষেত্রে 30000 অক্ষরের মধ্যে সীমাবদ্ধ।

— মিঃ লিস্টার
সূত্র

আমি সত্যিই এটি পছন্দ করি.

— জাকব

3

এটি "মহিষের প্রতিটি অংশ ব্যবহার করুন" কেস স্টেটমেন্টের পদ্ধতির মতো।

— জোনাথন ভ্যান মাত্রে

এটা সত্যিই দারুন. সমস্ত লুপগুলি আনرول করুন!

— ম্যাককে

দুর্দান্ত চিন্তা !!!

— বিক্রম990

26

জানান

ক্লাসিক ইনফোকম জেড-মেশিন ইন্টারপ্রেটারের জন্য ইন্টারেক্টিভ ফিকশন গেম লেখার জন্য ইনফর্ম হল একটি ভাষা language স্পেলারদের এড়াতে, আমি প্রথমে আমার প্রোগ্রামের ফলাফলগুলি দিচ্ছি, তারপরে উত্স কোড।

সম্পাদনা: অ্যারেতে সংখ্যার যোগ করার অনুমতি দেওয়ার জন্য আমি একটি ছোট্ট সংশোধন করেছি এবং একটি কমনীয় কক্ষের বিবরণ অন্তর্ভুক্ত করেছি।

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

ডোজে রুবি

প্রথমে আপনাকে এই সেটআপ কোডটি চালাতে হবে

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

এবং আপনার উত্তর মুদ্রিত করা হবে (সত্য বা মিথ্যা)।

সর্বোত্তম পারফরম্যান্সের জন্য দয়া করে ডেজ কোড যুক্ত করুন:

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

এই সবচেয়ে সহজ উপায়।

(ASCII শিল্পটি আমার লেখা একটি স্ক্রিপ্ট দ্বারা উত্পন্ন হয়েছিল, যা এই চিত্র থেকে প্রাপ্ত ))

— ডোরকনব
সূত্র

7

আপনি "তাই অ্যালগরিদম" ভুলে গেছেন। একটি বাস্তব ডেজ নমুনায় "ওয়াও" এর আগে 3 টি বাক্য রয়েছে। এবং হ্যাঁ, আমি পার্টিতে খুব মজা করি।

— পিয়েরে আরলাড

@ArlaudPierre হেহ, ঠিক আছে, সংশোধন করা হয়েছে: পি

— Doorknob

11

সুতরাং মন্তব্য, খুব উন্নতি, অনেক দরকারী। কি দারুন.

— পিয়েরে আরলাড

আপনার একটি দোজের মতো আকৃতির আকারে একটি বিএফ প্রোগ্রাম লেখা উচিত ছিল ... নতুন প্রশ্ন ধারণা !!

— TheDoctor

19

পিএইচপি

আপনি নীচের সমাধানটির স্বাচ্ছন্দ্য এবং সোজাসাপ্টা পছন্দ করবেন। কোডিংয়ের এই মাস্টারপিসে ব্যবহৃত সামগ্রিক ধারণা এবং কাটিয়া প্রান্ত ফাংশনগুলি আপনাকে অবিলম্বে বিশ্বের শীর্ষ বিকাশকারীদের অভিজাত তালিকায় নিয়ে আসবে।

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 কারণ আপনি বাছাই করা প্রশ্নের আমার উত্তরটির

— ভিক্টর স্টাফুসা

4

মিসেস রবার্টস যদি মানগুলিতে প্রবেশ করে তবে এটি কাজ করবে?

— ব্যবহারকারী 80551

3

@ ব্যবহারকারী 80551 হ্যাঁ কারণ শিক্ষার্থী বলে কোনও টেবিল নেই

— freak

3

@ জোনাথনভ্যানম্যাট্রে অবশ্যই সুরক্ষা এই কোডের একটি শক্তিশালী দিক।

— ভিজিওন

1

এটি এই ওয়েবসাইটে আমার নতুন প্রিয় উত্তর; তবে অতিরিক্ত চিহ্নের জন্য আপনি সুরক্ষার জন্য আপনাকে পিডিও ব্যবহার করতে দেখতে পছন্দ করবেন

— আলেকজান্দারক্যানন

17

সি # - পরিসংখ্যান শক্তি

এটি সমাধানের জন্য আপনাকে যা করতে হবে তা হ'ল প্রশ্নটিকে এমনভাবে ফ্রেম করা যাতে সমাধানটি সুস্পষ্ট হয়ে যায়। কারণ এটি মূলত একটি "সত্য-মিথ্যা" ধরণের প্রশ্ন, আপনি মূলত যা জিজ্ঞাসা করছেন তা হ'ল "অ্যারে সাজানো হয়েছে তা আমি কীভাবে 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

এই ফাংশনটির কার্যকারিতা প্রসারিত করা খুব সহজ, কারণ "বেশিরভাগভাবে বাছাই করা" বা "আরও সাজানো নয়" বা "সম্পূর্ণরূপে এলোমেলো" এর মতো কার্যকারিতা যুক্ত করা তুচ্ছ হবে।

সম্পাদন করা

অ্যালগরিদমের দক্ষতাটি প্রায় যেতে ভুলে গেছেন। এটি বর্তমানে ও (7)। পদ্ধতির নামে একটি, "কীওয়ার্ডগুলির জন্য" প্রত্যেকের মধ্যে একটি, "ডাবল" ঘোষণায় একটি এবং ভেরিয়েবল "সাজানো" এর ব্যবহারে দুটি রয়েছে। ফাংশনটির নাম পরিবর্তন করে, ডাবলকে দশমিক দশকে পরিবর্তন করে, "সর্টনেস" কে "এসআর্টডনেস" এ রূপান্তর করে এবং লুপগুলিতে রূপান্তর করে আপনি O (0) এর নিচে (যা আপনি যেতে পারেন তত কম) এ সমস্ত উন্নতি করতে পারবেন the লুপ যখন

— Comintern
সূত্র

2

আমি কঠোর পরিশ্রম করে জটিলতাটি পুনরায় গণনা করেছি এবং এটি হে (8) হিসাবে নির্ধারণ করেছি। আপনি আউটপুটটি হ্যান্ডওয়েভ করছেন, যা আমি বিশ্বাস করি যে এর কারণটি হওয়া উচিত a সত্যিকারের হে ()) জটিলতা পেতে আপনি "বাছাই করা" / "সাজানো" এর পরিবর্তে "আরোহী" / "হাফাজার্ড" ফেরত বিবেচনা করতে পারেন।

— জিওবিটস

@ জিওবিটস - আমি আবার এটির দিকে তাকালাম এবং অবশ্যই আপনি সঠিক। আমি অনুমান করি যে এটিগুলি দেখায় যে স্ট্রিংগুলি ফেরত দেওয়ার সময় ও (1) এর ন্যূনতম জটিলতা রয়েছে। যদিও এটি প্রদানের জন্য এটি একটি ছোট দাম, কারণ বুলিয়ান ফেরত দেওয়া দ্বিগুণ খারাপ is

— কমিন্টার্ন

1

ও () গণনার জন্য +1। স্পিয়ারম্যান রহও গণনা না করার জন্য -1, কারণ দুটি তুলনামূলক একের চেয়ে ভাল হয় না? এবং পরিসংখ্যানবিদদের প্রমাণিত প্রিয় সি # তে পরিসংখ্যানগুলির জন্য +1।

— জোনাথন ভ্যান মাত্রে

দয়া করে আমাকে বলুন O(7)জিনিসটি একটি রসিকতা

— mbatchkarov

@ এমবাচকারভ - এটি অল্প স্বীকৃতি। :-)

— কমিন্টার্ন

16

চুনি

নিম্নলিখিত কৌশলটি শেষ পর্যন্ত প্রকাশ করবে যদি একটি অ্যারে বাছাই করা হয়:

একজন একটি অ্যারের হতে (হয় সাজানো বা পাঁচমিশালী, যেমন [1,2,3] বা [1,3,2])
পি এর সমস্ত ক্রম ধারণ করে এমন একটি অ্যারে হতে হবে একটি
যদি A বাছাই করা হয় তবে এটি হয় সর্বাধিক বা ন্যূনতম পি (যা মূলত রুবিতে A এর সাজানো সংস্করণ )

পরীক্ষার জন্য অনলাইন সংস্করণ ।

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

— ডেভিড হারম্যান
সূত্র

1

আমি ব্যাখ্যাটি আমি বুঝি বলে মনে করি না। যদি অ্যারে হয়, উদাহরণস্বরূপ, [1, 9, 100], তবে মিনিটটি 10019 এবং সর্বোচ্চ 91100 হয়, তবে সাজানো সংখ্যা 19100 হয় with [1,9,100] হয়। কিছুই দেখতে পাচ্ছে না যেখানে "একটি সংখ্যা দ্বারা প্রতিনিধিত্ব করা হচ্ছে"; দেখে মনে হচ্ছে অ্যারেগুলি কেবল অভিধান সংক্রান্ত অর্ডার দেওয়া হচ্ছে। আমার ধারণা, এটি যদি একই হয় তবে সমস্ত সংখ্যা যদি কেবল একটি অঙ্ক হয়।

— জোশুয়া টেলর

"... হয় সর্বাধিক বা সর্বনিম্ন ..." এটি পছন্দ করেছিল।

— মাইক্রোবিয়ান

@ জোশুয়া টেলর: মাথা উঁচু করার জন্য ধন্যবাদ! আমি এটিকে সহজেই বোধগম্যভাবে ব্যাখ্যা করতে চেয়েছিলাম - যা শেষ পর্যন্ত ভুল হয়ে গেছে;) আমি আমার বর্ণনাটি সংশোধন করেছি ...

— ডেভিড হারম্যান

2

@ জোশুয়া টেইলর রুবি পদ্ধতিগুলি অ্যারে # সর্বাধিক এবং # মিনিট <এবং> অপারেটরদের সাথে সম্মান জানিয়ে বৃহত্তম এবং ক্ষুদ্রতম উপাদান নির্বাচন করুন। অ্যারেতে, <এবং> অভিধানিকর বাছাইকরণ প্রয়োগ করুন। [1,9,100] হ'ল ডিক্সোগ্রাফিক ক্রম অনুসারে 1, 9 এবং 100 এর আদেশযুক্ত অনুমতিগুলির মিনিমা।

— কার্ল দামগার্ড আসমুসেন

এটি প্রায় উত্পাদন মানের।

— primo

12

সি # - অ-নিরস্তকর সমাধান

এই কোড সম্ভবত কাজ করে।

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
}

— fejesjoco
সূত্র

8

যদি আপনি পুনরাবৃত্তির সংখ্যা -n ^ 2 * ln (1-p) তে সেট করেন, আপনি পি এর সম্ভাব্যতার সাথে নিশ্চিত করতে পারেন যে সমস্ত সংমিশ্রণগুলি পরীক্ষা করা হবে!

— হান্নেশ

এবং এই সমাধানটিকে "ওয়ার্কিং কোড তবে ট্রোলিং" হিসাবে গৃহীত হওয়ার জন্য পি এর কোন মানগুলি বৈধ? :)

— ফেব্রুজোকো

2

থেকে stackoverflow.com/questions/2580933 , কসমিক রে কারণে তুলনা ভুল সম্ভাবনা 0.0000018 (1.8e -6) প্রতি সেকেন্ডে হবে। সুতরাং যদি: ১) কোনও পুনরাবৃত্তির জন্য কতক্ষণ সময় লাগে তা বুঝতে পারেন, ২) আমরা সম্ভাবনা গণনা করতে @ হানেশের সূত্রটি ব্যবহার করতে পারি, এবং তারপরে আপনার সমাধানটিকে অবিচ্ছেদ্য করে তোলে এমন পুনরাবৃত্তির সংখ্যা খুঁজতে সমীকরণের সিস্টেমটি সমাধান করতে পারি We স্ট্যান্ডার্ড ইসর্টড পদ্ধতি।

— 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_sort ((1,2,3]) #True
is_sort ((3,2,1]) #
ফাঁকা_সোর্ট করা হয়েছে ([1,4,3,2,0,3,4,5]) # ভুল

পর্যবেক্ষক পাঠক লক্ষ্য করবেন যে এটি ঠিক এর মতো কাজ করে না।
is_sort ((1,4,3,2,0,3,4,11]) #
মিথ্যা অনুসারে বাছাই করা হয়েছে ([1,4,3,2,0,3,4,12]) #
স্রোত is_sorted ([1,2,2 1, 1,2,1,2,1,2,99]) # ট্রু

— VBCPP
সূত্র

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 ফলাফলকে মূল অ্যারের সাথে তুলনা করুন।

বাশের সাথে আমি খুব একটা ভাল নই, আমি কেবল এটি চেষ্টা করে দেখতে চেয়েছিলাম :)

— জাচ ঠাকর
সূত্র

খুব ভাল, এটি ধরে নিয়েছে যে "./nums" ডিরেক্টরিটি ইতিমধ্যে বিদ্যমান রয়েছে। কোথাও একটি "mkdir -p nums" হতে পারে?

— ক্যামেলথেমেমেল

ওহ, হ্যাঁ এটি উপলব্ধি করে: পি

— জাচ ঠাকুর

8

সি শার্প

"ছোট" অথবা "বড়" এর ধারণার হয় এত 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] == ০.

— সাইমন

@ সিমন ওহ হো! প্রকৃতপক্ষে, আমি অনুমান করি যে দুটি অভিন্ন সংখ্যা বাছাই হয়েছে। এই প্রান্তের ক্ষেত্রে তুলনা যুক্ত করা হয়েছে ভাল লাগছে।

— পিয়েরে-লুক পিনাল্ট

5

জেনে খুশি যে {0, -1, 2। একটি বাছাই করা তালিকা।

— পিয়েরে আরলাড

9

@ আরলাডপিয়ার আপনি যদি ২০১৪ সালের আসল প্রোগ্রামার হতে চান তবে আপনাকে নেতিবাচক সব কিছু আলাদা করে রাখতে হবে। বিশ্ব ইতিবাচক, বিশ্ব নিরঙ্কুশ, বিশ্বটি মডুলো!

— পিয়েরে-লুক পিনাল্ট

1

যেহেতু আপনি "বৃহত্তর" এবং "আরও ছোট" ধারণাটি পছন্দ করেন না, তাই এটি লজ্জাজনক যেগুলি আপনাকে এর চেয়ে কম এবং বৃহত্তর চিহ্নগুলি অন্তর্ভুক্ত করতে হয়েছিল। আপনার তালিকার চেয়ে অ্যারে ব্যবহার করা উচিত ছিল।

— মিস্টার লিস্টার

8

scala

একটি অ্যারে বাছাই করা হয় কিনা তা পরীক্ষা করা সহজ! প্রথম উপাদানটি দ্বিতীয়টির চেয়ে কম কিনা তা পরীক্ষা করে দেখুন। তারপরে বাক্যগুলি বাছাই করুন এবং দেখুন যে তারা সমান if

দুর্ভাগ্যক্রমে, বাছাই করা একটি কঠিন সমস্যা। অ্যারে বাছাই করার জন্য অনেক সুপরিচিত বা দক্ষ অ্যালগরিদম নেই; প্রকৃতপক্ষে এটি কম্পিউটার বিজ্ঞানের জ্ঞানের বর্তমান অবস্থার একটি বিশাল অন্ধ-স্পট। সুতরাং আমি একটি সাধারণ অ্যালগরিদম প্রস্তাব করছি: অ্যারে পরিবর্তন এবং তারপর এটি বাছাই করা হয়েছে কিনা তা যাচাই করুন, যেমন ইতিমধ্যে বলা হয়েছে, সহজ! এটি বাছাই করা অবধি পরিবর্তন করুন।

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

পূর্ণসংখ্যার সাজানো অ্যারেতে এমন বৈশিষ্ট্য রয়েছে যা প্রতিটি উপ-অ্যারে (অ্যারের উপাদানগুলির মাধ্যমে এন উপাদানগুলি বলুন) এছাড়াও সংখ্যার সাজানো অ্যারে হয়। এটি স্পষ্টতই বোঝায় যে সেরা পদ্ধতিটি একটি পুনরুত্থিত ফাংশন:

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

এটি দ্রুততম পদ্ধতি নাও হতে পারে তবে তালিকার অর্ডার দেওয়া হয়েছে কিনা তা খুব কম-বেশি একটি খুব স্বীকৃত পরীক্ষা নয়। এই কোডটি পড়া এবং বুঝতে এটি অবিশ্বাস্যরকম সহজ কারণ এটি একটি কার্যকরী দৃষ্টান্ত ব্যবহার করে এবং তাই রাষ্ট্র পরিবর্তন এবং পুনরুক্তিযুক্ত লুপের ভয়াবহতা থেকে মুক্ত।

আমি আশা করি এটি আপনার জন্য দরকারী তথ্য হবে।

— অ্যালেন
সূত্র

6

সি # - দীর্ঘতম বর্ধমান অনুচ্ছেদ

বাছাই করা অ্যারের জন্য, দীর্ঘতম বর্ধমান অনুচ্ছেদের দৈর্ঘ্য অ্যারের দৈর্ঘ্যের সমান। আমি এখান থেকে অ্যালগরিদম অনুলিপি করেছি , কেবল এটি বাড়ানোর পরিবর্তে অ-হ্রাসযোগ্য হিসাবে পরিবর্তন করেছি।

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

— fejesjoco
সূত্র

6

স্টোনস্ক্রিপ্ট (সি) এলএমএসিংহ - 0 বিয়োগ (4102 প্যালিনড্রোমড)।

স্টোনস্ক্রিপ্ট (সি) -এর নীচে লিখিত হয়েছে, বহু শতাব্দী আগে আমার দ্বারা কপিরাইটযুক্ত এবং আমার দ্বারা ব্যবহৃত একটি ভাষা, অর্থাত্ মিডেজফ্রেমগুলির আগে পুরানো সময়ে। দ্রষ্টব্য: এটি সংস্কৃতের পূর্বসূরী।

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

= - = - = - = - = - =
আপনার সমস্ত কোড স্যুথ এবং পাওয়ার ডিবাগারের জন্য, আমি উপরের দ্বিতীয় ধাপের দ্বিতীয় প্রকারের মধ্যে ইচ্ছাকৃতভাবে একটি বাগ যুক্ত করেছি you আপনি এটি খুঁজে পেতে পারেন?

— LMSingh
সূত্র

3

আমি বাগটি খুঁজে পেয়েছি - সমস্ত 4.3.*হওয়া উচিত4.2.*

— টিমটেক

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 থেকে দৈর্ঘ্যের হতে হবে। বিটিডাব্লু, 1,2,3 বাছাই করা উচিত, তাই না?

— মাইক্রোবিয়ান

@ মাইক্রোবিয়ান ঠিক আছে, সম্পাদিত।

— ভিক্টর স্টাফুসা

4

সি

পরবর্তীতে, "বাছাই করা" এর অর্থ "আরোহী ক্রমে সাজানো"।

একটি অ্যারে if বাছাই করা হয় না a[i]>a[i+1]

সুতরাং আমরা যদি x=a[i]-a[i+1],x ইতিবাচক হতে হবে iff অ্যারে সাজানো হয় না।

xইতিবাচক হওয়ার জন্য পরীক্ষা করার জন্য , আমরা এটিকে দুটি ভাগে বিভক্ত করতে পারি: xnegativeণাত্মক নয়, এবংx শূন্য নয়

xNegativeণাত্মক কিনা তার একটি সহজ পরীক্ষা হ'ল আমরা 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;
}

— ace_HongKongIndependence
সূত্র

আসলে, এর জন্য পরীক্ষা a[i]-a[i+1] > 0করা ইতিমধ্যে সমস্যাযুক্ত। এই ধরণের স্টাফগুলি করার দরকার নেই।

— n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

অপ্রয়োজনীয় জিনিস করা কোড ট্রোলিংয়ের পুরো পয়েন্ট, তাই না? (এবং সমস্যাযুক্ত বলতে কী

— বোঝ

1

স্বাক্ষরযুক্ত পূর্ণসংখ্যার ওভারফ্লো হ'ল ইউবি। এমনকি যদি আমরা আচরণের চারপাশে মোড়কে সংজ্ঞায়িত করি, এমনকি যদি আমরা INT_MAX - INT_MIN করি তবে ফলাফলটি একটি নেতিবাচক সংখ্যা হবে (একটি [i] কে INT_MAX এবং একটি [i + 1] INT_MIN এর সাথে প্রতিস্থাপন করবে)।

— n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

যেহেতু এটি কেবলমাত্র হোমওয়ার্কের সমস্যা, তাই ধরে নেওয়া যাক যে শিক্ষক এত চরম সংখ্যা দেবেন না।

— #HongKongInd dependence

ঠিক আছে. আমি ট্রল করতে পছন্দ করি তা খারাপ evil

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

এটা কি ট্রিট নয়?

— n0la
সূত্র

4

সি

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

সম্ভাব্যতা 1- (1 / n!) এবং জটিলতা O (1) নিয়ে কাজ করে। স্পষ্টতই খুব বড় এলোমেলো অ্যারেগুলির জন্য সেরা পদ্ধতি।

জটিলতা কেবল ও (1) হওয়ায় আরও ভাল অনুমানের জন্য, দু'বার চালান।

— cpri
সূত্র

3

সি

এই ক্রিয়াটি অ্যারে বাছাই করা থাকলে আপনাকে আরও বেশি কিছু বলছে। এটি আপনাকে জানায় যে কতগুলি উপাদান সঠিক জায়গায় রয়েছে। এটি যে কোনও ধরণের ডেটার জন্য ব্যবহার করা যেতে পারে।

আপনার কোড অনুসরণ করা সহজ করতে বর্ণনামূলক পরিবর্তনশীল নামগুলি ব্যবহারের গুরুত্বটি নোট করুন। অন্যদিকে, আমাদের ভেরিয়েবল 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

"আমাদের ভেরিয়েবলটি ঘোষণার দরকার নেই, কারণ এটি প্রোগ্রামের অন্য কোথাও ঘোষিত হতে বাধ্য" " একটি হাসি মূল্য ছিল।

— জোনাথন ভ্যান মাত্রে

@ জোনাথানভানম্যাট্রে ধন্যবাদ তবে কোনওভাবেই এই কোডটিতে ভুল হওয়া উচিত না।

— স্তর নদী সেন্ট

3

জাভাস্ক্রিপ্ট + আরও পরিসংখ্যান

আমি @ পরিচালকগণের দ্বারা প্রস্তাবিত সমাধানটি পছন্দ করেছিলাম। তবে ইতিমধ্যে সাজানো তালিকার সাথে তুলনা করছেন? এটাই প্রতারণা!

পরিবর্তে, আমি অ্যারের স্বতঃসংশোধন গণনা করি (অ্যারে এবং অ্যারে বামে একটি অবস্থান সরিয়ে নিয়ে পারস্পরিক সম্পর্ক)। তারপরে, আমি অ্যারের প্রচুর বার পরিবর্তন করি এবং প্রতিবার এটি নতুন স্বতঃসংশোধনটিকে মূল স্বতঃসংশ্লিষ্টতার সাথে তুলনা করি। যদি অ্যারে বাছাই করা হয় তবে মূল স্বতঃসংশোধন সবচেয়ে বেশি সময় হত!

http://jsfiddle.net/dB8HB/

বোনাস: আপনার পি-মান <0.05, আউটপুট আপনার জন্য অ্যারে বাছাই করা হয়েছে দাবি করার কাজটি স্বয়ংক্রিয় করবে। আপনি আর কি চাইতে পারেন?

বোনাস 2: যদিও এই প্রয়োগটি সুবিধার জন্য জাভাস্ক্রিপ্টের ও (এন) অ্যারে ফাংশনগুলি ব্যবহার করে, তবে পদ্ধতির ধ্রুবক সময়ে চালানোর জন্য নমুনা ব্যবহার করতে পারে!

<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

জাভাস্ক্রিপ্ট / এসভিজি - সানডায়ালসোর্ট

এই সমাধানটি <, <=,> বা> = তুলনামূলক ব্যবহার করে না। আমি এটিকে যতটা সম্ভব একটি সাজানোর ফাংশনের মতো সামান্য পড়ার চেষ্টা করেছি।

পদ্ধতি

একটি চাপকে বরাবর বিন্দু হিসাবে মানগুলি প্লট করুন।
একটি আরোহণ অ্যারের জন্য প্রতিটি মান অঙ্কনকে মোট প্রশস্ত করতে হবে এবং প্রারম্ভিক এক্সকে কমিয়ে দেবে না (ব্যতিক্রম: দুটি অভিন্ন মান)।
প্রস্থটি সংকুচিত হতে পারে না! = যথেষ্ট হবে,
এক্স হিসাবে একটি == বৃদ্ধি করতে পারে না যথেষ্ট হবে।
দুইটি অভিন্ন মানের জন্য ঠিক করতে প্রতিটি বিন্দু আসলে বর্ধমান দৈর্ঘ্যের একটি লাইন। যেখানে ইউনিটের দৈর্ঘ্য মান / সংখ্যার চেয়ে কম।

trolling

এই খুব খারাপ কোডটি পড়ার যাত্রায় আমি নিম্নলিখিত মুখ-পামগুলি যুক্ত করেছি।

ফাংশনটি অ্যারের বাছাইয়ের মতো দেখতে এটির নাম সানডায়ালসোর্ট (বোনাস খারাপ মূলধন)
সমস্ত পরিবর্তনশীল নামের জন্য লিট-গিক রেফারেন্স ব্যবহৃত হয়
অ্যারেতে উপাদানগুলির সংখ্যা গণনা করতে রেগেক্স হাতুড়ি ব্যবহার করেছেন
একটি সতর্কতা বাক্স ব্যবহৃত
প্রান্তের ক্ষেত্রে সমাধান যেখানে ধারাবাহিকভাবে 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/

— OutRideACrisis
সূত্র

3

সি

যেহেতু বাইনারি অনুসন্ধান কেবল বাছাই করা অ্যারেগুলিতে কাজ করে, কোনও অ্যারে বাছাই করা হয়েছে কিনা তা পরীক্ষা করতে, আমাদের কেবল যা যা করা দরকার তা যাচাই করা উচিত যে বাইনারি অনুসন্ধান অ্যারের সমস্ত উপাদানগুলির জন্য কাজ করে। যদি এটি কোনও উপাদান খুঁজে পেতে ব্যর্থ হয় তবে আমরা জানি অ্যারে বাছাই করা হয়নি।

প্রদত্ত কমান্ড-লাইন আর্গুমেন্টগুলি অবশ্যই শীর্ষস্থানীয় জিরো ছাড়াই দশমিক পূর্ণসংখ্যার হতে হবে।

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

— hvd
সূত্র

3

জাভাস্ক্রিপ্ট

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

— জেসন সি
সূত্র

1

{ 69 , 313 , 187 , 31338 }

— জিওবিটস

2

সি

অ্যারের একটি অনুলিপি তৈরি করুন
অনুলিপি ক্রমে অনুলিপি করুন
এই অ্যারে প্রদত্ত অ্যারেটির বিপরীত কিনা তা পরীক্ষা করে দেখুন

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


     }

— Mhmd
সূত্র

2

ম্যাথামেটিকাল

এই অ্যালগরিদমটি কাজ করছে বলে মনে হচ্ছে তবে এটি কিছুটা ধীর। বাছাই করার আরও দ্রুত উপায় থাকতে পারে তবে আমি সেগুলি পাই নি।

তালিকার এলোমেলো ক্রম করুন এবং এটি (সহ OrderedQ) ক্রমানুসারে রয়েছে কিনা তা পরীক্ষা করুন ।
যদি তা হয়, থামো। অন্যথায়, পদক্ষেপ 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}

— DavidC
সূত্র

কাজটি ইনপুটটি ইতিমধ্যে সাজানো হয়েছে কিনা তা পরীক্ষা করা ছিল ।

— ইলমারি করোনেন

এটিই আমার সমাধানের পিছনে প্রয়োজনীয় ধারণা (যদিও আমি OrderedQচতুষ্পদের জন্য একটি চতুর্ভুজ সময় ব্যবহার করি) শেষে যোগ করা চেকটি দিয়ে "এখন যে আমাদের একটি বাছাই করা হয়েছে, এটি কি আমরা শুরু করে দিয়েছি?"

— বুথবি

2

জাভাস্ক্রিপ্ট

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

তারা বলছেন এটি নেতিবাচক সংখ্যার উপর অপ্রত্যাশিত ফলাফল দেয়, তবে এটি আসলে কী তা আপনি ভবিষ্যদ্বাণী করার ক্ষেত্রে কতটা ভাল।

— Ry-
সূত্র

2

আমি আশা করি লোকেরা এই জাতীয় জিনিসগুলি করা থেকে বিরত রাখার জন্য ক্রোম বস্তু বৈশিষ্ট্যগুলিকে

— বদলে দেবে

2

জাভা (লেভেনস্টাইন দূরত্ব)

এই বাস্তবায়নে, আমি আসল অ্যারের ক্লোন করে ক্লোন করা দৃষ্টান্তটি বাছাই করি। তারপরে, লেভেনস্টাইন দূরত্ব গণনা করা হয়। যদি এটি শূন্য হয়, তবে মূল অ্যারে বাছাই করা হয়েছিল।

দ্রষ্টব্য: 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];
    }
}

— user3001267
সূত্র

একটি অ্যারে বাছাই করা হয়েছে কিনা তা নির্ধারণ করার জন্য "ক্রিয়েটিভ" উপায়গুলি

চুনি

জাভাস্ক্রিপ্ট

জাভা - পুনরাবৃত্তিযোগ্য সাবসেটস

কি? নিশ্চয় তা না হয় যে হার্ড ...

পর্যাপ্ত আলোচনা, কোড আছে!

সি ++ - একটি নিষ্ঠুর বল পদ্ধতি

জানান

ডোজে রুবি

পিএইচপি

সি # - পরিসংখ্যান শক্তি

চুনি

সি # - অ-নিরস্তকর সমাধান

সি শার্প

scala

সি # - দীর্ঘতম বর্ধমান অনুচ্ছেদ

জাভাস্ক্রিপ্ট

সি

সি

সি

জাভাস্ক্রিপ্ট + আরও পরিসংখ্যান

জাভাস্ক্রিপ্ট / এসভিজি - সানডায়ালসোর্ট

পদ্ধতি

trolling

XML

ক্রিয়া

সি

জাভাস্ক্রিপ্ট

সি

ম্যাথামেটিকাল

জাভাস্ক্রিপ্ট

জাভা (লেভেনস্টাইন দূরত্ব)