Kreative Methoden, um festzustellen, ob ein Array sortiert ist

51

Schreiben Sie bei einem gegebenen Integer-Array ein Programm, das feststellt, ob es in aufsteigender Reihenfolge sortiert ist.

Denken Sie daran, dass dies eine Code-Trolling-Frage ist.

Ich suche nach den interessantesten Wegen, die sich die Leute einfallen lassen.

Die Antwort mit den meisten positiven Stimmen gewinnt.

Diese Frage ist inspiriert von einer "kreativen" Lösung, die mir ein Kandidat in einem Interview gegeben hat :)

Die "kreative" Lösung war ungefähr so:

  • Denn für ein sortiertes Array

    • Alle Elemente auf der linken Seite eines Elements müssen kleiner sein
    • Alle Elemente auf der rechten Seite eines Elements müssen größer sein

Führen Sie daher eine Hauptschleife für alle Elemente aus und überprüfen Sie die beiden obigen Bedingungen, indem Sie zwei verschachtelte Schleifen innerhalb der Hauptschleife ausführen (eine für die linke und eine für die rechte Seite).

Ich war schockiert!!.

popularity-contest  code-trolling 
— mikrobisch
quelle
58
Dies ist kein Duplikat. Einige Moderatoren halten es für notwendig, jede Frage doppelt zu markieren, ohne sie zu lesen. Dies ist überhaupt keine sortierende Frage. Lies es.
— Microbian
3
Am Ende des Wettbewerbs möchte ich auch die "kreative" Lösung kennenlernen! :)
— Vereos
16
@micro Diamond-Moderatoren werden von der Community gewählt. Sie verwechseln Moderatoren mit dem Berechtigungssystem.
— Türknauf
3
@microbian Also hast du diesen Kerl engagiert?
— VisioN
3
Wenn nur die StackExchange-API Schreibzugriff zulässt, stelle ich die Frage "Ist dieses Array sortiert?" und zähle die positiven / negativen Bewertungen nach oben.
— Michael Foukarakis

Antworten:

77

Rubin

Jeder weiß: Das Sortieren ist sehr langsam und dauert viele Zyklen (das Beste, was Sie tun können, ist etwas mit n log(n)). Somit ist es ziemlich einfach zu überprüfen, ob das Array sortiert ist. Sie müssen lediglich die Laufzeit des Sortierens des Arrays und des Sortierens des sortierten Arrays vergleichen.

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
— Howard
quelle
19
Dies hängt jedoch vom Sortieralgorithmus ab. Merge-Sort oder Heap-Sort zeigen überhaupt keinen Unterschied, unabhängig davon, ob das Array bereits sortiert ist oder nicht.
— Niklas B.
4
@NiklasB. Ruby benutzt Quicksort . , Daß die diese Methode knifflig könnte und Fehlalarme geben , wenn die Eingabe - Array fast sortiert, oder, was wahrscheinlicher ist , falsch - negative Ergebnisse, wenn das Array wird sortiert (es wäre sehr unwahrscheinlich , treference <= trunfür jeden sortierten Fall nur aufgrund nondeterministic andere Sachen) . Theoretisch scheint es, als würden Sie für den sortierten Fall ungefähr 50% falsch negative Ergebnisse erhalten?
— Jason C
6
Interessantes Denken, aber nicht deterministisch. Es ist ungefähr so ​​gut, als könnte man zehn Liegestütze und dann zehn weitere Liegestütze machen und dann entscheiden, ob das erste Array sortiert wurde oder nicht, weil man beim zweiten Satz Liegestütze mehr geschwitzt hat. Haben wir vergessen, dass wir Code auf Multitasking-Computern ausführen? Auch bei sehr kleinen Arrays ist die Zeitscheibe einfach nicht genau genug. +1 für einen wilden Versuch!
— LMSingh
1
@NiklasB. Timsort (eine Variante von Mergesort) wird in linearer Zeit auf sortierten (und auch teilweise sortierten) Arrays ausgeführt.
— Bakuriu
3
@JasonC - es ist erwähnenswert, dass dies die obige Implementierung noch zweifelhafter macht: Es beruht nicht nur auf dem Wissen, dass der interne Sortieralgorithmus von Ruby eine schnelle Sortierung ist (die an sich undokumentiert ist und daher eine zweifelhafte Sache, auf die man sich verlassen muss), sondern auch auf der spezifischen Implementierung ist optimiert für den Fall von bereits sortierten Daten (was standardmäßig nicht quicksort ist: quicksort ist im Durchschnitt nur O (n log n) ... seine schlechteste Performance ist O (n ^ 2) und in einer naiven Implementierung das schlimmsten Fall wird tatsächlich auf bereits sortierte Daten zugegriffen).
— Jules
52

