Đầu vào của bạn là một danh sách / chuỗi / vectơ / mảng gồm 5-255 số nguyên dương, không nhất thiết phải là duy nhất. Bạn có thể giả sử bất kỳ định dạng đầu vào nào phù hợp nhất và mỗi số nguyên (cũng như số lượng số nguyên) được chọn thống nhất một cách ngẫu nhiên trong phạm vi 5-255.

Mục tiêu là xuất ra cùng một danh sách, theo cùng định dạng (hoặc tương đương), nhưng được sắp xếp theo thứ tự tăng (không tăng). Một bài tập sớm phổ biến trong việc học một ngôn ngữ. Đệ trình bao gồm:

1. Một câu trả lời hoạt động chính xác và đạt được mục tiêu; và

2. Một câu trả lời thứ hai có chứa một lỗi khó chịu. Từ 1% đến 10% thời gian, đầu ra cần phải là một danh sách theo đúng định dạng và chứa các phần tử chính xác, nhưng theo thứ tự sai (bất kỳ thứ tự nào ngoại trừ được sắp xếp chính xác). Thời gian còn lại, chương trình phải hoạt động chính xác và đạt được mục tiêu.

Hai câu trả lời phải có khoảng cách Levenshtein một; nghĩa là, chúng ta có thể lấy cái này từ cái kia bằng cách xóa một byte hoặc thêm một byte hoặc thay đổi một byte.

Ghi điểm như bình thường trong môn đánh gôn (dựa trên câu trả lời ngắn hơn trong hai câu trả lời của bạn), với các sơ hở thông thường bị cấm.

Phần thưởng 10% (giảm điểm) nếu lỗi gây phiền nhiễu không phụ thuộc vào đầu vào, tức là sử dụng lại cùng một đầu vào không tái tạo lỗi (ngoại trừ từ 1% đến 10% thời gian).

Python 3 , 36 byte

Phiên bản không có lỗi, 37 byte

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

Hãy thử trực tuyến!

Phiên bản gây phiền nhiễu, 36 byte

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

Hãy thử trực tuyến!

Điều này phụ thuộc vào đầu vào và do đó không đủ điều kiện nhận thưởng.
Nó có xác suất khoảng 2% để thất bại. Nó thất bại khi chiều dài đầu vào thấp hơn 10.

Kết hợp với câu trả lời của LyricLy, điều này nhận được 34 byte:

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

05AB1E , 5 * 0,9 = 4,5 byte

Giải pháp làm việc

