配列がソートされているかどうかを判断する「創造的な」方法

51

整数配列を指定して、昇順でソートされているかどうかを判断するプログラムを作成します。

これはコードトローリングの質問であることを忘れないでください。

私は人々が思いつく最も興味深い方法を探しています。

ほとんどの賛成票の答えが勝ちです。

この質問は、候補者がインタビューで私にくれた「創造的な」解決策に触発されました:)

「創造的な」ソリューションは次のようなものでした。

  • ソートされた配列のため

    • 要素の左側にあるすべての要素は小さくする必要があります
    • 要素の右側にあるすべての要素はより大きくなければなりません

したがって、すべての要素に対してメインループを実行し、メインループ内で2つのネストされたループを実行して、上記の2つの条件を確認します（左側に1つ、右側に1つ）

私はショックを受けました！！。

popularity-contest  code-trolling 
— ミクロビアン
ソース
58
これは重複ではありません。一部のモデレーターは、すべての質問を読まずに他の質問と重複してマークする必要があると感じています。これはソート問題ではありません。それを読んで。
— ミクロ
3
コンテストの終わりに、私は「創造的な」解決策についても知りたいです！:)
— ヴェレオス14
16
@micro Diamondのモデレーターはコミュニティによって選出されます。モデレーターを特権システムと混同しています。
— ドアノブ
3
@microbianじゃああの人を雇ったの？
— VisioN 14
3
StackExchange APIのみが書き込みアクセスを許可した場合、「この配列はソートされていますか？」という質問をします。そして...正/負の回答にupvotesを数える
— マイケルFoukarakis

回答:

77

ルビー

並べ替えは非常に遅く、多くのサイクルを要します（できることはを使用することですn log(n)）。したがって、配列がソートされているかどうかを確認するのは非常に簡単です。必要なのは、配列の並べ替えと並べ替えられた配列の並べ替えのランタイムを比較することだけです。

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

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

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

## compare run times
if trun > treference
  print "array was not sorted"
else
  print "array was sorted"
end
— ハワード
ソース
19
ただし、これはソートアルゴリズムに依存します。配列が既にソートされているかどうかに関係なく、マージソートまたはヒープソートはまったく違いを示しません。
— ニクラスB. 14
4
@NiklasB。Rubyはquicksortを使用します。つまり、このメソッドはトリッキー取得し、入力配列がされたときに偽陽性を与えることができると述べほとんど配列をする場合、可能性が高く、偽陰性をソート、またはされる（それがために非常に低いだろうソートtreference <= trunだけによる非決定的な他のものに、すべてのソートされた場合） 。理論的には、ソートされたケースで約50％の偽陰性を得るように思われますか？
— ジェイソンC
6
興味深い考えですが、決定論的ではありません。10回の腕立て伏せをしてからさらに10回の腕立て伏せを行い、2番目の腕立て伏せで汗をかいたために最初の配列をソートするかどうかを決定するのと同じくらい良いです。マルチタスクマシンでコードを実行することを忘れましたか？また、非常に小さなアレイでは、タイムスライスの精度が十分ではありません。しかし、猛烈な試みのために+1！
— LMSingh 14
1
@NiklasB。Timsort（mergesortのバリアント）は、ソートされた（および部分的にソートされた）配列で線形時間で実行されます。
— バクリウ14年
3
@JasonC-これは上記の実装をさらに疑わしいものにすることに注意する価値があります：それはルビーの内部ソートアルゴリズムがクイックソートであるという知識だけでなく（それ自体は文書化されておらず、したがって依存する疑わしいものです）、特定の実装すでにソートされたデータの場合に最適化されます（デフォルトではクイックソートではありません：クイックソートは平均的なケースでO（n log n）のみです...その最悪の場合のパフォーマンスはO（n ^ 2）であり、単純な実装では実際には、最悪のケースは既にソートされたデータで呼び出されています）。
— ジュール14年
52

Javascript