Javascript

array = prompt("Give the array");
while (true) {
    sorted = prompt("Is it sorted?");
    if (/yes|Yes/.test(sorted)) {
        alert("The array is sorted.");
        break;
    } else if (/no|No/.test(sorted)) {
        alert("The array is not sorted.");
        break;
    } else {
        alert("Dear user:\n\nPlease refer to the manual (RTFM) to observe how to use the system accordingly to the defined business rules.\nNow, try again.");
    }
}
— Victor Stafusa
quelle
55
-1 nicht genug JQuery.
— Pierre Arlaud
3
Ich hatte eine ähnliche Idee, die nach dem Array fragte, und dann eine nach der anderen Aufforderung "Ist das größer als das?" Und wenn alles wahr ist, dann ist das Array sortiert
— Zach Thacker
41

Java - Rekursive Teilmengen

Willkommen bei Stack Overflow! Dies ist eine ausgezeichnete erste Frage, da sie sogar einige erfahrene Programmierer überrumpelt. Lassen Sie mich ein paar Hintergrundinformationen geben, bevor ich den Code verteile:

Die Bestimmung der Sortierbarkeit kann auf den ersten Blick eine schwierige Aufgabe sein. Für jede Menge von Länge n gibt es n! mögliche Bestellmöglichkeiten. Diese werden Permutationen genannt . Wenn Ihr Array unterschiedliche Elemente enthält, wird nur eine dieser Möglichkeiten sortiert! Um die Sortierte zu finden, müssen Sie alle durchsehen, bis Sie die richtige (möglicherweise nur) gefunden haben, und alle anderen verwerfen.

Was? Sicher ist es nicht so schwer ...

Algorithmen mit n! Komplexität braucht viel Zeit für größere Eingaben, aber mit ein wenig Arbeit können wir das umgehen und eine ganze Größenordnung der Komplexität reduzieren. Das ist immer noch exponentielle Zeit, aber es ist viel besser als Fakultät.

Dazu müssen wir nur die folgenden mathematischen Fakten berücksichtigen: Wenn ein Array sortiert ist, wird auch jede seiner (relativ geordneten) Teilmengen sortiert. Sie können die Experten der Mathematik um einen formalen Beweis bitten , aber es ist intuitiv wahr. Zum Beispiel sind für die Menge 123die richtigen Teilmengen 1 2 3 12 13 23. Sie können sehen, dass sie alle bestellt sind. Nun, wenn das Original wäre 213, hätten Sie es 2 1 3 21 23 13, und sofort können Sie sehen, dass 21es nicht in Ordnung ist.

Der Grund, warum dies wichtig ist, ist, dass es weit weniger als n gibt! Teilmengen. In der Tat gibt es nur 2 n -2 Teilmengen, die wir betrachten müssen. Wir können die Menge, die das gesamte Array der ursprünglichen Zahlen enthält, sowie die leere Menge ausschließen.

Dennoch kann 2 n -2 eine Menge Arbeit sein. Wie bei den meisten Dingen, die die Polynomzeit überschreiten, funktioniert auch hier ein Divide-and-Conquer- Ansatz. Der einfachste Ansatz? Rekursion !

Die grundlegenden Schritte sind einfach. Für jede Teilmenge Ihrer Eingabe generieren Sie kleinere Teilmengen. Dann machst du für jeden das Gleiche. Sobald Ihre Teilmengen die Größe 2 erreicht haben, überprüfen Sie einfach, welche größer ist. Da Sie die Größe der Teilmengen jedes Mal verkleinern, geht es tatsächlich schneller als erwartet.

Die wichtigste Tatsache hierbei ist, dass Sie vorzeitig beenden können , sobald Sie feststellen, dass eine einzelne Teilmenge nicht in Ordnung ist. Sie müssen nicht alle durchsuchen. Wenn einer schlecht ist, ist die ganze Gruppe schlecht. Dies ist eine Überlegung zur Geschwindigkeit, die Sie in vielen dieser anderen Antworten nicht finden.

Genug geredet, lasst uns den Code haben!

Ich habe dies in Java gemacht, da es eine beliebte Sprache ist und leicht zu lesen ist. Die Eleganz der Rekursion sollte offensichtlich sein:

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

Für die Aufzeichnung, ich langweilte mich und tötete es, nachdem ich 15 Minuten auf ein sortiertes 12-Elemente-Array gewartet hatte. Es macht 11 Elemente in ungefähr 45 Sekunden. Natürlich ist es wirklich tut Ausfahrt früher für nicht sortiert, so dass die, äh, gut.