{TLΩi

Hãy thử trực tuyến!

Giải trình

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

Giải pháp có chứa lỗi

Cung cấp giải pháp sai 10% thời gian (độc lập với đầu vào).

{TLΩiR

Hãy thử trực tuyến!

Giải trình

Tương tự như giải pháp làm việc, ngoại trừ nó đảo ngược danh sách nếu số được chọn là đúng.

Thạch , 7 * (100% - 10%) = 6,3 byte

Ṣ¹⁵X:¤¡

Hãy thử trực tuyến!

Phiên bản lỗi:

ṢẊ⁵X:¤¡

Hãy thử trực tuyến!

Trong cả hai liên kết, có một khai thác thử nghiệm sẽ chạy mã 100 lần, mỗi lần với danh sách bạn đưa ra làm đối số và sau đó trả về kết quả.

Xác suất của mỗi chiều dài đầu vào là:

0.1 - 0.1/(length!)

Vì vậy, đối với chiều dài 1 có xác suất 0%, đối với chiều dài 2 5%, đối với chiều dài 3 8,83̅%, đối với chiều dài 4 9,583̅%, v.v. cho đến khi chiều dài có xác suất 10%.

Python 3, điểm 58 57 - 10% = 51.3

Lưu một byte nhờ vào ovs.

Phiên bản không có lỗi, 57 byte

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

Hãy thử trực tuyến!

Phiên bản lỗi, 57 byte

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

Hãy thử trực tuyến!

Tôi quyết định thử một giải pháp sử dụng tiền thưởng. Nó không đánh bại câu trả lời Python khác, nhưng tôi rất vui khi nghĩ về nó.

C, 71 * 0,9 = 63,9 byte

Không có lỗi:

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

Hãy thử trực tuyến!

Lỗi:

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

Hãy thử trực tuyến!

Groovy , 31 byte

Giải pháp lỗi:

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

Giải pháp làm việc:

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

Toán tử đăng ký Groovy ( getAtphương thức) trả về null cho danh sách nếu chỉ mục lớn hơn kích thước. Vì vậy, nếu có một yếu tố thứ chín, nó sẽ giữ nguyên như danh sách được sắp xếp, nhưng nếu không (1.99203187% cơ hội) thì nó sẽ bị đảo ngược. Tuy nhiên, sẽ luôn có một phần tử đầu tiên vì kích thước của danh sách luôn lớn hơn hoặc bằng 5. Vì vậy, số 0 trong a[0]có thể được hoán đổi với 1, 2, 3 hoặc 4.

Ngôn ngữ Wolfram (Mathicala) , 29 byte

Đây là 26,1 byte với tiền thưởng, nhưng tôi không hoàn toàn chắc chắn mình kiếm được tiền thưởng; trên đầu vào đã được sắp xếp, cả hai phiên bản luôn tạo đầu ra được sắp xếp.

Phiên bản không có lỗi (29 byte)

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

Hãy thử trực tuyến!

Phiên bản gây phiền nhiễu (30 byte)

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

Hãy thử trực tuyến!

PHP, 70 byte

Phiên bản không có lỗi, 70 byte

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

Hãy thử trực tuyến!

Phiên bản lỗi, 70 byte

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

Hãy thử trực tuyến!

Phiên bản lỗi sắp xếp theo thứ tự ngược 10% thời gian (dựa trên trình tạo số ngẫu nhiên).

Con trăn 2 , 26 byte

Lỗi:

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

Hãy thử trực tuyến!

Đầu ra bằng cách sửa đổi danh sách đầu vào . Chỉ sắp xếp danh sách nếu độ dài của nó ít nhất là 10. Phiên bản không có lỗi thay thế 9bằng0 để luôn luôn sắp xếp.

Đang làm việc:

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

Hãy thử trực tuyến!

Chúng ta có thể sửa đổi hàm để trả về danh sách với chi phí là 4 byte, với tổng số 30 byte:

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

Hãy thử trực tuyến!

25 byte với một số quy tắc:

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

Hãy thử trực tuyến!

Xuất ra một hàm theo nghĩa đen sắp xếp hoặc là danh tính, sử dụng id(0)như một nguồn ngẫu nhiên. Thay đổi >để >=sửa chữa, hoặc 0để ~0.

Husk , 6 byte

Phiên bản lỗi:

?OIV¦9

Hãy thử trực tuyến!

Phiên bản chính xác:

?OIVK9

Hãy thử trực tuyến!

Giải trình

Các chương trình này là hoàn toàn xác định. Trên thực tế, Husk hiện không có hỗ trợ nào cho các số ngẫu nhiên.

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

Tôi khẳng định rằng đầu ra của chương trình lỗi không được sắp xếp với xác suất từ ​​1% đến 2%. Suy ra bởi N = 251 số lượng giá trị có thể có của các phần tử. Xác suất danh sách ngẫu nhiên có độ dài L không chứa bội số của 9 là ((NK) / N) ^ L , trong đó K là số giá trị chia hết cho 9 (trong trường hợp của chúng tôi là K = 28 ). Tổng xác suất là trung bình của điều này trong 5 ≤ L ≤ 255 , khoảng 1,98%. Một số danh sách này là dương tính giả, vì chúng đã được sắp xếp. Xác suất của một danh sách ngẫu nhiên độ dài L được sắp xếp tối đa là ((N + N * (N-1) / 2) / N ^ 2) ^ L / 2⌋ : nếu chúng ta chia danh sách thành các đoạn có độ dài 2, mỗiPhải sắp xếp các khối ⌊L / 2⌋ . Tổng xác suất của một danh sách được sắp xếp được giới hạn bởi mức trung bình của mức trên cho 5 ≤ L ≤ 255 , khoảng 0,30%. Do đó, xác suất của hàm trả về một danh sách không được sắp xếp là từ 1,67% đến 1,98%.

Bash , 26 byte

Phiên bản chính xác

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

Hãy thử trực tuyến! hoặc kiểm tra xác suất .

Phiên bản lỗi

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

Hãy thử trực tuyến! hoặc kiểm tra xác suất .

Lấy đầu vào là số phân tách dòng mới. Sử dụng biến dựng sẵn RANDOM, luôn trả về một số ngẫu nhiên (giả) trong phạm vi 0 - 32767 . Sử dụng %20kết quả trong khoảng 5% tỷ lệ thất bại (cảm ơn @Titus đã làm rõ vấn đề với %10).

Tính ngẫu nhiên này có nghĩa là tỷ lệ thất bại độc lập với đầu vào, nhưng điều này đòi hỏi mảng đầu vào bao gồm ít nhất một số có nhiều hơn một chữ số, vì đầu ra thất bại được sắp xếp theo từ vựng.

Phiên bản thay thế, 27 byte

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

Phiên bản lỗi thay thế +bằng a %. Hãy thử trực tuyến hoặc thử nó .

Bình , điểm 8 * 0,9 = 7,2

Đoạn đầu tiên (chính xác):

h.uSNT.S

Hãy thử nó ở đây!

Đoạn mã thứ hai (lỗi một):

O.uSNT.S

Hãy thử nó ở đây!

Đã lưu hai byte (và 1,8 điểm) nhờ vào isaacg !

JavaScript (ES6), 24 byte

Phiên bản không có lỗi (ít nhất là cho các số nguyên trong phạm vi 0-2147483647, vì vậy mọi thứ trong phạm vi đã cho):

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

Phiên bản lỗi:

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

Phụ thuộc vào a) thuật toán sắp xếp của động cơ và b) danh sách đầu vào chứa hai giá trị sai thứ tự khác nhau 1. (Nếu xác suất của nó quá thấp thì 1có thể tăng lên, nhưng khi bạn nhận được với 8nó chỉ đơn giản là sẽ không sắp xếp bất cứ thứ gì trong phạm vi 5-255.)

