"Креативні" способи визначення сортування масиву

51

Задавши цілий масив, напишіть програму, яка визначає, чи сортується вона у порядку зростання.

Пам'ятайте, що це питання тролінгу коду.

Я шукаю найцікавіші способи, які люди придумують.

Відповідь з більшістю результатів виграє.

Це питання натхнене "креативним" рішенням, яке мені дав кандидат в інтерв'ю :)

«Креативне» рішення було приблизно таким:

  • Тому що для відсортованого масиву

    • всі елементи з лівого боку будь-якого елемента повинні бути меншими
    • всі елементи праворуч будь-якого елемента повинні бути більшими

Тому запустіть основний цикл для всіх елементів і перевірте вищевказані два умови, виконавши дві вкладені петлі всередині основної (одну для лівої та однієї для правої сторони)

Я був шокований!!.

popularity-contest  code-trolling 
— мікробій
джерело
58
Це не дублікат. Деякі модератори вважають за потрібне позначити кожне запитання дублікатом для інших, не читаючи його. Це взагалі не питання сортування. Читати.
— мікробій
3
Наприкінці конкурсу я також хотів би знати «креативне» рішення! :)
— Вереос
16
Модератори @micro Diamond обираються громадою. Ви плутаєте модераторів із системою пільг.
— Дверна ручка
3
@microbian Отже, ти найняв цього хлопця?
— VisioN
3
Якщо тільки API StackExchange дозволяв доступ для запису, я б задав питання "Чи сортується цей масив?" і порахуйте відгуки на позитивні / негативні відповіді ..
— Michael Foukarakis

Відповіді:

77

Рубін

Всім відомо: сортування відбувається дуже повільно і займає багато циклів (найкраще, що можна зробити, - це щось із цим n log(n)). Таким чином, досить легко перевірити, чи сортується масив. Все, що вам потрібно зробити, - порівняти час виконання сортування масиву та сортування відсортованого масиву.

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

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

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

## compare run times
if trun > treference
  print "array was not sorted"
else
  print "array was sorted"
end
— Говард
джерело
19
Однак це залежить від алгоритму сортування. Сортувати сортування або сортувати групу взагалі не показало б різниці, незалежно від того, масив вже відсортований чи ні.
— Ніклас Б.
4
@NiklasB. Рубі використовує квакірт . Тим НЕ менше , цей метод може отримати складний , і дає помилкові спрацьовування , коли масив введення майже відсортований, або, що більш імовірно, помилкові негативи , коли масив буде відсортований (це було б дуже малоймовірні treference <= trunдля кожного відсортованого випадку, просто з - за недетерміновані інші речі) . Теоретично здається, ви отримаєте приблизно 50% помилкових негативів для відсортованого випадку?
— Джейсон C
6
Цікава думка, але не детермінована. Це приблизно так добре, як можна було б зробити десять віджимань, а потім ще десять віджимань, а потім вирішити, чи сортували перший масив чи ні, тому що один потів більше на другому наборі віджимань. Ми забули, ми запускаємо код на багатозадачних машинах? Також на дуже малих масивах часовий відрізок просто недостатньо точний. +1, але дика спроба!
— LMSingh
1
@NiklasB. Тимсорт (варіант злиття) працює в лінійний час на відсортованих (а також частково відсортованих) масивах.
— Бакуріу
3
@JasonC - варто відзначити, що це робить реалізацію вище ще більш сумнівною: вона покладається не лише на знання, що алгоритм внутрішнього сортування рубіну є хитким (який сам по собі недокументований і, отже, сумнівна річ, на який слід покластися), але і на конкретну реалізацію оптимізовано для випадку вже відсортованих даних (котрий quicksort за замовчуванням не є: quicksort є лише O (n log n) у середньому випадку ... його найгірший показник - O (n ^ 2) і в наївній реалізації, що найгірший випадок насправді викликається за вже відсортованими даними).
— Жуль
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.
— П’єр Арло
3
У мене була подібна ідея, яка б запитала масив, і тоді одна за одною підказка "чи це більше, ніж це?" І якщо все вірно, то масив відсортовано
— Zach Thacker
41

Java - рекурсивні підмножини

Ласкаво просимо до переповнення стека! Це відмінне перше запитання, оскільки воно спотикає навіть деяких ветеранських кодерів. Дозвольте надати трохи довідкової інформації, перш ніж я просто роздам код:

Визначення впорядкованості може бути важким завданням на перший погляд. Для будь-якого набору довжини n є n! можливі способи її замовлення. Вони називаються перестановками . Якщо ваш масив має чіткі елементи, сортується лише одна з цих можливостей! Щоб знайти відсортований, вам потрібно просіяти їх усіх, поки не знайдете потрібний (можливо, лише) один, відкинувши всі інші.

Що? Звичайно , це не що важко ...