Update: Bei einem Neustart werden 12 Elemente in 13 Minuten ausgeführt. 13 dauert fast 3 Stunden, und 14 ist bei 20 Stunden und zählt.

— Geobits
quelle
8
+1 Dies ist wahrscheinlich der am wenigsten effiziente Algorithmus, den ich je gesehen habe. Sollte um O (n! * 2 ^ (n!)) Liegen - Komplexität (wahrscheinlich schlimmer).
— Ral Zarek
6
Ich bin sicher, ich habe Schlimmeres gesehen, aber es ist ziemlich schlimm. Ich versuchte halbherzig, die Komplexität zu bestimmen, gab es aber auf und nannte es O(big).
— Geobits
1
Es ist beeindruckend, eine Lösung anzubieten, die weniger effizient ist als der naive Versuch, das Problem des Handlungsreisenden zu lösen.
— recursion.ninja
3
Da die Wahrscheinlichkeit, dass ein 12-Elemente-Array sortiert wird, nur 1 zu 479 Millionen beträgt, spielt es keine Rolle, dass es eine Weile dauert, bis man sicher ist, dass dies der Fall ist. In der realen Welt werden Sie wahrscheinlich nie einen sehen ...
— Jules
2
@Geobits Kein Problem. Führen Sie Victors Algorithmus aus und antworten Sie bei der ersten Eingabeaufforderung mit "Ja".
— Jason C
29

C ++ - eine Brute-Force-Methode

Jeder weiß, dass Brute-Force-Methoden immer die schnellsten sind.

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

Die eigentliche Routine ist länger (es geht zu std :: npos), aber ich bin auf 30000 Zeichen beschränkt, wenn ich hier poste.

— Herr Lister
quelle
Das gefällt mir wirklich gut.
— Jakob
3
Dies ist wie der Ansatz "Nutze jeden Teil des Büffels" für case-Anweisungen.
— Jonathan Van Matre
Das ist fantastisch. Rollen Sie alle Schleifen ab!
— McKay
guter Gedanke!!!
— Bikram990
26

Informieren

Inform ist eine Sprache zum Schreiben interaktiver Fiction-Spiele für den klassischen Infocom Z-Machine-Interpreter. Um Spoiler zu vermeiden, gebe ich zuerst die Ergebnisse meines Programms und dann den Quellcode.

Bearbeiten: Ich habe eine kleine Überarbeitung vorgenommen, um das Hinzufügen von Zahlen zum Array zu ermöglichen, und eine charmante Zimmerbeschreibung hinzugefügt.

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

Und hiermit der Quellcode:

"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' ";
— Jonathan Van Matre
quelle
21

Doge Ruby

Zuerst müssen Sie diesen Setup-Code ausführen

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

Speichern Sie dann das Array in einer Variablen namens codingund führen Sie Folgendes aus:

  very coding

                 many ruby
so algorithm


      wow

Und Ihre Antwort wird gedruckt (richtig oder falsch).

Bitte geben Sie auch den Doge-Code ein, um eine optimale Leistung zu erzielen:

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

Dies ist der einfachste Weg.

(Die ASCII- Grafik wurde von einem Skript erstellt, das ich aus diesem Bild abgeleitet habe .)

— Türknauf
quelle
7
Sie haben "so algorithm" vergessen. Ein echtes Dogenmuster besteht aus 3 Sätzen vor "wow". Und ja, ich mache sehr viel Spaß auf Partys.
— Pierre Arlaud
@ArlaudPierre Heh, okay, behoben: P
— Türklinke
11
Also Kommentar, sehr Verbesserung, viele nützlich. Beeindruckend.
— Pierre Arlaud
Du hättest ein BF-Programm in ASCII-Form schreiben sollen ... neue Frageidee !!
— TheDoctor
19

PHP

Sie werden die Einfachheit und Unkompliziertheit der folgenden Lösung lieben. Das Gesamtkonzept und die innovativen Funktionen, die in diesem Meisterwerk der Codierung verwendet werden, bringen Sie sofort auf die Elite-Liste der Top-Entwickler der Welt.

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));
— Vision
quelle
+1 Weil Sie das gleiche Konzept meiner Antwort auf die Sortierfrage verwenden
— Victor Stafusa
4
Würde dies funktionieren, wenn Frau Roberts die Werte eingibt?
— User80551
3
@ user80551 ja, weil es keinen Tisch mit dem Namen students
— ratschenfreak gibt
3
@JonathanVanMatre Sicherheit ist zweifellos eine der stärksten Seiten dieses Codes.
— VisioN
1
Dies ist meine neue Lieblingsantwort auf dieser Website. aber für extra marken würde ich gerne sehen, dass du ein gU für sicherheit verwendest
— alexandercannon
17

