Xem xét một chuỗi số một chiều trong một phạm vi cố định, nghĩa là

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

Biểu đồ tăng dần * ** là một đường kết nối tất cả các điểm trong chuỗi này từ trái sang phải và luôn đi lên hoặc duy trì mức. Nếu cần thiết, dòng kết thúc từ trên xuống dưới và tiếp tục đi lên từ đó để đáp ứng điểm tiếp theo.

Mục tiêu của thử thách này là phân chia chuỗi theo các chuỗi khác nhau, tất cả đều không tăng, do đó, khi được vẽ cùng với trục dọc hạn chế, chúng sẽ tạo thành một Đồ thị tăng dần. Điều này được thực hiện bằng cách thêm một điểm vào cuối của một chuỗi con và bắt đầu một điểm tiếp theo, sao cho góc của đường thẳng vượt qua ranh giới trên cùng thẳng hàng với đường thẳng vượt qua ranh giới dưới cùng và hai điểm giao nhau có cùng tọa độ ngang. Ví dụ trên sẽ cho đầu ra sau:

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

Và biểu đồ tương ứng sẽ như sau: Và với trục được mở rộng để có cái nhìn tốt hơn: Đầu ra bắt buộc là một danh sách các chuỗi con tạo thành các phần của Biểu đồ tăng dần. Tạo một cốt truyện là không bắt buộc nhưng sẽ kiếm được điểm thưởng cho bạn;). Đầu ra phải phân tách rõ ràng các phần sau theo một cách nào đó.

Ghi chú

• Phạm vi sẽ luôn có 0 là ranh giới bên trái (bao gồm) và ranh giới bên phải sẽ là một số nguyên N.
• Chuỗi sẽ không bao giờ chứa các giá trị không nằm trong phạm vi.
• Phần đầu tiên không có điểm bổ sung lúc đầu.
• Phần cuối cùng không có điểm bổ sung ở cuối.
• Không bắt buộc phải cung cấp các chỉ số bắt đầu sẽ được yêu cầu để vẽ các chuỗi con.

Các trường hợp thử nghiệm

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]

Chấm điểm

Đây là code-golf, mã ngắn nhất tính bằng byte thắng.

* Không phải biệt ngữ thực tế ** Thực tế nên được gọi là Đồ thị không giảm, như @ngm đã chỉ ra, nhưng điều đó nghe có vẻ ít ấn tượng hơn.

Thạch , 20 byte

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

Hãy thử trực tuyến!

Hậu quả được chia tách bởi 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}}

Hãy thử trực tuyến!

Chỉnh sửa: Mã bây giờ là một chức năng và nhận đầu vào. (Cảm ơn Giuseppe, user202729 và JayCe đã bình tĩnh chỉ ra điều đó)
Chỉnh sửa: -21 byte được đề xuất bởi Giuseppe.
Chỉnh sửa: -7 byte bằng cách xóa d=NULL;.

Python 2 , 60 byte

Đầu vào là N, theo sau là tất cả các điểm dưới dạng đối số riêng lẻ. Các kết quả trong đầu ra được phân tách bằng 0.5.

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

Hãy thử trực tuyến!

Python 2 , 92 77 68 byte

Hậu quả được ngăn cách bởi [...].

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

Hãy thử trực tuyến!

Sạch , 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..]]

Hãy thử trực tuyến!

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

Hãy thử trực tuyến! Câu trả lời Python của @ ovs.

Haskell, 82 81 80 byte

Đây là một cổng của câu trả lời sạch của tôi .

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

Hãy thử trực tuyến!

-1, -1 nhờ Laikoni

Sạch , 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)

Hãy thử trực tuyến!

Đối số toán tử foldrlà lambda có bảo vệ; nó được phân tích thành:

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

Tôi chuyển cái này cho Haskell .

Sạch , 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]

Hãy thử trực tuyến!

-1 byte nhờ 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

Hãy thử trực tuyến! Cổng câu trả lời sạch của tôi .

Thay thế, cũng 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

Hãy thử trực tuyến!

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)

Hãy thử trực tuyến! Câu hỏi này dài hơn một chút so với câu trả lời JS khác, nhưng nó sử dụng một cách tiếp cận khác.

Giải thích đơn giản và đơn giản

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, mảng được phân tách bằng,,

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

Hãy thử trực tuyến!

JavaScript (Node.js) , 50 byte, mảng được phân tách bằng|

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

Hãy thử trực tuyến!