array = prompt("Give the array");
while (true) {
    sorted = prompt("Is it sorted?");
    if (/yes|Yes/.test(sorted)) {
        alert("The array is sorted.");
        break;
    } else if (/no|No/.test(sorted)) {
        alert("The array is not sorted.");
        break;
    } else {
        alert("Dear user:\n\nPlease refer to the manual (RTFM) to observe how to use the system accordingly to the defined business rules.\nNow, try again.");
    }
}
— ビクター・スタフサ
ソース
55
-1 JQueryが十分ではありません。
— ピエールアラード14
3
私は配列を要求する同様のアイデアを持っていて、1つずつプロンプトが「これはこれよりも大きいですか？」すべてに該当する場合と、その配列をソートする
— ザックタッカー
41

Java-再帰サブセット

Stack Overflowへようこそ！これは優れた最初の質問です。ベテランのコーダーも困惑するからです。コードを配布する前に、背景情報を少し教えてください。

ソートされているかどうかを判断することは、一見すると難しい作業です。長さnの任意のセットに対して、n！注文の可能な方法。これらは順列と呼ばれます。配列に個別の要素がある場合、それらの可能性の1つだけがソートされます！ソートされたものを見つけるには、適切な（場合によってのみ）ものが見つかるまですべてをふるいにかけ、他のすべてを破棄する必要があります。

何？確かにそうではありませんことを、ハード...

n！のアルゴリズム 複雑さは大きな入力には長い時間がかかりますが、少し手間をかけることでそれを回避し、複雑さを一段階下げることができます。それはまだ指数関数的な時間ですが、はるかに良いです、階乗もます。

これを行うには、次の数学的な事実のみを考慮する必要があります。配列が並べ替えられる場合、その（相対的に順序付けられた）サブセットもすべて並べ替えられます。数学の専門家に正式な証明を求めることができますが、それは直感的に真実です。たとえば、setの123場合、適切なサブセットは1 2 3 12 13 23です。すべて注文されていることがわかります。オリジナルがの場合、213持っているでしょう2 1 3 21 23 13、すぐにそれを見ることができます21が故障し。

これが重要な理由は、nよりはるかに少ないためです！サブセット。実際、2 nしかない見なければ -2サブセットです。空のセットだけでなく、元の数値の配列全体を含むセットを除外できます。

それでも、2 n -2は多くの作業になる可能性があります。多項式時間を超えるほとんどのことと同様に、ここでは分割統治アプローチがうまく機能します。最も簡単なアプローチ？再帰！

基本的な手順は簡単です。入力のすべてのサブセットに対して、より小さなサブセットを生成します。次に、それらのそれぞれについて、同じことを行います。サブセットのサイズが2になったら、どれが大きいかを確認します。毎回サブセットのサイズを縮小するので、実際には予想よりも速くなります。

ここでの重要な事実は、順序が正しくない単一のサブセットが見つかったらすぐに終了できることです。あなたは持っていないすべてを検索。1つが悪い場合、グループ全体が悪いです。これは、他の多くの回答では見られない速度の考慮事項です。

十分に話して、コードを入手しましょう！

人気のある言語で読みやすいので、Javaでこれを行いました。再帰の優雅さは明らかです：

import java.util.ArrayList;