Die Macht der Statistik

Was Sie wirklich tun müssen, um dies zu lösen, ist, die Frage so neu zu formulieren, dass die Lösung offensichtlich wird. Da es sich im Grunde genommen um eine Frage vom Typ "Wahr-Falsch" handelt, stellen Sie im Wesentlichen die Frage: "Wie kann ich 100% ig sicher sein, dass das Array sortiert ist?" Wenn ein Wort aus dieser Frage herausspringt, ist es das Wort "sicher". Wie lässt sich Gewissheit am besten messen? Sie haben es verstanden: Statistiken.

Bei anderen Antworten wird nur geprüft, ob das Array in eine Richtung sortiert ist . Diese Lösung testet gleichzeitig die aufsteigende und absteigende Reihenfolge. Der Trick besteht darin, ein Array derselben Größe zu nehmen, von der Sie bereits wissen, dass es sortiert ist (es ist einfach, eines selbst zu erstellen), und dann herauszufinden, wie gut die Reihenfolge der einzelnen Arrays mit der der anderen übereinstimmt. Die Berechnung des Kendall-Tau-Rang-Korrelationskoeffizienten ist der einfachste Weg, dies zu tun:

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

Ausgabe:

Unsorted
Sorted
Sorted

Diese Funktion ist auch sehr einfach zu erweitern, da es trivial wäre, Funktionen wie "Meistens sortiert" oder "Mehr sortiert als nicht" oder "Vollständig zufällig" hinzuzufügen.

Bearbeiten

Fast vergessen, über die Effizienz des Algorithmus zu gehen. Dies ist derzeit O (7). Es gibt einen im Methodennamen, einen in jedem der "for" -Schlüsselwörter, einen in der "double" -Deklaration und zwei in der Verwendung der Variablen "sortness". Sie können dies bis hinunter zu O (0) verbessern (was so niedrig wie möglich ist), indem Sie die Funktion umbenennen, das Doppel in eine Dezimalzahl ändern, die Sortierung in "srtdnss" aufheben und die for-Schleifen in "srtdnss" konvertieren while-Schleifen.

— Komintern
quelle
2
Ich habe die Komplexität sorgfältig neu berechnet und festgestellt, dass sie 0 ist (8). Sie schwenken die Ausgabe von Hand weg, was meines Erachtens berücksichtigt werden sollte. Um eine echte O (7) -Komplexität zu erzielen, sollten Sie erwägen, "aufsteigend" / "zufällig" anstelle von "sortiert" / "unsortiert" zurückzugeben.
— Geobits
@Geobits - Ich habe es mir noch einmal angesehen und natürlich hast du recht. Ich denke, dies zeigt, dass es eine minimale Komplexität von O (1) gibt, wenn die Zeichenfolgen zurückgegeben werden. Dies ist jedoch ein geringer Preis, da das Zurückgeben eines Booleschen doppelt so schlimm ist.
— Comintern
1
+1 für die O () Berechnung. -1, weil nicht auch ein Spearman-Rho berechnet wird, weil zwei Korrelationen nicht besser sind als eine? Und +1 für Statistiken in C #, dem bewährten Favoriten der Statistiker.
— Jonathan Van Matre
Bitte sagen Sie mir, dass das O(7)Ding ein Witz ist
— mbatchkarov
@mbatchkarov - Es ist kleine O-Notation. :-)
— Comintern
16

Rubin

Die folgende Strategie zeigt schließlich, ob ein Array sortiert ist:

  1. A sei ein Array (entweder sortiert oder unsortiert, zB [1,2,3] oder [1,3,2])
  2. P ist ein Array, das alle Permutationen von A enthält
  3. Wenn A sortiert ist, ist es entweder das Maximum oder das Minimum von P (was im Grunde genommen die sortierten Versionen von A in Ruby sind).

Online-Version zum Testen.

class Array
   def is_sorted?
      permutations = permutation.to_a
      self == permutations.max || self == permutations.min
   end