Алгоритми з n! складність займає багато часу для більших вкладень, але, доклавши трохи роботи, ми зможемо обійти це питання і просунути цілий порядок складності. Це ще експоненційний час, але це набагато краще, ніж фактор.

Для цього нам потрібно врахувати лише наступний математичний факт: Якщо масив відсортований, то сортується також кожна його (відносно впорядкована) підмножина . Ви можете попросити експертів з математики отримати офіційний доказ, але це інтуїтивно правда. Наприклад, для набору 123належні підмножини 1 2 3 12 13 23. Ви можете бачити, що всі вони замовлені. Тепер, якби оригінал був 213, ви мали б 2 1 3 21 23 13, і відразу ви можете побачити, що 21це не в порядку.

Причина цього важлива в тому, що їх набагато менше, ніж n! підмножини Насправді є лише 2 n -2 підмножини, на які нам потрібно звернути увагу. Ми можемо виключити набір, що містить весь масив вихідних чисел, а також порожній набір.

Все-таки 2 n -2 може бути багато роботи. Як і у більшості речей, що перевищують багаточленний час, тут добре працює підхід « ділити-перемагай» . Найпростіший підхід? Рекурсія !

Основні етапи прості. Для кожного підмножини вашого вводу ви генеруєте менші підмножини. Тоді для кожного з них ви робите те саме. Як тільки ваші підмножини зменшаться до розміру 2, ви просто перевірте, яка з них більша. Оскільки ви скорочуєте розмір підмножини щоразу, це насправді йде швидше, ніж ви очікували.

Ключовим фактом тут є те, що ви можете вийти зранку , як тільки знайдете одну підмножину з ладу. Вам не доведеться шукати їх усі. Якщо один поганий, вся група погана. Це врахування швидкості, яку ви не бачите в багатьох інших відповідях.

Досить поговорити, давайте код!

Я робив це на Java, оскільки це популярна мова та її легко читати. Елегантність рекурсії повинна бути очевидною:

import java.util.ArrayList;

public class SortChecker {

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

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

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

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

Для запису я набрид і вбив його, чекаючи 15 хвилин на відсортований 12-елементний масив. Це зробить 11 елементів приблизно за 45 секунд. Звичайно, це дійсно робить вихід раніше для НЕ відсортований, так що, гм, добре.

Оновлення: При новому перезавантаженні він робить 12 елементів за 13 хвилин. 13 займає майже 3 години, а 14 - 20 годин і рахується.

— Геобіт
джерело
8
+1 це, мабуть, найменш ефективний алгоритм, який я коли-небудь бачив. Повинно бути навколо O (n! * 2 ^ (n!)) - Складність (можливо, гірше).
— Раль Зарек
6
Я впевнений , що я бачив гірше, але це дуже погано. Я напівсердечно намагався визначити складність, але здався і покликав це O(big).
— Геобіт
1
Забезпечення рішення, яке є менш ефективним, навіть вражає наївна проблема продавця подорожі!
— recursion.ninja
3
Оскільки шанс відсортувати 12-ти елементний масив становить лише 1 на 479 мільйонів, насправді не важливо, що потрібно певний час, щоб бути абсолютно впевненим, що це, безумовно? Ви насправді ніколи не побачите його в реальному світі ...
— Жуль
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 символів.

— Містер Лістер
джерело
Мені це дуже подобається.
— Якоб
3
Це як підхід "використовувати кожну частину буйволів" до заяв справи.
— Джонатан Ван Матре
Це круто. Розкручуємо всі петлі!
— Маккей
чудова думка !!!
— bikram990
26

Інформувати

Inform - це мова для написання інтерактивних ігор з художньою літературою для класичного перекладача Z-машини з інформаційного коду. Щоб уникнути спойлерів, я спочатку надаю результати своєї програми, а потім вихідний код.

Редагувати: я зробив невелику редакцію, щоб додати номери до масиву, і включив чарівний опис кімнати.

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

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

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

>open safe
You open the safe.

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

You put the flask of poison into the safe.

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

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

>get array
Taken.

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

You put the numeral 1 into the array.

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

You put the numeral 2 into the array.

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

You put the numeral 3 into the array.

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

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

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

>close safe
You close the safe.

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

І з цим вихідний код:

"Sorted" by Jonathan Van Matre

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

Додж Рубі

Спочатку потрібно запустити цей код налаштування

class Array;alias ruby sort;end
def self.method_missing x,*a;x;end
def very x;$a=x;end
def many x;$b=$a.send x;end
def wow;puts $a==$b;end

Потім просто збережіть масив у змінній під назвою codingта запустіть:

  very coding

                 many ruby
so algorithm


