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

Мета - вивести той самий список у тому самому (або еквівалентному) форматі, але відсортований у порядку збільшення (не зменшується). Поширена рання вправа в вивченні мови. До матеріалів, що включають:

1. Відповідь, яка працює правильно і досягає мети; і

2. Друга відповідь, яка містить дратівливу помилку. Від 1% до 10% часу, вихід повинен бути списком у правильному форматі та містить правильні елементи, але в неправильному порядку (будь-який порядок, крім правильно відсортованого). Решту часу програма повинна правильно працювати і досягати мети.

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

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

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метод) повертає null для списків, якщо індекс більший за розмір. Отже, якщо є дев'ятий елемент, він залишатиметься таким же, як і відсортований список, але якщо ні (1.99203187% шансів), він буде перетворений. Однак завжди знайдеться перший елемент, оскільки розмір списку завжди більший або дорівнює 5. Тож 0 у a[0]може бути замінений на 1, 2, 3 або 4.

Мова Вольфрама (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. Версія, яка не багує, замінює сортування 9a 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

Спробуйте в Інтернеті!

Пояснення

Ці програми є повністю детермінованими. Насправді у Хуска наразі взагалі немає підтримки для випадкових чисел.

?  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

Bugged версія замінює +з %. Спробуйте в Інтернеті або спробуйте помилку .

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

Пушистий , 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 555], приблизно 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);}

ЛД 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()

вхід x