end
— David Herrmann
quelle
1
Ich glaube nicht, dass ich die Erklärung verstehe. Wenn das Array z. B. [1, 9, 100] ist, ist die min 10019 und die max 91100, aber die sortierte Nummer ist 19100. Bei der Online-Version ist die max [100,9,1] und die min ist [1,9,100]. Ich sehe nicht, wo etwas "durch eine Zahl dargestellt" wird. es sieht so aus, als würden die Arrays nur lexikografisch bestellt. Das wäre wohl dasselbe, wenn alle Zahlen nur eine Ziffer wären.
— Joshua Taylor
"... entweder das Maximum oder das Minimum ..." liebte es.
— Microbian
@ JoshuaTaylor: Danke für das Heads-up! Ich wollte es auf eine leicht verständliche Art und Weise erklären - was sich als klar falsch herausstellte;) Ich habe meine Beschreibung korrigiert ...
— David Herrmann
2
@JoshuaTaylor Die Ruby-Methoden Array # max und #min wählen das größte und kleinste Element in Bezug auf die Operatoren <und> aus. In Arrays <und> implementieren Sie die lexikografische Sortierung. [1,9,100] ist das Minimum aller geordneten Permutationen von 1, 9 und 100 in der lexikographischen Reihenfolge.
— Karl Damgaard Asmussen
Das ist fast Produktionsqualität.
— Primo
12

Nicht deterministische Lösung

Dieser Code funktioniert wahrscheinlich.

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
quelle
8
Wenn Sie die Anzahl der Iterationen auf -n ^ 2 * ln (1-p) setzen, können Sie mit einer Wahrscheinlichkeit von p sicherstellen, dass alle Kombinationen geprüft werden!
— Hannesh
Und welche Werte von p sind gültig, damit diese Lösung als "Arbeitscode aber Trolling" akzeptiert wird? :)
— fejesjoco
2
Von stackoverflow.com/questions/2580933 wäre die Chance einer Fehleinschätzung eines Vergleichs durch kosmische Strahlen 0,0000018 (1.8E-6) jede Sekunde. Also, wenn: 1) Sie herausfinden können, wie lange eine Iteration dauert, 2) wir @Hanneshs Formel verwenden können, um die Wahrscheinlichkeit zu berechnen, und dann das Gleichungssystem lösen, um die Anzahl der Iterationen zu finden, die Ihre Lösung von a nicht unterscheidbar machen Standard isSorted-Methode.
— Xantix
11

Python

Wenn die Liste sortiert ist, ist jede Nummer kleiner oder gleich der nächsten Nummer. Wenn Sie also die Zahl ganz links entfernen, wird der Durchschnittswert erhöht, andernfalls wird die Liste nicht sortiert. Wir werden dies in eine Schleife setzen, um jede Zahl zu überprüfen

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

Der aufmerksame Leser wird feststellen, dass es so nicht funktioniert.
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
quelle
9

Bash 

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

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

Berühren Sie eine Datei für jedes Element im Array, und vergleichen Sie das Ergebnis mit dem ursprünglichen Array.

Ich bin nicht sehr gut mit Bash, ich wollte es nur versuchen :)

— Zach Thacker
quelle
Nizza, dies setzt allerdings voraus, dass das Verzeichnis "./nums" bereits existiert. Vielleicht irgendwo eine "mkdir -p nums"?
— Kamelthemammel
Oh ja, das macht Sinn: P
— Zach Thacker
8

C #

Die Begriffe "kleiner" oder "größer" sind so viel 2013 . Echte Programmierer benutzen nur den moduloOperator!

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;
}
— Pierre-Luc Pineault
quelle
Was ist, wenn dieselbe Nummer zweimal vorkommt? Dann liste [i]% liste [i + 1] == 0.
— Simon
@ Simon Oh ho! In der Tat denke ich, dass zwei identische Nummern sortiert sind. Ein Vergleich für diesen Kantenfall wurde hinzugefügt. Schöner Fund.
— Pierre-Luc Pineault
5
Gut zu wissen, dass {0, -1, 2} eine sortierte Liste ist.
— Pierre Arlaud
9
@ArlaudPierre Wenn Sie ein echter Programmierer für 2014 sein wollen, müssen Sie alles Negative beiseite legen. Die Welt ist positiv, die Welt ist absolut, die Welt ist modulo!
— Pierre-Luc Pineault
1
Da Sie den Begriff "größer" und "kleiner" nicht mögen, ist es eine Schande, dass Sie diese Zeichen "kleiner als" und "größer als" einschließen mussten. Sie sollten Arrays anstelle von Listen verwenden.
— Mr Lister
8

Scala

Es ist einfach zu überprüfen, ob ein Array sortiert ist! Prüfen Sie einfach, ob das erste Element kleiner als das zweite ist. Sortieren Sie dann den Rest und prüfen Sie, ob sie gleich sind.

Leider ist das Sortieren ein schwieriges Problem. Es gibt nicht viele bekannte oder effiziente Algorithmen zum Sortieren eines Arrays. Tatsächlich ist es ein großer blinder Fleck im aktuellen Stand der Informatik. Also schlage ich einen einfachen Algorithmus vor: Mische das Array und überprüfe dann, ob es sortiert ist, was, wie bereits erwähnt, einfach ist! Mische weiter, bis es sortiert ist.

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