public class SortChecker {

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

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

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

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

記録のために、ソートされた12要素の配列を15分待ってから退屈して殺しました。約45秒で11個の要素を実行します。もちろん、ソートされていない場合は本当に早く終了するので、それはいいですね。

更新：再起動すると、13分で12個の要素が実行されます。13はほぼ3時間かかり、14は20時間でカウントされます。

— ジオビット
ソース
8
+1これはおそらく私が今まで見た中で最も効率の悪いアルゴリズムです。O（n！* 2 ^（n！））-Complexity（おそらくさらに悪い）の周りにあるはずです。
— ラルザレック14
6
私はもっ​​と悪くなったと思うが、それはかなり悪い。私は中途半端に複雑さを判断しようとしましたが、あきらめてそれを呼び出しましたO(big)。
— ジオビット14
1
巡回セールスマン問題の素朴な試みよりも効率の低いソリューションを提供することは印象的です！
— recursion.ninja 14年
3
12要素の配列がソートされる可能性は4億7900万分の1であるため、確かに1つが確実に確実になるまでに時間がかかることは問題ではありません。あなたが実際にありそうな現実の世界で1 ...見るために決してならない
— ジュール・
2
@Geobits問題ありません。ビクターのアルゴリズムを実行し、最初のプロンプトで「はい」と答えます。
— ジェイソンC
29

C ++-総当たり法

誰もがブルートフォースメソッドが常に最速であることを知っています。

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

実際のルーチンは長くなります（std :: nposに移動します）が、ここでの投稿では30000文字に制限されています。

— ミスター・リスター
ソース
私は本当にこれが好きです。
— ヤコブ14
3
これは、ケースステートメントに対する「バッファローのすべての部分を使用する」アプローチに似ています。
— ジョナサンヴァンマトレ14
これはすごい。すべてのループを展開します！
— マッケイ
素晴らしい考え!!!
— bikram990 14
26

通知する

Informは、古典的なInfocom Z-machineインタープリター用のインタラクティブなフィクションゲームを作成するための言語です。ネタバレを避けるために、最初にプログラムの結果を提供し、次にソースコードを提供します。

編集：配列に番号を追加できるように小さな修正を加え、魅力的な部屋の説明を含めました。

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

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

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

>open safe
You open the safe.

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

You put the flask of poison into the safe.

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

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

>get array
Taken.

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

You put the numeral 1 into the array.

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

You put the numeral 2 into the array.

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

You put the numeral 3 into the array.

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

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

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

>close safe
You close the safe.

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

そして、ここでソースコード：

"Sorted" by Jonathan Van Matre

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

ドージェ・ルビー

まず、このセットアップコードを実行する必要があります

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

そして、あなたの答えが印刷されます（trueまたはfalse）。

最適なパフォーマンスを得るためにdogeコードも追加してください：

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

これが最も簡単な方法です。

（ASCIIアートは、この画像から派生した、私が作成したスクリプトによって生成されました。）

— ドアノブ
ソース
7
「そうアルゴリズム」を忘れました。実際のdogeサンプルには、「wow」の前に3文があります。そして、はい、私はパーティーでとても楽しいです。
— ピエールアラード
@ArlaudPierreへー、大丈夫、修正：P
— ドアノブ
11
コメント、非常に改善、多くは有用です。ワオ。
— ピエールアラード
あなたはドージェのような形のアスキーでBFプログラムを書いたはずです...新しい質問のアイデア！
— TheDoctor
19

PHP

次のソリューションの簡単さと簡単さが気に入っています。このコーディングの傑作で使用されている全体的な概念と最先端の機能により、世界のトップ開発者のエリートリストにすぐにアクセスできます。

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

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

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

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

    mysql_query('DROP TABLE sorting_table');

    return $result;
}

print is_sorted(array(10, 20, 30, 40, 50));
— ビジョン
ソース
— Victor Stafusa 14
4
ロバーツ夫人が値を入力した場合、これは機能しますか？
— user80551 14
3
@ user80551はい、学生と呼ばれるテーブルがないため
— ラチェットフリーク14
3
@JonathanVanMatre確かに、セキュリティはこのコードの最も強力な側面の1つです。
— VisioN
1
これは、このWebサイトでの新しいお気に入りの回答です。しかし、余分なマークのために私はあなたがセキュリティのためにPDOを使う見てみたい
— alexandercannon
17

C＃-統計の力

これを解決するために本当に必要なのは、解決策を明確にする方法で質問を再構成することです。これは基本的に「true-false」タイプの質問であるため、基本的には「配列がソートされていることを100％確実に確認するにはどうすればよいですか」という質問です。その質問から1つの単語が出てきたら、それは「特定の」という単語です。確実性を測定する最良の方法は何ですか？統計情報。

