ข้อมูลของคุณเป็นรายการ / ลำดับ / เวกเตอร์ / อาร์เรย์ของจำนวนเต็มบวก 5-255 ไม่จำเป็นต้องซ้ำกัน คุณอาจจะสมมติว่ารูปแบบการป้อนข้อมูลใดที่เหมาะสมที่สุดและแต่ละจำนวนเต็ม (รวมถึงปริมาณของจำนวนเต็ม) จะถูกเลือกอย่างสม่ำเสมอโดยการสุ่มจากช่วงที่ 5-255

เป้าหมายคือการส่งออกรายการเดียวกันในรูปแบบเดียวกัน (หรือเทียบเท่า) แต่เรียงลำดับเป็นการเพิ่ม (ไม่มีการลบ) ลำดับ แบบฝึกหัดทั่วไปในการเรียนรู้ภาษา ส่งไปยังรวมถึง:

1. คำตอบที่ทำงานได้อย่างถูกต้องและบรรลุเป้าหมาย และ

2. คำตอบที่สองซึ่งมีข้อผิดพลาดที่น่ารำคาญ ระหว่าง 1% ถึง 10% ของเวลาเอาต์พุตต้องเป็นรายการในรูปแบบที่ถูกต้องและมีองค์ประกอบที่ถูกต้อง แต่ในลำดับที่ไม่ถูกต้อง (ลำดับใด ๆ ยกเว้นเรียงอย่างถูกต้อง) เวลาที่เหลือโปรแกรมจะต้องทำงานอย่างถูกต้องและบรรลุเป้าหมาย

คำตอบทั้งสองจะต้องมีระยะทางหนึ่งLevenshtein ; นั่นคือเราสามารถรับหนึ่งจากอื่น ๆ โดยการลบหนึ่งไบต์หรือเพิ่มหนึ่งไบต์หรือเปลี่ยนหนึ่งไบต์

การให้คะแนนตามปกติในการเล่นกอล์ฟ (ขึ้นอยู่กับคำตอบสั้น ๆ ของคุณทั้งสอง) โดยห้ามช่องโหว่ตามปกติ

โบนัส 10% (ลดลงเป็นคะแนน) หากบั๊กที่น่ารำคาญนั้นเป็นอิสระต่อกันเช่นการใช้อินพุตเดียวกันอีกครั้งจะไม่สร้างข้อผิดพลาดขึ้นอีก (ยกเว้นระหว่าง 1% ถึง 10% ของเวลา)

งูหลาม 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:¤¡

ลองออนไลน์!

รุ่น Buggy:

ṢẊ⁵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

บันทึกเป็นไบต์ขอบคุณ ovs

รุ่นที่ไม่มีข้อผิดพลาด 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

ภาษา Wolfram (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);

ลองออนไลน์!

รุ่น bugged เรียงลำดับย้อนกลับ 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

Husk , 6 ไบต์

รุ่น Buggy:

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

ฉันอ้างว่าผลลัพธ์ของโปรแกรม buggy ไม่ได้ถูกจัดเรียงด้วยความน่าจะเป็นระหว่าง 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 sorted ความน่าจะเป็นรวมของรายการที่เรียงลำดับถูก จำกัด โดยค่าเฉลี่ยของด้านบนสำหรับ5 ≤ L ≤ 255ซึ่งมีค่าประมาณ 0.30% ดังนั้นความน่าจะเป็นของฟังก์ชันที่ส่งคืนรายการที่ไม่เรียงลำดับอยู่ระหว่าง 1.67% ถึง 1.98%

Bash , 26 ไบต์

รุ่นที่ถูกต้อง

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

ลองออนไลน์! หรือตรวจสอบความน่าจะเป็น

เวอร์ชันที่เข้มงวด

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

ลองออนไลน์! หรือตรวจสอบความน่าจะเป็น

รับอินพุตเป็นตัวเลขที่คั่นด้วยบรรทัดใหม่ ใช้ตัวแปร builtin RANDOMซึ่งจะส่งกลับตัวเลขสุ่ม (หลอก) ในช่วง 0 - 32767เสมอ การใช้%20ผลลัพธ์มีอัตราความล้มเหลวประมาณ 5% (ขอบคุณ @Titus สำหรับการชี้แจงปัญหาด้วย%10)

การสุ่มนี้หมายถึงอัตราความล้มเหลวเป็นอิสระจากอินพุต แต่สิ่งนี้ต้องการให้อาร์เรย์อินพุตมีตัวเลขอย่างน้อยหนึ่งตัวที่มีมากกว่าหนึ่งหลักเพราะเอาต์พุตความล้มเหลวถูกจัดเรียงตามพจนานุกรม

รุ่นสำรอง 27 ไบต์

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

รุ่น Bugged แทนที่ด้วย+ ลองมันออนไลน์หรือลอง Bugged%

Pyth , คะแนน 8 * 0.9 = 7.2

ตัวอย่างแรก (ถูกต้องหนึ่งอัน):

h.uSNT.S

ลองที่นี่!

ตัวอย่างที่สอง (bugged อันหนึ่ง):

O.uSNT.S

ลองที่นี่!

บันทึกสองไบต์ (และ 1.8 คะแนน) ขอบคุณisaacg !

JavaScript (ES6), 24 ไบต์

รุ่นที่ไม่มีข้อผิดพลาด (อย่างน้อยสำหรับจำนวนเต็มในช่วง 0-2147483647 ดังนั้นทุกอย่างในช่วงที่กำหนด):

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

รุ่น Buggy:

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

ขึ้นอยู่กับ a) อัลกอริธึมการเรียงลำดับของเครื่องยนต์และ b) รายการอินพุตที่มีค่าสองค่าในลำดับที่ไม่ถูกต้องที่แตกต่างกัน 1 (หากความน่าจะเป็นที่นั้นต่ำเกินไปก็1สามารถเพิ่มได้ แต่ตามเวลาที่คุณได้รับ ไป8มันก็จะไม่ได้เรียงลำดับอะไรในช่วง5-255.)

PHP, 62 ไบต์

แรงบันดาลใจจากวิธีการแก้ปัญหาของ Jo (และฉันเพิ่งสังเกตเห็น: มันเป็นพอร์ตของJustin Mariner's ):

ทำงาน (เรียงลำดับจากน้อยไปมาก):

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

ลองออนไลน์!

โค้ดที่ bugged ทำดังต่อไปนี้:

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 ไบต์

รุ่น Buggy:

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)

รุ่น buggy เรียงลำดับในdecreasing=T10% ของเวลาสุ่มตัวอย่างจากการแจกแจงแบบสม่ำเสมอ (0,1) รุ่นที่ไม่สามารถเปิดได้เสมอdecreasing=F

Röda , 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 ไบต์

รุ่น Buggy:

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

อินพุต x