Ich gehe davon aus, dass dies "wahr, falsch, wahr" ist. Es läuft schon eine Weile ...

— Joe K
quelle
8

Ein sortiertes Array von Ganzzahlen hat die Eigenschaft, dass jedes Unterarray (z. B. Elemente n bis m des Arrays) auch ein sortiertes Array von Ganzzahlen ist. Dies impliziert offensichtlich, dass die beste Methode eine RECURSIVE-Funktion ist:

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

Es ist vielleicht nicht die schnellste Methode, aber es ist trotzdem ein SEHR GENAUER Test, ob eine Liste bestellt ist oder nicht. Es ist auch unglaublich einfach, diesen Code zu lesen und zu verstehen, da er ein FUNKTIONALES Paradigma verwendet und daher frei von den Schrecken von Zustandsänderungen und iterativen Schleifen ist.

Ich hoffe, dies sind nützliche Informationen für Sie.

— Allen
quelle
6

C # - am längsten zunehmende Folge

Bei einem sortierten Array ist die Länge der am längsten zunehmenden Teilsequenz gleich der Länge des Arrays. Ich habe den Algorithmus von hier kopiert und nur so modifiziert, dass er nicht abnimmt, sondern zunimmt.

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

Stonescript (c) LMSingh - 0 minus (4102 palindromed).

Das Folgende ist in Stonescript (c) geschrieben, einer Sprache, die vor Jahrhunderten von mir urheberrechtlich geschützt und verwendet wurde, dh in alten Zeiten vor den Midgetframes. HINWEIS: Es ist ein Vorläufer des Sanskrit.

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

Beispiel eines Arrays mit 8 Elementen. In absteigender Reihenfolge sortiert :-) 

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

- Code fortgesetzt.

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.