      wow

І ваша відповідь буде надрукована (правдива чи помилкова).

Будь ласка, додайте код дози для оптимальної роботи:

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

Це найпростіший спосіб.

(Мистецтво ASCII формувалося написаним мною сценарієм, похідним від цього зображення .)

— Дверна ручка
джерело
7
Ви забули "так алгоритм". Справжній зразок дожів має 3 пропозиції перед "вау". І так, мені дуже весело на вечірках.
— П’єр Арло
@ArlaudPierre Хе, добре, виправлено: P
— Doorknob
11
Тож коментар, дуже вдосконалення, багато корисного. Ого.
— П’єр Арло
Ви мусили написати програму BF у форматі ascii у формі дожа ... нова ідея питання !!
— TheDoctor
19

PHP

Вам сподобається легкість і прямолінійність наступного рішення. Загальна концепція та передові функції, використовувані в цьому шедеврі кодування, негайно підведуть вас до елітного списку провідних розробників світу.

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

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

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

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

    mysql_query('DROP TABLE sorting_table');

    return $result;
}

print is_sorted(array(10, 20, 30, 40, 50));
— ВІДОМОСТЬ
джерело
+1 Тому що ви використовуєте ту саму концепцію моєї відповіді на питання щодо сортування
— Віктор Стафуса
4
Чи вдасться це зробити, якщо місіс Робертс введе цінність?
— користувач80551
3
@ user80551 так, тому що немає таблиці під назвою студенти
— храповик виродка
3
@JonathanVanMatre Безумовно, безпека є однією з найсильніших сторін цього коду.
— VisioN
1
Це моя нова улюблена відповідь на цьому веб-сайті; але для додаткових оцінок я хотів би бачити, що ви використовуєте PDO для безпеки
— alexandercannon
17

C # - Сила статистики

Що вам дійсно потрібно зробити для вирішення цього питання - це переформулювати питання таким чином, щоб зробити рішення очевидним. Оскільки це в основному питання "істинно-помилкового" типу, те, що ви по суті запитуєте, це "як я можу бути на 100% впевнений, що масив відсортований?" Якщо одне слово спливе з цього питання, це слово "певне". Який найкращий спосіб оцінити визначеність? Ви зрозуміли: статистика.

Інші відповіді тут лише перевіряють, чи сортується масив в одному напрямку . Це рішення перевіряє як висхідний, так і низхідний порядок одночасно. Трюк полягає в тому, щоб взяти масив того самого розміру, який ви вже знаєте, відсортовано (легко зробити його самостійно), а потім з’ясувати, наскільки добре впорядкування кожного масиву співвідноситься з іншим. Розрахунок коефіцієнта кореляції рейтингу Кендалл тау - це найпростіший спосіб зробити це:

using System;

namespace Homework
{
    class Example
    {
        static void Main(string[] args)
        {
            int[] n1 = { 23, 50, 16, 57, 19, 60, 40, 7, 30, 54 };
            int[] n2 = { 7, 16, 19, 23, 30, 40, 50, 54, 57, 60 };
            int[] n3 = { 60, 57, 54, 50, 40, 30, 23, 19, 16, 7 };

            Console.WriteLine(isSorted(n1));
            Console.WriteLine(isSorted(n2));
            Console.WriteLine(isSorted(n3));
        }

        static string isSorted(int[] a)
        {
            double t = 0;
            int n = a.Length;

            //Build a 'known' sorted array.
            int[] k = new int[n];
            for (int i = 1; i < n; i++)
            {
                k[i] = i;
            }

            //Find the Kendall's tau coefficient.
            //First the numerator...
            for (int i = 1; i < n; i++)
            {
                for (int j = 0; j < i; j++)
                {
                    t += Math.Sign(a[i] - a[j]) * Math.Sign(k[i] - k[j]);
                }
            }
            //...then the denominator.
            int d = n * (n-1) / 2;
            //This gives the correlation coefficient.
            double sortedness = t / d;
            //1 is perfect correlation (ascending), -1 is perfectly non-correlated (descending).
            if (Math.Abs(sortedness) == 1)
            {
                return "Sorted";
            }
            else
            {
                return "Unsorted";
            }
        }
    }
}

Вихід:

Unsorted
Sorted
Sorted

Ця функція також дуже просто розширить функціонал, оскільки було б тривіально додати функціональність на кшталт "В основному відсортований" або "Більше відсортований, ніж ні" або "Повністю випадковий".

Редагувати

Майже забув перейти над ефективністю алгоритму. Наразі це O (7). У назві методу є один, по одному в кожному з ключових слів «за», по одному в декларації «подвійний» і два у використанні змінної «сортування». Ви можете покращити це аж до O (0) (що настільки ж низько), перейменувавши функцію, змінивши подвійне на десяткове, знешкоджуючи "сортування" на "srtdnss" і перетворивши цикли для циклів у при цьому петлі.

