Considera una sequenza unidimensionale di numeri all'interno di un intervallo fisso, ad es

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

Il grafico in costante aumento * ** è una linea che collega tutti i punti di questa sequenza da sinistra a destra e sale sempre verso l'alto o rimane in piano. Se necessario, la linea si avvolge dall'alto verso il basso e continua a salire da lì per incontrare il punto successivo.

L'obiettivo di questa sfida è quello di dividere la sequenza in diverse sottosequenze che non sono tutte in diminuzione, in modo che quando vengono tracciate insieme con un asse verticale limitato formeranno un grafico in costante aumento. Questo viene fatto aggiungendo un punto alla fine di una sottosequenza e all'inizio della sottosequenza successiva, in modo che l'angolo della linea che attraversa il limite superiore sia allineato con la linea che attraversa il limite inferiore e i due punti di attraversamento hanno le stesse coordinate orizzontali. L'esempio sopra darebbe il seguente output:

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

E il grafico corrispondente apparirà come segue: E con l'asse esteso per una visione migliore: L'output richiesto è un elenco di sottosequenze che formano le parti del grafico in costante aumento. Fare una trama non è richiesto ma ti farà guadagnare punti bonus;). L'output deve separare chiaramente le sottosequenze in qualche modo.

Gli appunti

• L'intervallo avrà sempre zero come limite sinistro (inclusivo) e il limite destro sarà un numero intero N.
• La sequenza non conterrà mai valori che non rientrano nell'intervallo.
• La prima sottosequenza non ha un punto aggiuntivo all'inizio.
• L'ultima sottosequenza non ha un punto aggiuntivo alla fine.
• Non è necessario fornire gli indici di partenza necessari per tracciare le sottosequenze.

Casi test

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]

punteggio

Questo è code-golf, vince il codice più breve in byte.

* Gergo non reale ** In realtà dovrebbe essere chiamato grafico mai decrescente, come ha sottolineato @ngm, ma sembra meno impressionante.

Gelatina , 20 byte

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

Provalo online!

Le successive sono divise per 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}}

Provalo online!

Modifica: il codice ora è una funzione e accetta input. (Grazie a Giuseppe, user202729 e JayCe per averlo tranquillamente sottolineato)
Modifica: -21 byte suggeriti da Giuseppe.
Modifica: -7 byte rimuovendo d=NULL;.

Python 2 , 60 byte

L'input è N, seguito da tutti i punti come singoli argomenti. Le successive nell'output sono separate da 0.5.

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

Provalo online!

Python 2 , 92 77 68 byte

Le successive sono separate da [...].

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

Provalo online!

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

Provalo online!

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

Provalo online! La risposta di Port of @ ovs in Python.

Haskell, 82 81 80 byte

Questa è una porta della mia risposta pulita .

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

Provalo online!

-1, -1 grazie a Laikoni

Pulito , 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)

Provalo online!

L'argomento dell'operatore foldrè un lambda con guardia; viene analizzato come:

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

L'ho portato su Haskell .

Pulito , 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]

Provalo online!

-1 byte grazie a 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

Provalo online! Porta della mia risposta pulita .

Alternativa, anche 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

Provalo online!

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)

Provalo online! Questo è un po 'più lungo dell'altra risposta JS, ma utilizza un approccio diverso.

Spiegazione ungolfed e semplificata

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, matrici separate da,,

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

Provalo online!

JavaScript (Node.js) , 50 byte, matrici separate da|

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

Provalo online!