Beispiel eines Arrays mit 8 Elementen. Nicht sortiert :-( 

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

- Code fortgesetzt.

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

= - = - = - = - = - =
Bei weiterer Optimierung können die Stanzblätter von Schritt 4 durch die folgenden Stanzblätter ersetzt werden.
= - = - = - = - = - = 

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.

= - = - = - = - = - =
Für alle Code-Ermittler und Power-Debugger habe ich in der obigen zweiten Variante von Schritt 4 absichtlich einen Fehler hinzugefügt. Können Sie ihn finden?

— LMSingh
quelle
3
Ich fand den Bug - alles 4.3.*sollte sein4.2.*
— Timtech
4

Javascript

Das ist es, was dich über die "Kreativität" schockiert hat:

  • Denn für ein sortiertes Array

    * 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

  • Führen Sie daher eine Hauptschleife für alle Elemente aus und überprüfen Sie die beiden obigen Bedingungen, indem Sie zwei verschachtelte Schleifen innerhalb der Hauptschleife ausführen (eine für die linke und eine für die rechte Seite).

Also, ich gebe eine Javascript-Implementierung des beschriebenen Algorithmus:

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

Lass es uns testen:

checkArraySorted([]);
> true

checkArraySorted([1]);
> true

checkArraySorted([1, 2]);
> true

checkArraySorted([2, 1]);
> false

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

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

Scheint perfekt zu funktionieren! Es hat eine Komplexität von O(n²), ideal für einen Algorithmus, der sein sollte O(n), aber dadurch O(n²)wird es effizienter, da dies ein Maß für die Effizienz ist, also O(n²)effizienter als O(n).

— Victor Stafusa
quelle
Ich wollte keine "Mitte" verwenden. Die erste verschachtelte Schleife war von 0 bis a, und die zweite sollte von + 1 bis Länge sein. Übrigens, 1,2,3 sollten sortiert werden, nicht wahr?
— Mikrobier
@microbian Ok, bearbeitet.
— Victor Stafusa
4

C

Nachstehend bedeutet "sortiert" "in aufsteigender Reihenfolge sortiert".

Ein Array ist nicht iff sortiert a[i]>a[i+1]

Wenn wir also zulassen x=a[i]-a[i+1], xist dies positiv, wenn das Array nicht sortiert ist.

Um zu testen x, ob es positiv ist, können wir es in zwei Teile zerlegen: xist nicht negativ und xist nicht null

Ein einfacher Test, ob xnegativ ist, besteht darin, dass wir testen, ob x*xgleich ist x*abs(x). Diese Bedingung sollte falsch sein, wenn sie xnegativ ist (-1)*(-1)==1.

Um auf Null zu testen, können wir einen anderen einfachen Test verwenden: 0./(float)xis Not a Number iff xis zero.

Also hier ist der gesamte Code: (setzt voraus, dass das Array 5 Elemente hat)

#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
quelle
Das Testen auf a[i]-a[i+1] > 0ist eigentlich schon problematisch. Sie müssen nicht all diese Dinge tun.
— n̴̖̋h̷͉̃a̷̭̿h̷̭̿d̷̰̀ĥ̷̳
Unnötiges Zeug zu tun ist der springende Punkt beim Code-Trolling, nicht wahr? (Und was meinst du mit problematisch?)
— ace_HongKongIndependence
1
Der vorzeichenbehaftete Ganzzahlüberlauf ist UB. Selbst wenn wir das Umlaufverhalten definieren, ist das Ergebnis bei INT_MAX - INT_MIN eine negative Zahl (ersetzen Sie ein [i] durch INT_MAX und ein [i + 1] durch INT_MIN).
— n̴̖̋h̷͉̃a̷̭̿h̷̭̿d̷̰̀ĥ̷̳
Da es sich nur um ein Hausaufgabenproblem handelt, nehmen wir an, dass der Lehrer nicht so viele extreme Zahlen gibt.
— ace_HongKongIndependence
OKAY. Nur dass ich lieber trolle + böse bin.
— n̴̖̋h̴̖̋a̷̭̿h̷̭̿d̷̰̀ĥ̷̳
4

Es geht darum, wie sicher Sie sein möchten. Da keine Gewissheit gegeben wurde, ist das Folgende in Bezug auf die Leistung tatsächlich recht gut. Der folgende Code gibt eine gute Vorstellung, aber wenn Sie sicher sind, sollten Sie die Funktion ein paar Mal wiederholen. Wenn Sie wirklich sicher sein möchten, sollten Sie es in einer Schleife ausführen und ein Dutzend Mal ausführen. Perfekte Skalierbarkeit!

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

Ist das nicht ein Vergnügen?

— n0la
quelle
4

C

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

Funktioniert mit Wahrscheinlichkeit 1- (1 / n!) Und Komplexität O (1). Offensichtlich die beste Methode für sehr große zufällige Arrays.

Da die Komplexität nur O (1) ist, sollten Sie zur besseren Abschätzung zweimal ausführen.

— cpri
quelle
3

C

Diese Funktion sagt nicht nur, ob das Array sortiert ist. Hier erfahren Sie, wie viele Elemente sich am richtigen Ort befinden. Es kann für jede Art von Daten verwendet werden.

Beachten Sie, wie wichtig es ist, beschreibende Variablennamen zu verwenden, damit der Code einfach zu befolgen ist. Auf der anderen Seite müssen wir die Variable i nicht deklarieren, da sie an einer anderen Stelle im Programm deklariert werden muss.

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

Bearbeiten: Dies ist eine bessere Möglichkeit für größere Arrays. Dies hat den Vorteil, dass es der Art und Weise ähnlich ist, wie ein Mensch dies überprüfen würde.

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");
}
— Level River St
quelle
1
"Wir müssen die Variable i nicht deklarieren, da sie an einer anderen Stelle im Programm deklariert werden muss." war ein Lachen wert.
— Jonathan Van Matre
@JonathanVanMatre Danke, aber es ist keineswegs das Einzige, was an diesem Code falsch ist.
— Level River St
3

JavaScript + mehr Statistiken

Die von @Cominterm vorgeschlagene Lösung hat mir sehr gut gefallen. Aber mit einer bereits sortierten Liste vergleichen? Das ist Betrug!

Stattdessen berechne ich die Autokorrelation des Arrays (Korrelation zwischen dem Array und dem um eine Position nach links verschobenen Array). Dann mische ich das Array viele Male und vergleiche jedes Mal die neue Autokorrelation mit der ursprünglichen Autokorrelation. Wenn das Array sortiert wäre, wäre die ursprüngliche Autokorrelation die meiste Zeit am höchsten!

http://jsfiddle.net/dB8HB/

Bonus: Wenn Ihr p-Wert <0,05 ist, automatisiert die Ausgabe die Behauptung, dass das Array für Sie sortiert ist. Was könnte man mehr verlangen?

Bonus2: Obwohl diese Implementierung aus Bequemlichkeitsgründen die O (n) -Array-Funktionen von JavaScript verwendet, könnte der Ansatz Sampling verwenden, um in konstanter Zeit ausgeführt zu werden!

<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>
— Fabio Beltramini
quelle
3

JavaScript / SVG - sunDialsort

Diese Lösung verwendet nicht die Komparatoren <, <=,> oder> =. Ich habe versucht, es so wenig wie möglich wie eine Sortierfunktion zu lesen.