ここでの他の回答は、配列が一方向にソートされているかどうかを確認するためだけにチェックします。このソリューションは、昇順と降順の両方を同時にテストします。トリックは、既に自分が簡単にソートできることがわかっているのと同じサイズの配列を取得し、各配列の順序が他の配列とどの程度相関しているかを調べることです。これを行う最も簡単な方法は、ケンドールタウランク相関係数を計算することです。

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）です。メソッド名に1つ、「for」キーワードごとに1つ、「double」宣言に1つ、変数「sortedness」の使用に2つあります。関数の名前を変更し、doubleを10進数に変更し、「sortedness」を「srtdnss」に分解し、forループをwhileループ。

— コミンテルン
ソース
2
私は苦労して複雑さを再計算し、O（8）であると判断しました。O（7）を本当に複雑にするために、「ソート済み」/「未ソート」の代わりに「昇順」/「無計画」を返すことを検討するかもしれません。
— ジオビット14年
@Geobits-もう一度調べましたが、もちろん正しいです。これは、文字列を返すときにO（1）の最小の複雑さがあることを示していると思います。ただし、ブール値を返すのは2倍悪いため、これはわずかな代償です。
— コミンテルン14年
1
O（）計算の場合は+1。-1は、スピアマンローも計算しないため、2つの相関関係は1つよりも優れていないためですか？そして、統計学者の定評のあるお気に入りであるC＃の統計については+1。
— ジョナサンヴァンマトレ14
教えてくださいO(7)ことは冗談です
— mbatchkarov
@mbatchkarov-ちょっとした表記です。:-)
— コミンテルン
16

ルビー

次の戦略により、配列がソートされているかどうかが明らかになります。

  1. Aは配列（たとえば、[1,2,3]または[1,3,2]などの並べ替え済みまたは未並べ替え）
  2. PはAのすべての順列を保持する配列です
  3. Aがソートされている場合、それはPの最大または最小のいずれかです（これは基本的にRuby の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です。オンラインバージョンで遊ぶ場合、最大値は[100,9,1]およびminです。は[1,9,100]です。何が「数字で表されている」のかわかりません。配列が辞書順に並べられているように見えます。これは、すべての数字が1桁である場合、同じだと思います。
— ジョシュアテイラー14
「...最大または最小...」
— ミクロ
@JoshuaTaylor：ヘッズアップをありがとう！私が理解しやすい方法でそれを説明したかった-平野間違ったことになった;）私は私の記述を修正...
— デヴィッド・ハーマン
2
@JoshuaTaylor ruby​​メソッドArray＃maxおよび#minは、<および>演算子に関して最大​​要素と最小要素を選択します。配列では、<および>は辞書式ソートを実装します。[1,9,100]は、辞書式順序での1、9、および100のすべての順序順列の最小値です。
— カールダンガードアスムッセン14
それはほぼ生産品質です。
— プリモ14
12

C＃-非決定的ソリューション

このコードはおそらく機能します。

static bool isSorted(int[] s)
{
    var rnd = new Random();
    for (var i = 0; i < s.Length * s.Length * s.Length; i++)
    {
        var i1 = rnd.Next(0, s.Length);
        var i2 = rnd.Next(0, s.Length);
        if (i1 < i2 && s[i1] > s[i2] || i1 > i2 && s[i1] < s[i2])
            return false; // definitely not sorted
    }
    return true; // probably sorted
}
— フェジェスコ
ソース
8
反復回数を-n ^ 2 * ln（1-p）に設定すると、確率pですべての組み合わせがチェックされることを保証できます！
— ハネシュ14
また、pのどの値が、このソリューションが「ワーキングコードがトローリング」として受け入れられるために有効ですか？:)
— fejesjoco 14
2
stackoverflow.com/questions/2580933起因宇宙線との比較の誤算の可能性は0.0000018（1.8E-6）毎秒であろう。したがって、1）反復にかかる時間を把握できる、2）@Hanneshの式を使用して確率を計算し、方程式系を解いて、解と区別できない反復回数を見つけることができます標準のisSortedメソッド。
— Xantix 14
11

Python

