考虑固定范围内的一维数字序列，即

[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所指出的，实际上应称为Ever Non-Decreasing Graph，但这听起来不那么令人印象深刻。

果冻，20字节

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

在线尝试！

子序列被分割0.5。

[R ， 179个 158 151字节

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冷静地指出了这一点）
编辑： Giuseppe建议的-21个字节。
编辑：删除-7个字节d=NULL;。

Python 2，60个字节

输入为N，后跟所有点作为单独的参数。输出中的子序列用分隔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字节

子序列用分隔[...]。

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

在线尝试！@ovs的Python答案的端口。

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是带有警戒的lambda；它被解析为：

\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))+``

在线尝试！