— Комінтерн
джерело
2
Я ретельно перерахував складність і визначив, що це O (8). Ви махаєте рукою вихідний результат, який, на мою думку, повинен враховувати. Щоб мати справді складність O (7), ви можете розглянути можливість повернення "висхідний" / "випадковий", а не "відсортований" / "несортований".
— Геобіт
@Geobits - я ще раз переглянув це, і, звичайно, ти прав. Я думаю, це показує, що існує мінімальна складність O (1) при поверненні рядків. Це є невеликою ціною, яку потрібно платити, тому що повернення булевого вдвічі поганіше.
— Комінтерн
1
+1 для розрахунку O (). -1 для того, щоб не розрахувати rho Спірмена, бо хіба два кореляції не кращі, ніж один? І +1 за статистику в C #, перевіреному фавориті статистиків.
— Джонатан Ван Матре
Скажіть, будь ласка, O(7)річ - жарт
— mbatchkarov
@mbatchkarov - Це мало позначення O. :-)
— Комінтерн
16

Рубін

Наступна стратегія в підсумку виявить, якщо масив буде відсортований:

  1. A - масив (відсортований або несортований, наприклад [1,2,3] або [1,3,2])
  2. P - масив, що містить усі перестановки A
  3. Якщо сортується A , це або максимум, або мінімум P (що в основному є відсортованими версіями A в Ruby)

Інтернет-версія для тестування.

class Array
   def is_sorted?
      permutations = permutation.to_a
      self == permutations.max || self == permutations.min
   end
end
— Девід Геррман
джерело
1
Я не думаю, що я розумію пояснення. Якщо масив є, наприклад, [1, 9, 100], то хв - 10019, а макс - 91100, але відсортоване число - 19100. Граючи з онлайн-версією, max - [100,9,1] і min становить [1,1100]. Я не бачу, де щось "представлено цифрою"; схоже, масиви просто впорядковуються лексикографічно. Гадаю, це було б так само, якби всі числа були лише однією цифрою.
— Джошуа Тейлор
"... або максимум, або мінімум ..." сподобалось.
— мікробій
@JoshuaTaylor: Дякую за голову! Я хотів пояснити це легко зрозумілим способом - що в результаті виявилося неправильним;) Я виправив свій опис ...
— Девід Геррманн
2
@JoshuaTaylor методами рубіну Array # max і #min вибирають найбільший і найменший елемент стосовно операторів <і>. На масивах <і> введіть лексикографічне сортування. [1, 100] - мінімуми всіх упорядкованих перестановок 1, 9 і 100 у лексикографічному впорядкуванні.
— Карл Дамгаард Асмуссен
Це майже якість виробництва.
— прим
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
}
— fejesjoco
джерело
8
Якщо встановити кількість ітерацій на -n ^ 2 * ln (1-p), ви можете впевнитись, що ймовірність p буде перевірена всіма комбінаціями!
— Ганнеш
І які значення p справедливі, щоб це рішення було прийняте як "робочий код, але тролінг"? :)
— fejesjoco
2
З сайту stackoverflow.com/questions/2580933 шанс прорахунку порівняння через космічні промені становив би 0,0000018 (1,8е-6) щосекунди. Отже, якщо: 1) ви можете зрозуміти, скільки часу триває ітерація; 2) Ми можемо використовувати формулу @ Ханнеша для обчислення ймовірності, а потім вирішити систему рівнянь, щоб знайти кількість ітерацій, які роблять ваше рішення невідрізним від стандартним єСортований метод.
— Ксантікс
11

Пітон

Якщо список відсортований, кожне число є або меншим або рівним наступному номеру. Тому видалення самого лівого числа призведе до підвищення середнього значення, інакше список не буде відсортований. Ми поставимо це в цикл, щоб перевірити кожне число

def is_sorted(lst):
    def _avg(lst):
        return sum(lst)/(1.0*len(lst))
    for i in range(len(lst)-1):
        if _avg(lst[i:]) > _avg(lst[i+1:]):
            return False
    return True

is_sorted ([1,2,3]) #True
is_sorted ([3,2,1]) #False
is_sorted ([1,4,3,2,0,3,4,5]) #False

Читач, що спостерігає, помітить, що це не зовсім так.
введено ([1,4,3,2,0,3,4,11]) # Помилка
є_подарована ([1,4,3,2,0,3,4,12]) # Істинно
вказано ([1,2 , 1,2,1,2,1,2,99]) # Правда

— VBCPP
джерело
9

Баш 

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

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

торкніться файлу для кожного елемента масиву, ls каталогу та порівняйте результат ls з вихідним масивом.

Я не дуже хороший з башем, просто хотів спробувати :)

— Зак Такер
джерело
Приємно, це передбачає, що каталог "./nums" вже існує. Може десь "mkdir -p nums"?
— camelthemammel
О, так, це має сенс: P
— Zach Thacker
8

C #

Поняття "менший" або "більший" так багато 2013 року . Справжні програмісти використовують лише moduloоператора!

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

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