リストがソートされている場合、すべての数値は次の数値以下です。したがって、左端の数値を削除すると、平均値が上がります。それ以外の場合、リストはソートされません。これをループに入れて各番号をチェックします

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

— 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して、lsの結果を元の配列と比較します。

私はbashがあまり得意ではありません、試してみたいだけです:)

— ザック・タッカー
ソース
いいですね、これはディレクトリ "./nums"が既に存在することを前提としています。多分「mkdir -p nums」でしょうか？
— camelthemammel 14
ああ、ええ理にかなって：P
— ザックタッカー
8

C＃

「小さい」または「大きい」という概念は、2013年に非常に多くなります。実際のプログラマーはmodulo演算子のみを使用します！

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

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

private static bool IsSorted(List<int> list)
{
    for(int i = 0; i % list.Count != list.Count() - 1; i++)
    {
        if (list[i] % list[i + 1] != list[i] &&
            list[i] != list[i + 1])
        {
            return false;
        }
    }
    return true;
}
— ピエール・リュック・ピノー
ソース
同じ番号が2回表示されたらどうなりますか？次いで、リスト[i]は％リスト[I + 1] == 0
— サイモン
@Simon Oh ho！実際、2つの同一の数字がソートされていると思います。このエッジケースの比較を追加しました。素敵な発見。
— ピエールリュックピノー
5
{0、-1、2}がソートされたリストであることを知って喜んでいます。
— ピエールアラード
9
@ArlaudPierreあなたが本当の2014年のプログラマになりたいのなら、あなたはネガティブなものをすべて脇に置かなければなりません。世界はポジティブであり、世界は絶対的であり、世界はモジュロです！
— ピエールリュックピノー14
1
「より大きい」と「より小さい」という概念が好きではないので、これらの小なり記号と大なり記号を含める必要があったのは残念です。リストではなく配列を使用する必要があります。
— ミスターリスター14年
8

スカラ

配列がソートされているかどうかを確認するのは簡単です！最初の要素が2番目の要素より小さいかどうかを確認してください。次に、残りを並べ替えて、それらが等しいかどうかを確認します。

残念ながら、ソートは難しい問題です。配列をソートするための有名なアルゴリズムや効率的なアルゴリズムは多くありません。実際、それはコンピューターサイエンスの知識の現状では巨大な盲点です。そこで、単純なアルゴリズムを提案します。配列をシャッフルし、並べ替えられているかどうかを確認します。既に述べたように、これは簡単です。並べ替えるまでシャッフルし続けます。

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

私はこれが「true、false、true」を出力すると仮定します。しばらく実行されています...

— ジョー・K
ソース
8

整数のソートされた配列には、すべてのサブ配列（配列の要素nからmなど）も整数のソートされた配列であるという特性があります。これは明らかに、最良の方法は再帰関数であることを意味します。

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

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

これは最速の方法ではないかもしれませんが、それでもリストが順序付けられているかどうかの非常に正確なテストです。また、このコードはFUNCTIONALパラダイムを使用しているため、状態の変化や反復ループの恐怖から解放されているため、このコードを非常に読みやすく、理解しやすくなっています。

これがあなたにとって有益な情報になることを願っています。

— アレン
ソース
6

C＃-最長増加サブシーケンス

ソートされた配列の場合、最も長く増加するサブシーケンスの長さは配列の長さに等しくなります。ここからアルゴリズムをコピーしましたが、増加ではなく非減少に変更しただけです。

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

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

    l[0] = 1;

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

    for (int i = 1; i < s.Length; i++)
    {
        l[i] = 1;
        for (int j = 0; j < i; j++)
        {
            if (s[j] <= s[i] && l[j] + 1 > l[i])
            {
                l[i] = l[j] + 1;
                p[i] = j;
                if (l[i] > max)
                    max = l[i];
            }
        }
    }
    return max;
}
— フェジェスコ
ソース
6

Stonescript（c）LMSingh-0マイナス（4102回文）。

以下は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.

