Sabit bir aralıktaki tek boyutlu bir sayı dizisini göz önünde bulundurun, örn.

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

Her Zaman-Artan Grafik * **, bu dizideki tüm noktaları soldan sağa bağlayan ve her zaman yukarı giden veya düz kalan bir çizgidir. Gerekirse, çizgi yukarıdan aşağıya doğru sarılır ve bir sonraki noktaya ulaşmak için oradan yukarı doğru devam eder.

Bu zorluğun amacı, diziyi tamamen azalan farklı alt dizilere bölmektir, böylelikle sınırlı bir dikey eksenle birlikte çizildiğinde Sürekli Artan Bir Grafik oluşturacaklardır. Bu, bir dizinin sonuna ve bir sonraki dizinin başına bir nokta eklenerek yapılır, böylece üst sınırı geçen çizginin açısı, alt sınırı geçen çizgiyle ve iki geçiş noktasıyla aynı hizada olur. aynı yatay koordinatlara sahip. Yukarıdaki örnek aşağıdaki çıktıyı verir:

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

Ve karşılık gelen grafik aşağıdaki gibi görünecektir: Eksen daha iyi bir görünüm için uzatılmış olarak: Gerekli çıktı, Sürekli Artan Grafiğin parçalarını oluşturan bir alt listesidir. Bir arsa yapmak gerekli değildir, ancak size bonus puan kazandırır;). Çıktı, ekleri bir şekilde açıkça ayırmalıdır.

notlar

• Aralık, sol (dahil) sınır olarak sıfır olacaktır ve sağ sınır, bazı tam sayı N olacaktır.
• Dizi asla aralık içinde olmayan değerler içermez.
• İlk sıranın başlangıçta ek bir noktası yoktur.
• Son alt dizinin sonunda ek bir noktaya sahip değil.
• Sıraları çizmek için gerekli olan başlangıç ​​endekslerini sağlamanız gerekmez.

Test durumları

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]

puanlama

Bu kod golf, bayt cinsinden en kısa kod kazanır.

* Asıl jargon değil ** Aslında, @ ngm'nin işaret ettiği gibi Asla Düşmeyen Grafik olarak adlandırılmalıdır, ancak bu daha az etkileyici görünmektedir.

Jöle , 20 bayt

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

Çevrimiçi deneyin!

Alıntılar, bölünür 0.5.

R , 179 158 151 bayt

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

Çevrimiçi deneyin!

Düzenleme: Kod şimdi bir fonksiyondur ve girdi alır. (Giuseppe'ye teşekkürler, user202729 ve JayCe sakince şunu işaret ediyorlardı)
Düzenleme: -21 Giuseppe tarafından önerilen.
Düzenleyin: -7 bayt kaldırarak d=NULL;.

Python 2 bayt

Girdi N, ardından tüm noktalar bireysel argümanlar olarak. Çıktıdaki alt sıralar ile ayrılır 0.5.

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

Çevrimiçi deneyin!

Python 2 , 92 77 68 bayt

Alt diziler ile ayrılır [...].

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

Çevrimiçi deneyin!

Temiz , 279 269 258 bayt

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

Çevrimiçi deneyin!

JavaScript (Node.js) , 104 82 bayt

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

Çevrimiçi deneyin! @ Ovs Limanı'nın Python cevabı.

Haskell, 82 81 80 bayt

Bu benim Temiz cevabımın bir limanı .

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

Çevrimiçi deneyin!

Laikoni sayesinde -1, -1

Temiz , 92 bayt

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)

Çevrimiçi deneyin!

Operatör argümanı foldr, korumalı bir lambdadır; şöyle ayrıştırılır:

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

Bunu Haskell'e taşıdım .

Temiz , 110 109 104 100 97 bayt

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]

Çevrimiçi deneyin!

Keelan sayesinde -1 bayt

Haskell , 82 bayt

(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

Çevrimiçi deneyin! Temiz cevabımın limanı .

Alternatif, ayrıca 82 bayt

(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

Çevrimiçi deneyin!

JavaScript (Node.js) , 98 bayt

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)

Çevrimiçi deneyin!Bu, diğer JS cevaplarından biraz daha uzun, ama farklı bir yaklaşım kullanıyor.

Ungolfed ve basitleştirilmiş açıklama

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 bayt, dizilerle ayrılmış,,

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

Çevrimiçi deneyin!

JavaScript (Node.js) , 50 bayt, dizilerle ayrılmış|

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

Çevrimiçi deneyin!