private static bool IsSorted(List<int> list)
{
    for(int i = 0; i % list.Count != list.Count() - 1; i++)
    {
        if (list[i] % list[i + 1] != list[i] &&
            list[i] != list[i + 1])
        {
            return false;
        }
    }
    return true;
}
— П’єр-Люк Пеньо
джерело
Що робити, якщо однакове число з’являється двічі? Потім перерахуйте [i]% list [i + 1] == 0.
— Саймон
@Simon О, хо! Дійсно, я думаю, відсортовано два однакових числа. Додано порівняння для цього крайнього випадку. Приємна знахідка.
— П’єр-Люк Пеньо
5
Радий знати, що {0, -1, 2} - це відсортований список.
— П'єр Арло
9
@ArlaudPierre Якщо ви хочете бути справжнім програмістом 2014 року, вам слід відкинути все негативне. Світ позитивний, світ абсолютний, світ - модуль!
— П’єр-Люк Пеньо
1
Оскільки вам не подобаються поняття «більший» і «менший», прикро, що вам довелося включати знаки, менші та більші, ніж знаки. Ви повинні були використовувати масиви, а не списки.
— Містер Лістер
8

Скала

Перевірка сортування масиву проста! Просто перевірте, чи перший елемент менший за другий. Потім відсортуйте решту та подивіться, чи рівні вони.

На жаль, сортування - це важка проблема. Існує не так багато відомих або ефективних алгоритмів для сортування масиву; насправді це величезна сліпа пляма в сучасному стані знань з інформатики. Тому я пропоную простий алгоритм: перетасувати масив, а потім перевірити, чи він відсортований, що, як уже було сказано, легко! Продовжуйте перемішувати, поки не буде відсортовано.

object Random {
  def isSorted(list: List[Int]): Boolean = {
    if (list.size <= 1) {
      true
    } else {
      sort(list.tail) == list.tail && list.head <= list.tail.head
    }
  }

  def sort(list: List[Int]): List[Int] = {
    val rand = new scala.util.Random()
    var attempt = list
    do {
      attempt = rand.shuffle(attempt)
    } while (!isSorted(attempt))
    attempt
  }

  def main(args: Array[String]): Unit = {
    println(isSorted(List(1, 2, 3)))
    println(isSorted(List(1, 3, 2)))
    println(isSorted(List(1, 2, 3, 4, 5, 6, 7, 8)))
  }
}

Я припускаю, що це виходить "правдивим, хибним, правдивим". Він працює деякий час ...

— Джо К
джерело
8

Впорядкований масив цілих чисел має властивість, що кожен підмасив (скажімо, елементи з n через m масиву) також є відсортованим масивом цілих чисел. Це, очевидно, означає, що найкращим методом є функція РЕКУРСУВАННЯ:

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

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

Це може бути не найшвидшим методом, але це все-таки ДУЖЕ ТОЧНИЙ тест того, чи вказується список чи ні. Читати і розуміти цей код також надзвичайно просто, оскільки він використовує ФУНКЦІОНАЛЬНУ парадигму, і тому не містить жахів змін і ітераційних циклів.

Сподіваюся, це стане для вас корисною інформацією.

— Аллен
джерело
6

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;
}
— fejesjoco
джерело
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. Чи можете ви її знайти?

— 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

  • Тому запустіть основний цикл для всіх елементів і перевірте вищевказані два умови, виконавши дві вкладені петлі всередині основної (одну для лівої та однієї для правої сторони)

Отже, я даю реалізацію описаного алгоритму 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, а другий повинен був бути від + 1 до довжини. До речі, 1,2,3 слід сортувати, чи не так?
— мікробій
@microbian Добре, відредаговано.
— Віктор Стафуса
4

С

Згодом "відсортований" означає "відсортований у порядку зростання".

Масив не сортується iff a[i]>a[i+1]

Тож якщо ми дозволимо x=a[i]-a[i+1], xбуде позитивним, якщо масив не буде відсортований.

Щоб перевірити, чи xє позитивним, ми можемо розбити його на дві частини: xне є негативною і xне дорівнює нулю

Простий тест на те, чи xє негативним те, що ми перевіряємо, чи x*xдорівнює x*abs(x). Ця умова має бути хибним , якщо xнегативно, так як (-1)*(-1)==1.

Щоб перевірити нуль, ми можемо скористатися ще одним простим тестом: 0./(float)xце не число, якщо iff xдорівнює нулю.

Отже, ось весь код: (припустимо, що масив містить 5 елементів)

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main() {
    int i, a[5];
    for(i=0;i<5;i++) scanf("%d",&a[i]);
    int sorted=1;
    for(i=0;i<4;i++) {
        int x=a[i]-a[i+1];
        if(x*x==x*abs(x)&&!isnan(0./(float)x)) {
            sorted=0;
            break;
        }
    }
    puts(sorted?"sorted":"not sorted");
    return 0;
}
— ace_HongKongIndependence
джерело
Власне, тестування на a[i]-a[i+1] > 0це вже проблематично. Не потрібно робити усі ці напої.
— n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳
Робити непотрібні речі - вся суть тролінгу коду, чи не так? (А що ви маєте на увазі під проблематикою?)
— ace_HongKongIndependence
1
Переповнене ціле число переповнено UB. Навіть якщо ми визначимо поведінку, що завершиться, якщо ми зробимо INT_MAX - INT_MIN, то результатом буде від'ємне число (замінимо [i] на INT_MAX, а [i + 1] на INT_MIN).
— n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳
Оскільки це лише проблема домашнього завдання, припустимо, що вчитель не дасть стільки крайніх цифр.
— ace_HongKongIndependence
ГАРАЗД. Тільки що я вважаю за краще троль + бути злим.
— n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳
4

