พิจารณาลำดับของตัวเลขหนึ่งมิติภายในช่วงที่กำหนดเช่น

[1, 2, 4, 6, 8, 0, 2, 7, 3] in range [0, 10⟩

กราฟที่เพิ่มมากขึ้น * ** เป็นเส้นที่เชื่อมจุดทั้งหมดในลำดับนี้จากซ้ายไปขวาและขึ้นไปเรื่อย ๆ หรืออยู่ในระดับ หากจำเป็นบรรทัดนั้นจะพันจากบนลงล่างและขึ้นไปเรื่อย ๆ จากจุดนั้นไปยังจุดถัดไป

เป้าหมายของความท้าทายนี้คือการแบ่งลำดับในการเรียงลำดับที่แตกต่างกันซึ่งไม่ได้สร้างขึ้นทั้งหมดดังนั้นเมื่อวางแผนร่วมกับแกนแนวตั้งที่ จำกัด พวกเขาจะสร้างกราฟที่เพิ่มมากขึ้นเรื่อย ๆ สิ่งนี้ทำได้โดยการเพิ่มจุดหนึ่งไปยังจุดสิ้นสุดของการเรียงลำดับหนึ่งและการเริ่มต้นของการเรียงลำดับถัดไปเพื่อให้มุมของเส้นที่ตัดผ่านขอบเขตด้านบนจัดชิดกับเส้นที่ข้ามขอบเขตด้านล่างและจุดข้ามสองจุด มีพิกัดแนวนอนเดียวกัน ตัวอย่างข้างต้นจะให้ผลลัพธ์ต่อไปนี้:

[1, 2, 4, 6, 8, 10]
[-2, 0, 2, 7, 13]
[-3, 3]

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

หมายเหตุ

• ช่วงจะมีศูนย์เสมอเป็นขอบเขตด้านซ้าย (รวม) และขอบเขตด้านขวาจะเป็นจำนวนเต็ม N
• ลำดับจะไม่ประกอบด้วยค่าที่ไม่อยู่ในช่วง
• การเรียงลำดับแรกไม่มีจุดเพิ่มเติมที่จุดเริ่มต้น
• การเรียงลำดับสุดท้ายไม่มีจุดเพิ่มเติมในตอนท้าย
• ไม่จำเป็นต้องระบุดัชนีเริ่มต้นที่จะต้องมีการวางแผนองค์ประกอบ

กรณีทดสอบ

Input: [0, 2, 4, 6, 1, 3, 5, 0], 7
Output: [0, 2, 4, 6, 8], [-1, 1, 3, 5, 7], [-2, 0]
Input: [1, 1, 2, 3, 5, 8, 3, 1], 10
Output: [1, 1, 2, 3, 5, 8, 13],[-2, 3, 11],[-7, 1]
Input: [5, 4, 3, 2, 1], 10
Output: [5, 14],[-5, 4, 13],[-6, 3, 12],[-7, 2, 11],[-8, 1]
Input: [0, 1, 4, 9, 16, 15, 0], 17
Output: [0, 1, 4, 9, 16, 32], [-1, 15, 17], [-2, 0]

เกณฑ์การให้คะแนน

นี่คือโค้ดกอล์ฟซึ่งเป็นรหัสที่สั้นที่สุดในหน่วยไบต์

* ไม่ใช่ศัพท์แสงที่เกิดขึ้นจริง ** จริงๆแล้วควรเรียกกราฟที่ไม่มีการลดลงตามที่ @ngm ชี้ให้เห็น แต่ฟังดูน่าประทับใจน้อยกว่า

เยลลี่ , 20 ไบต์

⁹;+⁴,N¤j.x>ṭḷ
çƝF;Ṫ{

ลองออนไลน์!

subsequences จะ splitted 0.5โดย

R , 179 158 151 bytes

function(s,m){p=1;t=c(which(diff(s)<0),length(s));for(i in t){d=c(s[p]-m,s[(p+1):i],s[i+1]+m);if(p==1)d[1]=s[1];if(p==t[-1])d=head(d,-1);print(d);p=i}}

ลองออนไลน์!

แก้ไข:ตอนนี้โค้ดเป็นฟังก์ชั่นและรับอินพุต (ขอบคุณ Giuseppe, user202729 และ JayCe สำหรับการชี้อย่างใจเย็น)
แก้ไข: -21 ไบต์แนะนำโดย Giuseppe
แก้ไข: -7 d=NULL;ไบต์โดยการเอา

Python 2 , 60 ไบต์

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

f=lambda N,k,*l:(k,)+(l and(l[0]+N,.5,k-N)*(l[0]<k)+f(N,*l))

ลองออนไลน์!

Python 2 , 92 77 68 ไบต์

subsequences [...]จะถูกคั่นด้วย

l,N=input();r=[];k=0
for a in l:r+=[a+N,r,k-N]*(a<k)+[a];k=a
print r

ลองออนไลน์!

ทำความสะอาด , 279 269 258 ไบต์

import StdEnv
s=snd o unzip
$[]=[]
$l#(a,b)=span(uncurry(<))(zip2[-1:l]l)
=[s a: $(s b)]
?l n#[h:t]= $l
=[h:if(t>[])(?(map((+)n)(flatten t))n)t]
@l n#l= ?l n
=[[e-i*n\\e<-k]\\k<-[a++b++c\\a<-[[]:map(\u=[last u])l]&b<-l&c<-tl(map(\u=[hd u])l)++[[]]]&i<-[0..]]

ลองออนไลน์!

JavaScript (Node.js) , 104 82 ไบต์

n=>a=>a.map((e,i)=>e>a[s.push(e),++i]&&s.push(a[r.push(s=[e-n]),i]+n),r=[s=[]])&&r

ลองออนไลน์! คำตอบ Python ของพอร์ตของ @ ovs

Haskell, 82 81 80 ไบต์

นี่คือพอร์ตของคำตอบที่สะอาดของฉัน

r!n|let f x(r@(a:_):s)|x>a=[x,n+a]:(x-n:r):s|y<-x:r=y:s=foldr f[[last r]]$init r

ลองออนไลน์!

-1, -1 ต้องขอบคุณLaikoni

ทำความสะอาด , 92 ไบต์

import StdEnv
@r n=foldr(\x[r=:[a:_]:s]|x>a=[[x,n+a]:[x-n:r]:s]=[[x:r]:s])[[last r]](init r)

ลองออนไลน์!

อาร์กิวเมนต์ตัวดำเนินการfoldrเป็นแลมบ์ดาที่มียาม; มันแยกเป็น:

\x [r=:[a:_]:s]
    | x > a     = [[x,n+a]:[x-n:r]:s]
    | otherwise = [[x:run]:s]

ฉันรังเพลิงนี้จะ Haskell

ทำความสะอาด , 110 109 104 100 97 ไบต์

import StdEnv
@[x:r]n=let$s=:[x:r]a|x<last a=[a++[n+x]: $s[last a-n]]= $r(a++[x]);$_ a=[a]in$r[x]

ลองออนไลน์!

-1 ไบต์ขอบคุณKeelan

Haskell , 82 ไบต์

(x:r)#n|let b@(a:_)%s@(x:r)|x<a=(n+x:b):[a-n]%s|c<-x:b=c%r;a%_=[a]=reverse<$>[x]%r

ลองออนไลน์! ท่าเรือของฉันคำตอบที่สะอาด

ทางเลือก 82 ไบต์เช่นกัน

(x:r)#n|let a%s@(x:r)|x<last a=(a++[n+x]):[last a-n]%s|c<-a++[x]=c%r;a%_=[a]=[x]%r

ลองออนไลน์!

JavaScript (Node.js)ขนาด 98 ไบต์

a=>m=>(r=[],b=[],a.map((e,i)=>e<a[--i]?(b[p](m+e),r[p](b),b=[a[i]-m,e]):b[p='push'](e)),r[p](b),r)

ลองออนไลน์! นี่ค่อนข้างยาวกว่าคำตอบ JS อื่น ๆ เล็กน้อย แต่ใช้วิธีการอื่น

คำอธิบายที่ไม่สวยงามและง่ายขึ้น

g=(a,m)=>{
    // r is the final array of arrays to return.
    // b is the current subset of only ascending numbers.
    r=[],b=[];

    a.map((e,i)=>{
        if(e<a[i-1]){
            // if the current value is less than the previous one,
            // then we're descending, so start a new array b.
            // add the proper value to b to match slopes with the next
            b.push(m+e);
            // add r to b, and restart b with the starter value and the current value in a
            r.push(b);
            b=[a[i-1]-m,e];
        } else{
            // otherwise, we're ascending, so just addd to to b.
            b.push(e);
        }
    });
    r.push(b); // add the final b to r, and return r
    return r;
}

JavaScript (Node.js) , 48 ไบต์, อาร์เรย์คั่นด้วย,,

s=>n=>s.map(r=t=>(t<r?[t+n,,r-n,,]:``)+(r=t))+``

ลองออนไลน์!

JavaScript (Node.js) , 50 ไบต์, อาร์เรย์คั่นด้วย|

s=>n=>s.map(r=t=>(t<r?t+n+`|${r-n},`:``)+(r=t))+``

ลองออนไลน์!