고정 된 범위 내에서 숫자의 1 차원 시퀀스를 고려하십시오.

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

해당 그래프는 다음과 같이 표시됩니다. 더 나은보기를 위해 축을 확장 한 경우 : 필요한 출력은 계속 증가하는 그래프의 일부를 형성하는 하위 시퀀스 목록입니다. 줄거리를 만들 필요는 없지만 보너스 포인트가 적립됩니다.). 결과는 어떤 식 으로든 하위 시퀀스를 명확하게 분리해야합니다.

노트

• 범위는 항상 왼쪽 (포함) 경계로 0이되고 오른쪽 경계는 정수 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}}

온라인으로 사용해보십시오!

편집 : 코드는 이제 기능이며 입력됩니다. (Giuseppe, user202729 및 JayCe에게 차분하게 지적 해 주셔서 감사합니다)
편집 : Giuseppe가 제안한 -21 바이트.
편집 하여 -7 바이트를 제거하십시오 d=NULL;.

파이썬 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))

온라인으로 사용해보십시오!

파이썬 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..]]

온라인으로 사용해보십시오!

자바 스크립트 (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 답변 포트.

하스켈, 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

온라인으로 사용해보십시오!

Laikoni 덕분에 -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]

나는 이것을 하스켈 로 포팅 했다 .

면도 , 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]

온라인으로 사용해보십시오!

Keelan 덕분에 -1 바이트

하스켈 , 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

온라인으로 사용해보십시오!

자바 스크립트 (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))+``

온라인으로 사용해보십시오!