Розглянемо одновимірну послідовність чисел у фіксованому діапазоні, тобто

[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;Ṫ{

Спробуйте в Інтернеті!

Наступності розділені на 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}}

Спробуйте в Інтернеті!

Редагувати: код тепер є функцією і приймає введення. (Спасибі Джузеппе, user202729 та JayCe за те, що вони спокійно вказали на це)
Редагувати: -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

Спробуйте в Інтернеті! Порт відповіді Python @ ovs.

Хаскелл, 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 завдяки Лайконі

Чисто , 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

Хаскелл , 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))+``

Спробуйте в Інтернеті!