Це все про те, якими певними ви хочете бути. Оскільки жодної впевненості не було надано, насправді досить хороші показники. Код нижче дає хорошу здогадку, але якщо ви впевнені, вам слід повторити функцію пару разів. Якщо ви хочете бути справді впевненими, вам слід запустити його в циклі і зробити це десяток разів. Ідеальна масштабованість!

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

static const int size = 100;

int issorted(int *array, int size)
{
    int idx = random() % size;
    return (array[idx] >= array[0]);
}

void check_array(int *array, int size)
{
    if (issorted(array, size)) {
        puts("The array is sorted but I am not 100% sure.");
    } else {
        puts("The array is definitely not sorted in ascending order.");
    }
}

int main(void)
{
    int *array = malloc(sizeof(int) * size);
    int i = 0;

    srand(time(NULL));

    for (i = 0; i < size; i++) {
        array[i] = random();
    }

    check_array(array, size);

    for (i = 0; i < size; i++) {
        array[i] = i + 1;
    }

    check_array(array, size);
    free(array);

    return 0;
}

Хіба це не частування?

— n0la
джерело
4

С

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

Працює з вірогідністю 1- (1 / n!) Та складністю O (1). Очевидно, найкращий метод для дуже великих випадкових масивів.

Оскільки складність становить лише O (1), для кращої оцінки виконуйте двічі.

— cпрі
джерело
3

С

Ця функція не тільки підказує, чи сортується масив. Це говорить вам, скільки елементів знаходиться в потрібному місці. Він може використовуватися для будь-якого типу даних.

Зверніть увагу на важливість використання описових імен змінних, щоб зробити ваш код легким для дотримання. З іншого боку, нам не потрібно оголошувати змінну i, оскільки вона обов'язково декларується десь в програмі.

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

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

  return number_of_elements_in_right_place;
}

Редагувати: Це кращий спосіб для більших масивів. Перевага цього в тому, що воно схоже на те, як людина перевірила б.

int sortcheck(array_to_be_checked[32767])
{
  i=rand(); j=rand();
  while( (array_to_be_checked[i] > array_to_be_checked[j]) = (i > j) ) 
  {
    printf("I think it's sorted");
    i=rand(); j=rand();
  };
  printf("It wasn't sorted");
}
— Рівень річки Св
джерело
1
"Нам не потрібно оголошувати змінну i, оскільки вона обов'язково буде оголошена деінде в програмі." варто було сміятися.
— Джонатан Ван Матре
@JonathanVanMatre Дякую, але це далеко не єдине, що не так у цьому коді.
— Рівень р. Св.
3

JavaScript + додаткова статистика

Мені дуже сподобалось рішення, запропоноване @Cominterm. Але порівняння з уже відсортованим списком? Це обман!

Натомість я обчислюю автокореляцію масиву (кореляція між масивом та лівою масивом зміщена на одне положення). Потім я перетасовую масив багато разів і кожен раз порівнюю його нову автокореляцію з початковою автокореляцією. Якби масив був відсортований, оригінальна автокореляція була б найбільшою частиною часу!

http://jsfiddle.net/dB8HB/

Бонус: Якщо ваше p-значення <0,05, вихід автоматично автоматизує завдання стверджувати, що масив відсортований для вас. Що ще можна попросити?

Bonus2: Хоча ця реалізація для зручності використовує функції масиву O (n) JavaScript, підхід може використовувати вибірку для запуску в постійний час!

<form name="out"><textarea name="put" cols="80" rows="3">Press the button</textarea></form> 
<button onclick="startstop();">The button</button>
<script>
var iid=input=0, my=document.forms, isit={'true':0.5,'false':0.5}, ownAutocorr;
function startstop(){
     if(iid){
        clearInterval(iid);
        if(1 - isit.true / (isit.true+isit.false)<0.05){my.out.put.value+="\nYour array is sorted! (p<0.05)";}
        iid=input=0;isit={'true':0.5,'false':0.5}
     }
     else   {
        input=JSON.parse("["+prompt("Comma separated integers")+"]");
        ownAutocorr=pearsonCorrelation(input,cloneShiftArray(input));
        iid=setInterval(trial,50);
    }
}

