Đồ thị ngày càng tăng


23

Xem xét một chuỗi số một chiều trong một phạm vi cố định, nghĩa là

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

Biểu đồ tăng dần * ** là một đường kết nối tất cả các điểm trong chuỗi này từ trái sang phải và luôn đi lên hoặc duy trì mức. Nếu cần thiết, dòng kết thúc từ trên xuống dưới và tiếp tục đi lên từ đó để đáp ứng điểm tiếp theo.

Mục tiêu của thử thách này là phân chia chuỗi theo các chuỗi khác nhau, tất cả đều không tăng, do đó, khi được vẽ cùng với trục dọc hạn chế, chúng sẽ tạo thành một Đồ thị tăng dần. Điều này được thực hiện bằng cách thêm một điểm vào cuối của một chuỗi con và bắt đầu một điểm tiếp theo, sao cho góc của đường thẳng vượt qua ranh giới trên cùng thẳng hàng với đường thẳng vượt qua ranh giới dưới cùng và hai điểm giao nhau có cùng tọa độ ngang. Ví dụ trên sẽ cho đầu ra sau:

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

Và biểu đồ tương ứng sẽ như sau: Đồ thị ngày càng tăng mà thực sự nên được gọi là Đồ thị không tăng Và với trục được mở rộng để có cái nhìn tốt hơn: Đồ thị tăng dần mà thực sự nên được gọi là Đồ thị không tăng dần với trục dọc mở rộng. Đầu ra bắt buộc là một danh sách các chuỗi con tạo thành các phần của Biểu đồ tăng dần. Tạo một cốt truyện là không bắt buộc nhưng sẽ kiếm được điểm thưởng cho bạn;). Đầu ra phải phân tách rõ ràng các phần sau theo một cách nào đó.

Ghi chú

  • Phạm vi sẽ luôn có 0 là ranh giới bên trái (bao gồm) và ranh giới bên phải sẽ là một số nguyên N.
  • Chuỗi sẽ không bao giờ chứa các giá trị không nằm trong phạm vi.
  • Phần đầu tiên không có điểm bổ sung lúc đầu.
  • Phần cuối cùng không có điểm bổ sung ở cuối.
  • Không bắt buộc phải cung cấp các chỉ số bắt đầu sẽ được yêu cầu để vẽ các chuỗi con.

Các trường hợp thử nghiệm

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]

Chấm điểm

Đây là code-golf, mã ngắn nhất tính bằng byte thắng.

* Không phải biệt ngữ thực tế ** Thực tế nên được gọi là Đồ thị không giảm, như @ngm đã chỉ ra, nhưng điều đó nghe có vẻ ít ấn tượng hơn.


7
Chào mừng đến với PPCG! Thử thách đầu tiên tốt đẹp!
admBorkBork

1
Hình như tôi đã hiểu nhầm một phần của thử thách. Tôi nghĩ rằng đây nên là những gì bạn dự định.
dùng202729

1
Bạn có thể mở rộng trục y trong biểu đồ mẫu của bạn dưới 0 và trên 10 để làm cho thử thách dễ hiểu hơn không?
JayCe

@JayCe Vâng, đề nghị tốt.
RvdV

2
Trường hợp thử nghiệm thứ hai cho thấy bạn có ý định các chuỗi không giảm, trái ngược với tăng? Nói cách khác, một giá trị lặp lại trong đầu vào không dừng được thứ tự hiện tại đó và nếu hai giá trị cuối cùng trong một chuỗi con bằng với "góc" để bắt đầu chuỗi tiếp theo là 0 (vì vậy nó sẽ bắt đầu bằng giá trị lặp lại cũng)?
ngm

Câu trả lời:



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

Hãy thử trực tuyến!

Chỉnh sửa: Mã bây giờ là một chức năng và nhận đầu vào. (Cảm ơn Giuseppe, user202729 và JayCe đã bình tĩnh chỉ ra điều đó)
Chỉnh sửa: -21 byte được đề xuất bởi Giuseppe.
Chỉnh sửa: -7 byte bằng cách xóa d=NULL;.


1
Chào mừng đến với PPCG! Câu trả lời này hiện không hợp lệ vì nó phải nhận đầu vào theo một cách nào đó (hiện tại chúng được mã hóa cứng trong môi trường). Ngoài ra, bạn có thể thấy những lời khuyên này để chơi gôn trong R hữu ích. Hãy ping tôi ở đây hoặc trong trò chuyện một khi bạn đã có đủ danh tiếng!
Giuseppe

Chỉ cần rõ ràng về những gì sẽ là một đệ trình hợp lệ: điều này sẽ được . Chào mừng và tận hưởng thời gian của bạn ở đây :)
JayCe

Tôi nghĩ s[p+1]-((m+s[p+1])-s[p])đơn giản hóa s[p]-m, và bạn có d=c(c(...))nơi chỉ d=c(...)được yêu cầu. Tôi hoàn toàn nghi ngờ có một cách chơi golf hơn nhưng đây vẫn là một câu trả lời hay.
Giuseppe

1
@PA có dcần khởi tạo không?
JayCe

1
@PA rất vui được giúp đỡ! Tôi vừa mở lại một phòng chat golf R để thoải mái liên lạc với tôi và tất cả những người chơi golf R khác cho những câu hỏi cụ thể mà bạn có thể có :-)
Giuseppe

6

Python 2 , 60 byte

Đầu vào là N, theo sau là tất cả các điểm dưới dạng đối số riêng lẻ. Các kết quả trong đầu ra được phân tách bằng 0.5.

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

Hãy thử trực tuyến!


Python 2 , 92 77 68 byte

Hậu quả được ngăn cách bởi [...].

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

Hãy thử trực tuyến!


1
Anwser tốt đẹp! Tôi thực sự thích việc sử dụng biến k cho các mục bổ sung có chọn lọc, đã học được điều gì đó mới ở đây!
RvdV

4

Sạch , 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..]]

Hãy thử trực tuyến!



4

Haskell, 82 81 80 byte

Đây là một cổng của câu trả lời sạch của tôi .

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

Hãy thử trực tuyến!

-1, -1 nhờ Laikoni


@Laikoni thật đáng tiếc, chúng tôi không thể xác định fcục bộ mà không có dấu ngoặc đơn xung quanh :mẫu, như trong let x<r@(a:_):s|....

3

Sạch , 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)

Hãy thử trực tuyến!

Đối số toán tử foldrlà lambda có bảo vệ; nó được phân tích thành:

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

Tôi chuyển cái này cho Haskell .




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)

Hãy thử trực tuyến! Câu hỏi này dài hơn một chút so với câu trả lời JS khác, nhưng nó sử dụng một cách tiếp cận khác.

Giải thích đơn giản và đơn giản

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

Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.