PHP, 62 byte

lấy cảm hứng từ giải pháp Jo hè (và tôi chỉ nhận thấy: đó là cổng Justinsa của Justin Mariner ):

làm việc (sắp xếp tăng dần):

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

lỗi (khoảng 5% cơ hội sắp xếp giảm dần):

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

Chạy với -nr

Tự đề cao , 9 byte - 10% = 8.1

Giải pháp lỗi:

g0TUn?};_

Hãy thử trực tuyến!

Giải pháp làm việc:

g1TUn?};_

Hãy thử trực tuyến!

Mã lỗi thực hiện như sau:

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

Mã cố định chỉ đơn giản là thay đổi 0thành 1. Như random(1, 10)sẽ không bao giờ 0, câu lệnh if sẽ không bao giờ được thực thi.

MATL , 7 * 0,9 = 6,3 6 * 0,9 = 5,4 byte

Phiên bản lỗi:

Gr.9<?S

Hãy thử trực tuyến!

Giải trình:

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

Phiên bản không có lỗi:

Gr9<?S

Hãy thử trực tuyến!

Giải trình:

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 byte

Lỗi

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

Đang làm việc (xóa =)

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

Giả sử độ dài dòng là đồng đều trong phạm vi [5.255] khoảng 7% sẽ gây ra lỗi

Hãy thử trực tuyến!

J, 22,5 byte (25 byte - 10%)

với lỗi:

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

không có lỗi:

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

Hãy thử trực tuyến!

R , 30 * .9 = 27 byte

(lỗi)

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

Hãy thử trực tuyến!

(không phải lỗi)

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

Phiên bản lỗi sắp xếp trong decreasing=T10% thời gian, lấy mẫu từ phân phối thống nhất (0,1). Phiên bản không có lỗi luôn luôndecreasing=F

Röda , 42 byte - 10% = 37,8

Không có lỗi:

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

Lỗi:

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

Hãy thử trực tuyến!

Điều này sử dụng currentTimechức năng để tạo số ngẫu nhiên. Có vẻ như phân phối của họ thay đổi một chút giữa các máy. Tỷ lệ 20//19có thể được điều chỉnh để có kết quả khác nhau mà không bị phạt byte (trừ khi nó nhỏ hơn 99//98).

Octave , 36 * 0,9 = 32,4 byte

Phiên bản lỗi:

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

Hãy thử trực tuyến!

Phiên bản không có lỗi:

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

Hãy thử trực tuyến!

Điều này sắp xếp vectơ, sau đó dịch chuyển tất cả các số một sang phải nếu một số ngẫu nhiên nhỏ hơn 0,1.

Java 8, 45 34,2 ( 50 38 - 10%) byte

Phiên bản bình thường:

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

Giải trình:

Hãy thử nó ở đây.

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

Phiên bản lỗi ( 51 39 byte):

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

LD của 1: 1đã thêm.

Giải trình:

Hãy thử nó ở đây.

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

đầu vào x