function trial(){

 var newArr=shuffle(input.slice(0));
 var newAutocorr=pearsonCorrelation(newArr,cloneShiftArray(newArr));
 isit[newAutocorr<ownAutocorr]++;
 my.out.put.value="Your array is sorted with probability " + (isit.true / (isit.true+isit.false)).toFixed(2);
}

function cloneShiftArray(oldArr){
    var newArr=oldArr.slice(0); //clone the array
    var len=oldArr.length;
    //shift the array one
    for(var l=0;l<len-1;l++){
     //performance is important so we'll use bitwise operators
     newArr[l]^=newArr[l+1];
     newArr[l+1]^=newArr[l];
     newArr[l]^=newArr[l+1];
    }
    newArr[l]+=newArr[l-1   ];
    return newArr;
}
function pearsonCorrelation(p1, p2) { //Borrowed from teh interwebs
  var len = p1.length;
  var sum1=sum2=sum1Sq=sum2Sq=pSum = 0;
  for (var l = 0; l < len; l++) sum1 += p1[l];
  for (var l = 0; l < len; l++) sum2 += p2[l];
  for (var l = 0; l < len; l++) sum1Sq += Math.pow(p1[l], 2);
  for (var l = 0; l < len; l++) sum2Sq += Math.pow(p2[l], 2);
  for (var l = 0; l < len; l++) pSum += p1[l] * p2[l];
  var num = pSum - (sum1 * sum2 / len);
  var den = Math.sqrt((sum1Sq - Math.pow(sum1, 2) / len) *
      (sum2Sq - Math.pow(sum2, 2) / len));
  if (den == 0) return 0;
  return num / den;
}
function shuffle(array) {//also borrowed
  var currentIndex = array.length, temporaryValue, randomIndex;
  while (0 !== currentIndex) {
    randomIndex = Math.floor(Math.random() * currentIndex);
    currentIndex -= 1;
    temporaryValue = array[currentIndex];
    array[currentIndex] = array[randomIndex];
    array[randomIndex] = temporaryValue;
  }
  return array;
}
</script>
— Фабіо Белтраміні
джерело
3

JavaScript / SVG - sunDialsort

Це рішення не використовує компаратори <, <=,> або> =. Я намагався змусити її читати якомога менше, як функцію сортування.

Метод

  • Накресліть значення у вигляді крапок уздовж дуги.
  • Для висхідного масиву кожне значення зробить загальну ширину малюнка ширшим і не зменшить початковий X (виняток: два однакових значення).
  • Оскільки ширина не може зменшитися! = Буде достатньо,
  • Оскільки X не може збільшитися, то == буде достатньо.
  • для фіксації двох однакових значень кожна точка є фактично лінією, що збільшує довжину. Якщо довжина одиниці менше 1 / кількість значень.

Тролінг

Я додав наступні долоні обличчя під час читання цього дуже поганого коду.

  • Функція може виглядати так, як збирається сортувати масив, назвавши його sunDialsort (бонусна погана капіталізація)
  • використовується посилання lit-geek для всіх імен змінних
  • використовував молоток регулярних виразів для підрахунку кількості елементів у масиві
  • використовували вікно оповіщення
  • рішення для крайового випадку, коли дві послідовні змінні однаково подвоюють кількість коду (один вкладиш міг би відсортувати його), поставте партії цього коду рано, щоб плутати мету функції.
  • замість того, щоб знайти мінімум та максимум, знайти найдовше число і обійти до наступної потужності десять, сподіваємось, це відкине людей від запаху.

xml

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

функція

sunDialsort = function (values)
{
    var twas = values.toString();  
    var brillig = twas.match(/,/g).length + 1; //<1>
    //find the sig figs we are working with (longest number)
    var and = [], the = 0;
    for (var jabberwock = 0; jabberwock < twas.length; jabberwock++)
    {
        switch (twas.charAt(jabberwock))
        {
        case ("."):
            break; //dont count
        case (","):
            and.push(the);
            the = 0;
            break;
        default:
            the++;
        }
    }
    and.push(the);
    var slithy = Math.max.apply(Math, and);
    //assume did/toves based on number of characters
    var toves = Math.pow(10, slithy);
    var did = toves * -1;
    console.log(did + "," + toves + "," + brillig);
    //for each number make a horizontal svg line of length (jabberwock*acuuracy)     
    var gyre = 1 / brillig;
    var gimble, wabe, all, mimsy, were, borogoves, mome, raths;
    var outgrabe = true;
    for (jabberwock = 0; jabberwock < brillig; jabberwock++)
    {
        gimble = document.createElementNS('http://www.w3.org/2000/svg', 'path');
        gimble.setAttribute("stroke", "blue"); //green is not a creative colour
        gimble.setAttribute("d", "M0 20 h " + (jabberwock * gyre));
        wabe = (values[jabberwock] - did) / (toves - did);
        mimsy = 90 - (wabe * 180);
        gimble.setAttribute("transform", "rotate(" + mimsy + ")");
        document.getElementById("dial").appendChild(gimble);
        borogoves = document.getElementById("dial").getBBox();
        if (mome)
        {
            raths = (borogoves.width != all && were == borogoves.x);
            console.log("test " + raths);
            all = borogoves.width;
            if (!raths)
            {
                outgrabe = false
            }
        }
        else
        {
            were = borogoves.x;
            all = borogoves.width;
            mome = true;
        }
    }
    return outgrabe
};
alert(sunDialsort([1, 2, 3, 3, 4341, 556]));

