Pertimbangkan urutan angka satu dimensi dalam rentang tetap, yaitu

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

Grafik Yang Terus Meningkat * ** adalah garis yang menghubungkan semua titik dalam urutan ini dari kiri ke kanan, dan selalu naik atau tetap di atas level. Jika perlu, garis membungkus dari atas ke bawah dan terus naik dari sana untuk memenuhi titik berikutnya.

Tujuan dari tantangan ini adalah untuk membagi urutan dalam urutan yang berbeda yang semuanya tidak bertambah, sehingga ketika diplot bersama dengan sumbu vertikal terbatas mereka akan membentuk Grafik yang Terus Meningkat. Hal ini dilakukan dengan menambahkan titik ke ujung satu urutan dan ke awal urutan berikutnya, sehingga sudut garis yang melintasi batas atas sejajar dengan garis yang melintasi batas bawah, dan dua titik persimpangan memiliki koordinat horizontal yang sama. Contoh di atas akan memberikan output berikut:

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

Dan grafik yang sesuai akan terlihat sebagai berikut: Dan dengan sumbu yang diperluas untuk tampilan yang lebih baik: Output yang diperlukan adalah daftar dari bagian selanjutnya yang membentuk bagian-bagian dari Grafik yang Terus Meningkat. Membuat plot tidak diperlukan tetapi akan memberi Anda poin bonus;). Keluaran harus dengan jelas memisahkan urutan dengan beberapa cara.

Catatan

• Rentang akan selalu memiliki nol sebagai batas kiri (inklusif), dan batas kanan akan berupa bilangan bulat N.
• Urutan tidak akan pernah berisi nilai yang tidak berada dalam rentang.
• Urutan pertama tidak memiliki titik tambahan di awal.
• Urutan terakhir tidak memiliki titik tambahan di akhir.
• Tidak diperlukan untuk memberikan indeks awal yang akan diperlukan untuk merencanakan selanjutnya.

Uji kasus

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]

Mencetak gol

Ini adalah kode-golf, kode terpendek dalam byte yang menang.

* Bukan jargon aktual ** Sebenarnya harus disebut Ever Non-Decreasing Graph, seperti yang ditunjukkan @ngm, tapi itu terdengar kurang mengesankan.

Jelly , 20 byte

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

Cobalah online!

Selanjutnya dipecah oleh 0.5.

R , 179 158 151 byte

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}}

Cobalah online!

Sunting: Kode sekarang berfungsi dan menerima input. (Terima kasih kepada Giuseppe, user202729 dan JayCe karena telah menunjukkan hal itu dengan tenang)
Edit: -21 byte yang disarankan oleh Giuseppe.
Edit: -7 byte dengan menghapus d=NULL;.

Python 2 , 60 byte

Input adalah N, diikuti oleh semua titik sebagai argumen individual. Selanjutnya dalam output dipisahkan oleh 0.5.

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

Cobalah online!

Python 2 , 92 77 68 byte

Selanjutnya dipisahkan oleh [...].

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

Cobalah online!

Bersih , 279 269 258 byte

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

Cobalah online!

JavaScript (Node.js) , 104 82 byte

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

Cobalah online! Port jawaban Python @ ovs.

Haskell, 82 81 80 byte

Ini adalah port jawaban Bersih saya .

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

Cobalah online!

-1, -1 terima kasih kepada Laikoni

Bersihkan , 92 byte

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)

Cobalah online!

Argumen operator untuk foldradalah lambda dengan penjaga; itu diurai sebagai:

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

Saya mengirim ini ke Haskell .

Bersih , 110 109 104 100 97 byte

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]

Cobalah online!

-1 byte terima kasih kepada Keelan

Haskell , 82 byte

(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

Cobalah online! Port jawaban Bersih saya .

Alternatif, juga 82 byte

(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

Cobalah online!

JavaScript (Node.js) , 98 byte

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)

Cobalah online! Ini sedikit lebih lama daripada jawaban JS lainnya, tetapi menggunakan pendekatan yang berbeda.

Penjelasan yang tidak disatukan dan disederhanakan

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 byte, array dipisahkan oleh,,

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

Cobalah online!

JavaScript (Node.js) , 50 byte, array dipisahkan oleh|

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

Cobalah online!