Вы вводите список / последовательность / вектор / массив из 5-255 натуральных чисел, не обязательно уникальных. Вы можете предположить, что любой входной формат является наиболее подходящим, и что каждое целое число (а также количество целых чисел) выбирается случайным образом равномерно из диапазона 5-255.

Цель состоит в том, чтобы вывести тот же список в том же (или эквивалентном) формате, но отсортированный в порядке возрастания (неубывания). Обычное раннее упражнение в изучении языка. Представления должны включать:

1. Ответ, который работает правильно и достигает цели; а также

2. Второй ответ, который содержит досадную ошибку. Между 1% и 10% времени выходные данные должны быть списком в правильном формате и содержать правильные элементы, но в неправильном порядке (любой порядок, кроме правильно отсортированных). В остальное время программа должна работать правильно и достигать цели.

Два ответа должны иметь расстояние Левенштейна один; то есть мы можем получить одно из другого, удалив один байт или добавив один байт или изменив один байт.

Подсчет очков, как обычно, в Code-Golf (на основе более короткого из двух ваших ответов), с обычными лазейками, запрещенными.

Бонус 10% (уменьшение до оценки), если надоедливая ошибка не зависит от ввода, то есть повторное использование того же ввода не воспроизводит ошибку (за исключением случаев от 1% до 10% времени).

Python 3 , 36 байт

Баг-бесплатная версия, 37 байт

lambda l:sorted(l,reverse=l[-9:]==[])

Попробуйте онлайн!

Раздражающая версия, 36 байт

lambda l:sorted(l,reverse=l[9:]==[])

Попробуйте онлайн!

Это зависит от ввода и, следовательно, не претендует на бонус.
Вероятность сбоя составляет около 2%. Сбой, когда входная длина меньше 10.

В сочетании с ответом LyricLy это дает 34 байта:

lambda l:sorted(l)[::l[9:]>[]or 1]
lambda l:sorted(l)[::l[9:]>[]or-1]

05AB1E , 5 * 0,9 = 4,5 байта

Рабочий раствор