=-=-=-=-=-=
すべてのコード探索およびパワーデバッガーのために、上記の手順4の2番目のバリエーションに意図的にバグを追加しました。見つけられますか？

— LMSingh
ソース
3
すべての-私は、バグが発見4.3.*する必要があります4.2.*
— Timtech
4

Javascript

これが、「創造性」に衝撃を与えた理由です。

  • ソートされた配列のため

    * 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

  • したがって、すべての要素に対してメインループを実行し、メインループ内で2つのネストされたループを実行して、上記の2つの条件を確認します（左側に1つ、右側に1つ）

だから、私は説明したアルゴリズムのjavascript実装を提供します：

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で、2番目はa + 1から長さであると想定されていました。ところで、1、2、3はソートする必要がありますよね？
— ミクロ
@microbian OK、編集。
— ビクターStafusa 14
4

C

以下、「ソート済み」とは「昇順でソート済み」を意味します。

配列は、iffでソートされていません a[i]>a[i+1]

私たちは聞かせてあればx=a[i]-a[i+1]、x配列はソートされていない場合に限っ正となります。

x正であることをテストするために、2つの部分に分けることができます。x負でxはなく、ゼロではありません

xが負かどうかの簡単なテストは、x*xがに等しいかどうかをテストすることx*abs(x)です。xが負の場合、この条件はfalseになります(-1)*(-1)==1。

ゼロをテストするには、別の簡単なテストを使用できます：0./(float)xis Not a Number iff xis zero。

コード全体は次のとおりです（配列に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̷̰̀ĥ̷̳ 14
不要な処理を行うことは、コードトローリングのポイントです。（そして問題があるとはどういう意味ですか？）
— ace_HongKongIndependence 14
1
符号付き整数オーバーフローはUBです。ラップアラウンドの動作を定義しても、INT_MAX-INT_MINを実行すると、結果は負の数になります（a [i]をINT_MAXに、a [i + 1]をINT_MINに置き換えます）。
— n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ 14
それは宿題の問題に過ぎないため、教師がそれほど多くの極端な数を与えないと仮定しましょう。
— ace_HongKongIndependence
OK。ただ、トロール+悪であることを好みます。
— 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;
}

これは御treat走ではありませんか？

— n0la
ソース
4

C

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

確率1-（1 / n！）および複雑度O（1）で動作します。明らかに、非常に大きなランダム配列に最適な方法です。

複雑さはO（1）のみであるため、より良い推定のために2回実行します。

— cpri
ソース
3

C

この関数は、配列がソートされているかどうかを伝えるだけではありません。適切な場所にある要素の数を示します。任意のタイプのデータに使用できます。

コードをわかりやすくするために、説明的な変数名を使用することの重要性に注意してください。一方、変数iを宣言する必要はありません。変数iはプログラム内の別の場所で宣言される必要があるためです。

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

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

  return number_of_elements_in_right_place;
}

編集：これは、より大きな配列に適した方法です。これの利点は、人間がチェックする方法に似ていることです。

int sortcheck(array_to_be_checked[32767])
{
  i=rand(); j=rand();
  while( (array_to_be_checked[i] > array_to_be_checked[j]) = (i > j) ) 
  {
    printf("I think it's sorted");
    i=rand(); j=rand();
  };
  printf("It wasn't sorted");
}
— レベルリバーストリート
ソース
1
「変数iを宣言する必要はありません。変数iはプログラム内のどこかで宣言する必要があるためです。」笑う価値がありました。
— ジョナサンヴァンマトレ14
@JonathanVanMatreありがとうございます。しかし、このコードの唯一の問題は決してありません。
— レベルリバーセント14
3

JavaScript +その他の統計

@Comintermによって提案されたソリューションがとても気に入りました。しかし、すでにソートされたリストと比較して？それはずるい！

代わりに、配列の自己相関を計算します（配列と配列を左に1ポジションシフトした相関）。その後、配列を何度もシャッフルし、そのたびに新しい自己相関を元の自己相関と比較します。配列がソートされている場合、ほとんどの場合、元の自己相関が最高になります！

