สเปค

ความท้าทายนี้ง่ายต่อการระบุ: อินพุตของคุณเป็นอาร์เรย์ที่ไม่ว่างของจำนวนเต็มที่ไม่ติดลบและงานของคุณคือแบ่งพาร์ติชันให้เป็นองค์ประกอบที่เพิ่มขึ้นน้อยที่สุดเท่าที่จะทำได้ อย่างเป็นทางการมากขึ้นถ้าอาร์เรย์อินAพุทคือเอาท์พุทเป็นอาร์เรย์ของอาร์เรย์Bดังกล่าว:

• แต่ละอาร์เรย์ในBรูปแบบพาร์ติชันของการเรียงAกัน (ไม่จำเป็นต้องต่อเนื่องกัน) Inductively นี่หมายความว่าอย่างใดอย่างหนึ่งBเป็นอาร์เรย์เดี่ยวที่มีAหรือองค์ประกอบแรกของBเป็นลำดับของAและส่วนที่เหลือเป็นรูปแบบพาร์ทิชันที่Aมีการลบออกเรียงลำดับ
• ทุกแถวในBนั้น (ไม่จำเป็นต้องเพิ่ม)
• จำนวนของอาร์เรย์Bมีค่าน้อยที่สุด

ทั้งอินพุทและเอาท์พุทสามารถใช้รูปแบบอาเรย์ดั้งเดิมของภาษาของคุณ โปรดทราบว่าอาจมีผลลัพธ์ที่ถูกต้องหลายอย่าง

ตัวอย่าง

A = [1,2,1,2,5,4,7,1]พิจารณาอาร์เรย์การป้อนข้อมูล B = [[1],[1,2,4,7],[1,2,5]]การส่งออกที่เป็นไปได้คือ เงื่อนไขของพาร์ติชันนั้นเห็นได้จากแผนภาพนี้:

A    1 2 1 2 5 4 7 1
B[0]               1
B[1] 1 2       4 7
B[2]     1 2 5

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

กฎและการให้คะแนน

คุณสามารถเขียนฟังก์ชั่นหรือโปรแกรมเต็มรูปแบบ จำนวนไบต์ต่ำสุดที่ชนะและช่องโหว่มาตรฐานไม่ได้รับอนุญาต ไม่มีเวลาผูกมัด แต่คุณควรทำการแก้ปัญหาของคุณในทุกกรณีทดสอบก่อนที่จะส่ง

กรณีทดสอบ

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

[0] -> [[0]]
[3,5,8] -> [[3,5,8]]
[2,2,2,2] -> [[2,2,2,2]]
[1154,1012,976,845] -> [[845],[976],[1012],[1154]]
[6,32,1,2,34,8] -> [[1,2,8],[6,32,34]]
[1,12,1,12,1,13] -> [[1,1,1,13],[12,12]]
[6,4,6,13,18,0,3] -> [[0,3],[4,6,13,18],[6]]
[1,2,3,2,3,4,7,1] -> [[1,1],[2,2,3,4,7],[3]]
[0,9,2,7,4,5,6,3,8] -> [[0,2,3,8],[4,5,6],[7],[9]]
[7,1,17,15,17,2,15,1,6] -> [[1,1,6],[2,15],[7,15,17],[17]]
[4,12,2,10,15,2,2,19,16,12] -> [[2,2,2,12],[4,10,15,16],[12,19]]
[10,13,9,2,11,1,10,17,19,1] -> [[1,1],[2,10,17,19],[9,11],[10,13]]
[3,7,3,8,14,16,19,15,16,2] -> [[2],[3,3,8,14,15,16],[7,16,19]]
[15,5,13,13,15,9,4,2,2,17] -> [[2,2,17],[4],[5,9],[13,13,15],[15]]

Haskell, 54 ไบต์

n#[]=[[n]]
n#(l:c)|[n]<=l=(n:l):c|1<2=l:n#c
foldr(#)[]

ตัวอย่างการใช้: foldr(#)[] [4,12,2,10,15,2,2,19,16,12]->[[2,2,2,12],[4,10,15,16],[12,19]]

มันทำงานอย่างไร: ผ่านรายการอินพุตเริ่มต้นที่ปลายด้านขวา สร้างรายการเอาต์พุต (รายการ) โดย prepending องค์ประกอบปัจจุบันnไปยังรายการย่อยครั้งแรกlที่เป็นน้อยกว่าหรือเท่ากับหัวของn lถ้าไม่มีให้สร้างรายการซิงเกิลใหม่nที่ท้ายรายการเอาท์พุท

Pyth, 20 ไบต์

fTu&ahfSI+THGHGQm[)Q

ลองใช้ออนไลน์: การสาธิตหรือชุดทดสอบ

วิธีการโลภ ฉันสร้างlen(input)รายการว่างเปล่า จากนั้นฉันก็วนซ้ำแต่ละตัวเลขในรายการinputเลือกแรกซึ่งยังคงเรียงลำดับหลังจากผนวกหมายเลข

คำอธิบาย:

fTu&ahfSI+THGHGQm[)Q   implicit: Q = input list
                m[)Q   create a list of empty lists and assign to G
  u            Q       iterate over all numbers H in input:
      f     G             filter for lists T in G, which satisfy:
         +TH                 create a new list out of T and H
       SI                    and check if it is sorted
     h                    take the first such list T
    a        H            and append H
   &          G           logical and with G (so that u doesn't overwrite G)
fT                     remove all empty lists