{TLΩi

Попробуйте онлайн!

объяснение

{      # sort input
 TL    # push the range [1 ... 10]
   Ω   # pick a random number in the range
    i  # if true (equal to 1), do nothing

Решение, содержащее ошибку

Дает неправильное решение 10% времени (независимо от ввода).

{TLΩiR

Попробуйте онлайн!

объяснение

То же, что и рабочее решение, за исключением того, что он переворачивает список, если выбранное число истинно.

Желе , 7 * (100% - 10%) = 6,3 байта

Ṣ¹⁵X:¤¡

Попробуйте онлайн!

Багги версия:

ṢẊ⁵X:¤¡

Попробуйте онлайн!

В обеих ссылках есть тестовая программа, которая будет запускать код 100 раз, каждый раз со списком, который вы даете в качестве аргумента, и затем возвращать результаты.

Вероятность каждой входной длины:

0.1 - 0.1/(length!)

Таким образом, для длины 1 существует вероятность 0%, для длины 2 5%, для длины 3 8,83̅%, для длины 4 9,583̅% и т. Д. До длины ∞, которая имеет 10% вероятности.

Python 3, оценка 58 57 - 10% = 51,3

Сохраненный байт благодаря овс.

Без ошибок версия, 57 байт

lambda m:sorted(m)[::random()>.1or 1]
from random import*

Попробуйте онлайн!

Версия с ошибками, 57 байт

lambda m:sorted(m)[::random()>.1or-1]
from random import*

Попробуйте онлайн!

Я решил попробовать решение, которое использует бонус. Это не побеждает другой ответ Python, но мне было весело думать об этом.

C 71 * 0,9 = 63,9 байта

Без ошибок:

c(int*a,int*b){return*a-*b;}f(a,n)int*a;{if(rand()%1<9)qsort(a,n,4,c);}

Попробуйте онлайн!

Багги:

c(int*a,int*b){return*a-*b;}f(a,n)int*a;{if(rand()%10<9)qsort(a,n,4,c);}

Попробуйте онлайн!

Groovy , 31 байт

Ошибка решения:

{a->a.sort()[a[9]?0..-1:-1..0]}

Рабочий раствор:

{a->a.sort()[a[0]?0..-1:-1..0]}

Оператор индекса Groovy ( getAtметод) возвращает ноль для списков, если индекс больше размера. Поэтому, если есть девятый элемент, он останется таким же, как и отсортированный список, но если нет (вероятность 1.99203187%), он будет перевернут. Однако всегда будет первый элемент, потому что размер списка всегда больше или равен 5. Таким образом, 0 в a[0]можно поменять местами с 1, 2, 3 или 4.

Wolfram Language (Mathematica) , 29 байт

Это 26,1 байта с бонусом, но я не совсем уверен, что получу бонус; на уже отсортированном вводе обе версии всегда выдают отсортированный вывод.

Без ошибок версия (29 байт)

If[RandomReal[]<0.,#,Sort@#]&

Попробуйте онлайн!

Раздражающая версия (30 байт)

If[RandomReal[]<0.1,#,Sort@#]&

Попробуйте онлайн!

PHP, 70 байт

Баг-бесплатная версия, 70 байт

<?unset($argv[0]);((rand(1,9)?"":r).sort)($argv);echo join(" ",$argv);

Попробуйте онлайн!

Ошибка версии, 70 байт

<?unset($argv[0]);((rand(0,9)?"":r).sort)($argv);echo join(" ",$argv);

Попробуйте онлайн!

Версия с ошибками сортируется в обратном порядке 10% времени (на основе генератора случайных чисел).

Python 2 , 26 байт

Багги:

lambda l:l[9:]and l.sort()

Попробуйте онлайн!

Выходы путем изменения списка ввода . Сортирует список только в том случае, если его длина составляет не менее 10. Не 9содержащая ошибок версия заменяет символ a 0на сортировку всегда.

За работой:

lambda l:l[0:]and l.sort()

Попробуйте онлайн!

Мы можем изменить функцию, чтобы она возвращала список по стоимости 4 байта, всего 30 байтов:

lambda l:l[9:]and l.sort()or l

Попробуйте онлайн!

25 байт с некоторыми отрезками правил:

[list,sorted][id(0)%17>0]

Попробуйте онлайн!

Выводит функциональный литерал, который либо сортирует, либо является идентификатором, используя его id(0)в качестве случайного источника. Изменить >на >=исправить или 0на ~0.

Шелуха , 6 байт

Багги версия:

?OIV¦9

Попробуйте онлайн!

Правильная версия:

?OIVK9

Попробуйте онлайн!

объяснение

Эти программы полностью детерминированы. Фактически, Husk в настоящее время вообще не поддерживает случайные числа.

?  V    If any element
    ¦9  is divisible by 9 (in buggy version),
    K9  is truthy when replaced by 9 (in correct version),
 O      sort the list,
  I     otherwise return it unchanged.

Я утверждаю, что выходные данные программы с ошибками не сортируются с вероятностью от 1% до 2%. Обозначим через N = 251 количество возможных значений элементов. Вероятность того, что случайный список длины L не содержит кратных 9, равна ((NK) / N) ^ L , где K - количество значений, кратных 9 (в нашем случае K = 28 ). Общая вероятность - это среднее значение для 5 ≤ L ≤ 255 , что составляет около 1,98%. Некоторые из этих списков являются ложными срабатываниями, поскольку они уже отсортированы. Вероятность сортировки случайного списка длины L не более ((N + N * (N-1) / 2) / N ^ 2) ^ ⌊L / 2⌋ : если мы разбиваем список на куски длины 2, каждый изКуски ⌋L / 2⌋ должны быть отсортированы. Общая вероятность сортировки списка ограничена средним значением для 5 ≤ L ≤ 255 , что составляет около 0,30%. Таким образом, вероятность того, что функция вернет несортированный список, находится между 1,67% и 1,98%.

Баш , 26 байт

Правильная версия

s=n
sort -${s:RANDOM%20<0}

Попробуйте онлайн! или проверьте вероятности .

Ошибка версии

s=n
sort -${s:RANDOM%20<1}

Попробуйте онлайн! или проверьте вероятности .

Принимает ввод в виде разделенных новой строкой чисел. Использует встроенную переменную RANDOM, которая всегда возвращает (псевдо) случайное число в диапазоне от 0 до 32767 . Использование %20результатов примерно на 5% отказов (спасибо @Titus за разъяснения проблем с %10).

Эта случайность означает, что частота отказов не зависит от входных данных, но для этого требуется, чтобы входной массив содержал хотя бы одно число с более чем одной цифрой, поскольку выходные данные об ошибках отсортированы лексикографически.

Альтернативная версия, 27 байт

((RANDOM+20))||cat&&sort -n

Исправленная версия заменяет +собой %. Попробуйте онлайн или попробуйте .

Pyth , оценка 8 * 0,9 = 7,2

Первый фрагмент (правильный):

h.uSNT.S

Попробуй это здесь!

Второй фрагмент (прослушанный):

O.uSNT.S

Попробуй это здесь!

Сохранено два байта (и 1,8 балла) благодаря isaacg !

JavaScript (ES6), 24 байта

Безошибочная версия (по крайней мере, для целых чисел в диапазоне 0-2147483647, поэтому все в указанном диапазоне):

a=>a.sort((a,b)=>a-b>>0)

Багги версия:

a=>a.sort((a,b)=>a-b>>1)

Зависит от а) алгоритма сортировки движка и б) списка входных данных, содержащего два значения в неправильном порядке, которые отличаются на 1. (Если вероятность этого оказывается слишком низкой, то значение 1можно увеличить, но к тому времени, когда вы получите к 8этому просто не будет ничего сортировать в диапазоне 5-255.)

PHP, 62 байта

Вдохновленный решением Джо (и я только что заметил: это порт Джастина Маринера ):

рабочая (сортировка по возрастанию):

unset($argv[0]);(r[rand()+20].sort)($argv);echo join(_,$argv);

багги (около 5% вероятности убывания):

unset($argv[0]);(r[rand()%20].sort)($argv);echo join(_,$argv);

Бежать с -nr

Pushy , 9 байт - 10% = 8,1

Ошибка решения:

g0TUn?};_

Попробуйте онлайн!

Рабочее решение:

g1TUn?};_

Попробуйте онлайн!

Код ошибки делает следующее:

g0TUn?};_