Якщо хтось хоче перевірити, тут є версія з читаними іменами змінних. http://jsfiddle.net/outRideACrisis/r8Awy/

— OutRideACrisis
джерело
3

С

Оскільки двійковий пошук працює лише на відсортованих масивах, для перевірки сортування масиву все, що нам потрібно зробити, - це перевірити, чи працює бінарний пошук для всіх елементів масиву. Якщо не вдається знайти жоден елемент, ми знаємо, що масив не сортується.

Усі аргументи командного рядка повинні бути десятковими цілими числами без провідних нулів.

#include <stdlib.h>
#include <string.h>

int compar(const void *a, const void *b) {
  char *const *sa = a, *const *sb = b;
  int cmp = strlen(*sa) - strlen(*sb);
  if (cmp == 0) cmp = strcmp(*sa, *sb);
  if (cmp == 0) cmp = sa - sb;
  return cmp;
}

int main(int argc, char *argv[]) {
  if (argc-- && argv++) {
    for (int i = 0; i != argc; i++) {
      if (bsearch(argv+i, argv, argc, sizeof *argv, compar) != argv+i) {
        return 1;
      }
    }
  }
  return 0;
}
— hvd
джерело
2

С

  • Зробіть копію масиву
  • сортувати копію у порядку зменшення
  • перевірте, чи цей масив є зворотним для даного масиву
    #include<stdio.h>
    #include<stdlib.h>
    #include <stddef.h>
    #include<string.h>
    int main(){
     int arr[100],i,j,temp;
     int a[] = {1,2,3,4,5,6,7,8,9,10};
     char b[256];

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

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

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

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

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


     }
— Mhmd
джерело
2

Математика

Цей алгоритм, здається, працює, але він трохи повільний. Можливо, існують більш швидкі способи сортування, але я їх не знайшов.

  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
джерело
Завдання полягало в тому, щоб перевірити, чи вхід вже відсортований.
— Ільмарі Каронен
Це найважливіша ідея мого рішення (хоча я використовую квадратичний час OrderedQлише для прихильників) з доданою перевіркою в кінці "тепер, коли у нас є сортування, з чого ми почали?"
— стенд
2

JavaScript

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

    var obj = {};
    var i;

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

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

    return true;
}

Ця функція може повертатися falseнеправильно, але не в сучасних браузерах; ви можете перевірити це і, якщо потрібно, надати повільнішу віддачу (як описано в питанні):

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

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

Вони кажуть, що це дає непередбачувані результати за негативними цифрами, але все, що насправді все залежить, - наскільки ви хороші в прогнозуванні речей.

— Ри-
джерело
2
Я б хотів, щоб Chrome міняв властивості об’єктів, щоб люди не могли робити такі дії…
— Bergi
2

Ява (відстань Левенштейна)

У цій реалізації я клоную вихідний масив і сортую клонований екземпляр. Потім обчислюється відстань Левенштейна. Якщо він дорівнює нулю, то початковий масив був відсортований.

Примітка. Реалізація getLevenshteinDistance () взята з Jakarta Commons Lang та модифікована для роботи над int [] замість CharSequence.

import java.util.Arrays;

public class CheckSorting {

    public boolean isSorted(int[] array) {
        int[] sortedArray = Arrays.copyOf(array, array.length);
        Arrays.sort(sortedArray);

        return CheckSorting.getLevenshteinDistance(array, sortedArray) == 0;
    }

    public static int getLevenshteinDistance(int[] s, int[] t) {
        int n = s.length;
        int m = t.length;

        if (n == 0) {
            return m;
        } else if (m == 0) {
            return n;
        }

        if (n > m) {
            int[] tmp = s;
            s = t;
            t = tmp;
            n = m;
            m = t.length;
        }

        int p[] = new int[n + 1];
        int d[] = new int[n + 1];
        int _d[];

        int i;
        int j;

        int t_j;

        int cost;

        for (i = 0; i <= n; i++) {
            p[i] = i;
        }

        for (j = 1; j <= m; j++) {
            t_j = t[j - 1];
            d[0] = j;

            for (i = 1; i <= n; i++) {
                cost = s[i - 1] == t_j ? 0 : 1;
                d[i] = Math.min(Math.min(d[i - 1] + 1, p[i] + 1), p[i - 1] + cost);
            }

            _d = p;
            p = d;
            d = _d;
        }
        return p[n];
    }
}
— user3001267
джерело
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.