Methode

  • Zeichnen Sie die Werte als Punkte entlang eines Bogens.
  • Bei einem aufsteigenden Array wird durch jeden Wert die Gesamtbreite der Zeichnung vergrößert und das Start-X nicht verkleinert (Ausnahme: zwei identische Werte).
  • Da die Breite nicht schrumpfen kann, reicht ein! = Aus,
  • Da X nicht erhöhen kann, genügt ein ==.
  • Um zwei identische Werte zu bestimmen, ist jeder Punkt eine Linie mit zunehmender Länge. Wobei die Einheitslänge weniger als 1 / Anzahl der Werte ist.

Trolling

Ich habe die folgenden Gesichtspalmen während des Lesens dieses sehr schlechten Codes hinzugefügt.

  • Die Funktion kann so aussehen, als würde sie das Array sortieren und als sunDialsort (Bonus mit falscher Groß- / Kleinschreibung) bezeichnen.
  • Verwendete Lit-Geek Referenz für alle Variablennamen
  • zählte mit dem Regex-Hammer die Anzahl der Elemente im Array
  • eine Alarmbox verwendet
  • Die Lösung für den Edge-Fall, bei dem zwei aufeinanderfolgende Variablen gleich sind, verdoppelte die Menge des Codes (ein Einzeiler hätte ihn sortieren können). Setzen Sie diesen Code frühzeitig ein, um den Zweck der Funktion zu verwechseln.
  • Anstatt das Minimum und das Maximum zu finden, ermitteln Sie die längste Zahl und runden Sie auf die nächste Zehnerpotenz auf.

xml

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

Funktion

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

Wenn jemand testen möchte, gibt es hier eine Version mit lesbaren Variablennamen. http://jsfiddle.net/outRideACrisis/r8Awy/

— OutRideACrisis
quelle
3

C

Da eine binäre Suche nur für sortierte Arrays funktioniert, müssen wir nur überprüfen, ob eine binäre Suche für alle Elemente des Arrays funktioniert, um zu überprüfen, ob ein Array sortiert ist. Wenn es kein Element findet, wissen wir, dass das Array nicht sortiert ist.

Die übergebenen Befehlszeilenargumente müssen alle Dezimalzahlen ohne führende Nullen sein.

#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
quelle
3

Javascript

a = prompt("Please enter the data");
r = prompt("Does your array arouse moral distaste and contempt?");
if ((/yes/i).test(r))
  alert("The array is sordid.");
— Jason C
quelle
1
{ 69 , 313 , 187 , 31338 }
— Geobits
2

C

  • Erstellen Sie eine Kopie des Arrays
  • sortieren Sie die Kopie in absteigender Reihenfolge
  • Überprüfen Sie, ob dieses Array das Gegenteil des angegebenen Arrays ist
    #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
quelle
2

Mathematica

Dieser Algorithmus scheint zu funktionieren, ist aber etwas langsam. Möglicherweise gibt es schnellere Sortiermöglichkeiten, aber ich habe sie nicht gefunden.

  1. Nimm eine zufällige Reihenfolge der Liste und überprüfe, ob sie in Ordnung ist (mit OrderedQ).
  2. Wenn ja, hör auf. Andernfalls wiederholen Sie Schritt 1.

Der folgende Code hat die Liste in etwas mehr als 18 Sekunden sortiert. 

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
quelle
Die Aufgabe bestand darin, zu überprüfen, ob die Eingabe bereits sortiert ist.
— Ilmari Karonen
Dies ist die Grundidee für meine Lösung (ich verwende jedoch eine quadratische Zeit OrderedQnur zum Spaß) mit dem zusätzlichen Häkchen am Ende "Jetzt, da wir eine sortierte haben, ist es das, womit wir begonnen haben?"
— Stand
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;
}

Diese Funktion wird möglicherweise falsefalsch zurückgegeben, jedoch nicht in modernen Browsern. Sie können dies überprüfen und bei Bedarf einen langsameren Fallback bereitstellen (wie in der Frage beschrieben):

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

Sie sagen, dies ergibt unvorhersehbare Ergebnisse bei negativen Zahlen, aber es hängt wirklich davon ab, wie gut Sie Dinge vorhersagen können.

— Ry-
quelle
2
Ich wünschte, Chrome würde Objekteigenschaften mischen, um zu verhindern, dass
— Benutzer
2

Java (Levenshtein Entfernung)

In dieser Implementierung klone ich das ursprüngliche Array und sortiere die geklonte Instanz. Dann wird die Levenshtein-Entfernung berechnet. Wenn es Null ist, wurde das ursprüngliche Array sortiert.

Hinweis: Die getLevenshteinDistance () -Implementierung stammt von Jakarta Commons Lang und wurde so geändert, dass sie auf int [] anstelle von CharSequence funktioniert.

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
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.