g          \ Sort the stack correctly
 0TU       \ Generate random(0, 10)
    n? ;   \ If this is zero:
      }    \    Cyclically shift the stack right once
        _  \ Print the result

Фиксированный код просто меняется 0на 1. Как random(1, 10)никогда 0, оператор if никогда не будет выполнен.

MATL , 7 * 0,9 = 6,3 6 * 0,9 = 5,4 байта

Багги версия:

Gr.9<?S

Попробуйте онлайн!

Объяснение:

G        % Grab input
 r       % Push a random number between 0 and 1
  .9     % Push 0.9
    <    % Check if the random number is smaller than 0.9
     ?   % If true
      S  % Sort input
         % Implicit output

Баг-бесплатная версия:

Gr9<?S

Попробуйте онлайн!

Объяснение:

G       % Grab input
 r      % Push a random number between 0 and 1
  9     % Push 9
   <    % Check if the random number is smaller than 9 (always true)
    ?   % If true
     S  % Sort the input
        % Implicit output     

Jq 1,5 , 42 байта

детская коляска

sort|if length%13<=0then reverse else. end

Рабочая (удалить =)

sort|if length%13<0then reverse else. end

Предполагая, что длины линий одинаковы в диапазоне [5,255], около 7% вызовут ошибку

Попробуйте онлайн!

J, 22,5 байта (25 байтов - 10%)

с ошибкой:

[:]`(1&A.)@.(0.1>?@0:)/:~

без ошибок:

[:]`(0&A.)@.(0.1>?@0:)/:~

Попробуйте онлайн!

R 30 * .9 = 27 байт

(Глючит)

function(l)sort(l,runif(1)<.1)

Попробуйте онлайн!

(не глючит)

function(l)sort(l,runif(1)<.0)

Версия с ошибками сортируется в decreasing=T10% случаев, выборка производится из равномерного (0,1) распределения. Версия без ошибок всегдаdecreasing=F

Рёда , 42 байта - 10% = 37,8

Без ошибок:

{sort key={|i|currentTime|[_%20//19*0+i]}}

Багги:

{sort key={|i|currentTime|[_%20//19*i+i]}}

Попробуйте онлайн!

Это использует currentTimeфункцию для создания случайных чисел. Кажется, что их распределение немного различается между машинами. Соотношение 20//19может быть скорректировано, чтобы получить разные результаты без потери байтов (если оно не меньше 99//98).

октава , 36 * 0,9 = 32,4 байта

Багги версия:

@(x)sort(x)(shift(1:end,+(rand<.1)))

Попробуйте онлайн!

Баг-бесплатная версия:

@(x)sort(x)(shift(1:end,+(rand<.0)))

Попробуйте онлайн!

Это сортирует вектор, а затем сдвигает все числа на один вправо, если случайное число меньше 0,1.

Java 8, 45 34,2 ( 50 38 - 10%) байтов

Нормальная версия:

a->{if(Math.random()>0.)a.sort(null);}

Объяснение:

Попробуй это здесь.

a->{                    // Method with ArrayList<Integer> parameter and no return-type
  if(Math.random()>0.)  //  If the random 0-1 double is larger than 0:
    a.sort(null);       //   Sort the input-List
}                       // End of method

Ошибка версии ( 51 39 байт):

a->{if(Math.random()>0.1)a.sort(null);}

LD 1: 1 добавлено.

Объяснение:

Попробуй это здесь.

a->{                     // Method with ArrayList<Integer> parameter and no return-type
  if(Math.random()>0.1)  //  If the random 0-1 double is larger than 0.1:
    a.sort(null);        //   Sort the input-List
}                        // End of method

JavaScript, 25 * 0,9 = 22,5

new Date%25?x:x.sort()

вход х