Grafik Yang Terus Meningkat

23

Pertimbangkan urutan angka satu dimensi dalam rentang tetap, yaitu

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

Grafik Yang Terus Meningkat * ** adalah garis yang menghubungkan semua titik dalam urutan ini dari kiri ke kanan, dan selalu naik atau tetap di atas level. Jika perlu, garis membungkus dari atas ke bawah dan terus naik dari sana untuk memenuhi titik berikutnya.

Tujuan dari tantangan ini adalah untuk membagi urutan dalam urutan yang berbeda yang semuanya tidak bertambah, sehingga ketika diplot bersama dengan sumbu vertikal terbatas mereka akan membentuk Grafik yang Terus Meningkat. Hal ini dilakukan dengan menambahkan titik ke ujung satu urutan dan ke awal urutan berikutnya, sehingga sudut garis yang melintasi batas atas sejajar dengan garis yang melintasi batas bawah, dan dua titik persimpangan memiliki koordinat horizontal yang sama. Contoh di atas akan memberikan output berikut:

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

Dan grafik yang sesuai akan terlihat sebagai berikut: Grafik yang Terus Meningkat yang seharusnya disebut Grafik Tidak Pernah Naik Dan dengan sumbu yang diperluas untuk tampilan yang lebih baik: Grafik yang Terus Meningkat yang seharusnya disebut Grafik Yang Tidak Pernah Meningkat dengan sumbu vertikal yang diperluas. Output yang diperlukan adalah daftar dari bagian selanjutnya yang membentuk bagian-bagian dari Grafik yang Terus Meningkat. Membuat plot tidak diperlukan tetapi akan memberi Anda poin bonus;). Keluaran harus dengan jelas memisahkan urutan dengan beberapa cara.

Catatan

  • Rentang akan selalu memiliki nol sebagai batas kiri (inklusif), dan batas kanan akan berupa bilangan bulat N.
  • Urutan tidak akan pernah berisi nilai yang tidak berada dalam rentang.
  • Urutan pertama tidak memiliki titik tambahan di awal.
  • Urutan terakhir tidak memiliki titik tambahan di akhir.
  • Tidak diperlukan untuk memberikan indeks awal yang akan diperlukan untuk merencanakan selanjutnya.

Uji kasus

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]

Mencetak gol

Ini adalah kode-golf, kode terpendek dalam byte yang menang.

* Bukan jargon aktual ** Sebenarnya harus disebut Ever Non-Decreasing Graph, seperti yang ditunjukkan @ngm, tapi itu terdengar kurang mengesankan.

RvdV
sumber
7
Selamat datang di PPCG! Tantangan pertama yang bagus!
AdmBorkBork
1
Sepertinya saya salah mengerti sebagian dari tantangan. Saya pikir ini yang seharusnya Anda maksudkan.
user202729
1
Bisakah Anda memperluas sumbu y dalam grafik sampel Anda di bawah 0 dan di atas 10 untuk membuat tantangan lebih mudah dipahami?
JayCe
@JayCe Ya, saran bagus.
RvdV
2
Kasus uji kedua menunjukkan Anda bermaksud agar urutannya tidak menurun, sebagai lawan dari peningkatan? Dengan kata lain, nilai berulang dalam input tidak menghentikan urutan saat ini, dan jika dua nilai terakhir dalam urutan sama dengan "sudut" untuk memulai urutan berikutnya adalah 0 (sehingga akan mulai dengan nilai yang diulang demikian juga)?
ngm

Jawaban:

8

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}}

Cobalah online!

Sunting: Kode sekarang berfungsi dan menerima input. (Terima kasih kepada Giuseppe, user202729 dan JayCe karena telah menunjukkan hal itu dengan tenang)
Edit: -21 byte yang disarankan oleh Giuseppe.
Edit: -7 byte dengan menghapus d=NULL;.

PA
sumber
1
selamat datang di PPCG! Jawaban ini saat ini tidak valid karena harus mengambil input dengan cara tertentu (saat ini mereka dikodekan di lingkungan). Selain itu, Anda mungkin menemukan tips ini untuk bermain golf di R bermanfaat. Jangan ragu untuk menelepon saya di sini atau dalam obrolan setelah Anda mendapatkan reputasi yang cukup!
Giuseppe
Untuk memperjelas pengajuan yang valid: ini akan menjadi . Selamat datang dan nikmati waktu Anda di sini :)
JayCe
Saya pikir s[p+1]-((m+s[p+1])-s[p])menyederhanakan s[p]-m, dan Anda memiliki d=c(c(...))tempat hanya d=c(...)diperlukan. Saya sangat curiga ada cara golf tapi ini masih jawaban yang bagus.
Giuseppe
1
@ PA dbahkan perlu diinisialisasi?
JayCe
1
@PA senang membantu! Saya baru saja membuka kembali chatroom golf R jadi jangan ragu untuk menghubungi saya dan semua pegolf R lainnya untuk pertanyaan spesifik yang mungkin Anda miliki :-)
Giuseppe
6

Python 2 , 60 byte

Input adalah N, diikuti oleh semua titik sebagai argumen individual. Selanjutnya dalam output dipisahkan oleh 0.5.

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

Cobalah online!


Python 2 , 92 77 68 byte

Selanjutnya dipisahkan oleh [...].

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

Cobalah online!

ovs
sumber
1
Jawaban yang bagus! Saya sangat suka penggunaan variabel k untuk menambahkan item secara selektif, mempelajari sesuatu yang baru di sini!
RvdV
4

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

Cobalah online!

Suram
sumber
4

Haskell, 82 81 80 byte

Ini adalah port jawaban Bersih saya .

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

Cobalah online!

-1, -1 terima kasih kepada Laikoni


sumber
@Laikoni sangat disayangkan kami tidak dapat mendefinisikan fsecara lokal tanpa tanda kurung di sekitar :pola, seperti pada let x<r@(a:_):s|....
3

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

Cobalah online!

Argumen operator untuk foldradalah lambda dengan penjaga; itu diurai sebagai:

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

Saya mengirim ini ke Haskell .


sumber
2

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

Cobalah online!

-1 byte terima kasih kepada Keelan

Laikoni
sumber
1

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)

Cobalah online! Ini sedikit lebih lama daripada jawaban JS lainnya, tetapi menggunakan pendekatan yang berbeda.

Penjelasan yang tidak disatukan dan disederhanakan

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;
}
NinjaBearMonkey
sumber