http://jsfiddle.net/dB8HB/

ボーナス：p値<0.05の場合、出力により、配列がソートされていると主張するタスクが自動化されます。これ以上何を要求できますか？

ボーナス2：この実装では便宜上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>
— ファビオ・ベルトラミニ
ソース
3

JavaScript / SVG-sunDialsort

このソリューションでは、<、<=、>または> =コンパレーターは使用しません。できる限りソート関数のように読まないようにしました。

方法

  • 値を円弧に沿って点としてプロットします。
  • 昇順配列の場合、各値は図面の幅全体を広くし、開始Xを減少させません（例外：2つの同一の値）。
  • 幅は縮小できないため、！=で十分です。
  • Xは増加できないため、==で十分です。
  • 2つの同一の値を修正するために、各ドットは実際には長さが増加する線です。単位の長さが1 /値の数より小さい場合。

トローリング

この非常に悪いコードを読む過程で、次のフェイスパームを追加しました。

  • 関数は、sunDialsortという名前の配列をソートするように見える場合があります（不正な大文字使用）
  • すべての変数名にlit-geekリファレンスを使用
  • 正規表現ハンマーを使用して、配列内の要素の数をカウントしました
  • 警告ボックスを使用した
  • 2つの連続した変数が同じであるエッジケースの解決策は、コードの量を2倍にしました（1つのライナーがそれをソートできた可能性があります）。
  • 最小値と最大値を見つけるのではなく、最も長い数字を見つけて次の10の累乗に切り上げます。これにより、人々が香りを消してくれることを願っています。

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

C

バイナリ検索はソートされた配列でのみ機能するため、配列がソートされているかどうかを確認するには、配列のすべての要素に対してバイナリ検索が機能することを確認するだけです。要素が見つからない場合、配列がソートされていないことがわかります。

渡されるコマンドライン引数はすべて、先行ゼロなしの10進整数でなければなりません。

#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
ソース
2

C

  • 配列のコピーを作成します
  • コピーを降順に並べ替える
  • この配列が指定された配列の逆であるかどうかを確認します
    #include<stdio.h>
    #include<stdlib.h>
    #include <stddef.h>
    #include<string.h>
    int main(){
     int arr[100],i,j,temp;
     int a[] = {1,2,3,4,5,6,7,8,9,10};
     char b[256];

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

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

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

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

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


     }
— Mhmd
ソース
2

Mathematica

このアルゴリズムは機能しているようですが、少し遅いです。より迅速なソート方法があるかもしれませんが、私はそれらを見つけていません。

  1. リストのランダムな順序を取り、リストが正しいかどうかを確認します（ OrderedQ）。
  2. ある場合は、停止します。それ以外の場合は、手順1を繰り返します。

次のコードは、わずか18秒でリストをソートしました。 

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

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

— DavidC
ソース
タスクは、入力が既にソートされているかどうかを確認することでした。
— イルマリカロネン14
これは私のソリューションの背後にある本質的なアイデアです（ただし、OrderedQファンシーのためだけに2次時間を使用します）。最後に追加されたチェックを使用します。
— ブースビー14
2

JavaScript

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

    var obj = {};
    var i;

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

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

    return true;
}

この関数はfalse正しく返されますが、最新のブラウザでは返されません。これを確認し、必要に応じて（質問で説明されているように）より遅いフォールバックを提供できます。

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

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

彼らは、これが負の数で予測不可能な結果を​​もたらすと言いますが、それは本当にあなたが物事を予測するのがどれだけ上手かということです。

— Ry-
ソース
2
Chromeがオブジェクトのプロパティをシャッフルして、人々がこのようなことをできないようにしたいのですが…
— Bergi
2

Java（レーベンシュタイン距離）

この実装では、元の配列を複製し、複製されたインスタンスをソートします。次に、レーベンシュタイン距離が計算されます。ゼロの場合、元の配列がソートされました。

注：getLevenshteinDistance（）実装はJakarta Commons Langから取得され、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
ソース
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.