Giới thiệu

Giả sử bạn muốn tính cực đại đuôi của một danh sách các số, nghĩa là tối đa của mỗi hậu tố không trống. Một cách để làm điều đó là liên tục chọn một số và thay thế nó bằng một số cao hơn xảy ra sau nó, cho đến khi điều này là không thể nữa. Trong thử thách này, nhiệm vụ của bạn là thực hiện một bước của thuật toán này.

Nhiệm vụ

Đầu vào của bạn là danh sách các số nguyên L , có thể trống. Đầu ra của bạn sẽ là danh sách L trong đó chính xác một số L _i đã được thay thế bằng một L _{j khác} , trong đó L _i <L _j và i <j .

Nói cách khác, bạn sẽ thay thế một số bằng một số cao hơn xảy ra sau nó.

Bạn có thể chọn i và j một cách tự do trong số tất cả các cặp hợp lệ và sự lựa chọn có thể không đặc biệt.

Nếu như tôi và j không tồn tại (ví dụ: L là không tăng), đầu ra của bạn sẽ là L không thay đổi.

Thí dụ

Xét đầu vào L = [3, 1, 4, -1, 2] . Các thao tác có thể là thay 3 bằng 4 , thay 1 bằng 4 , thay 1 bằng 2 hoặc thay -1 bằng 2 . Do đó, các đầu ra có thể là:

 [  3 ,   1 ,   4 ,  -1 ,   2 ]
 ------------------------------
 [( 4),   1 ,(  4),  -1 ,   2 ]
 [  3 ,(  4),(  4),  -1 ,   2 ]
 [  3 ,(  2),   4 ,  -1 ,(  2)]
 [  3 ,   1 ,   4 ,(  2),(  2)]

Nếu bạn lặp lại các hoạt động đủ thời gian, kết quả cuối cùng sẽ là [4,4,4,2,2] , mà chính xác là danh sách các đuôi cực đại của L .

Quy tắc và tính điểm

Bạn có thể viết một chương trình đầy đủ hoặc một chức năng. Trong trường hợp sau, bạn có thể sửa đổi đầu vào tại chỗ thay vì trả về một mảng mới, nếu ngôn ngữ của bạn cho phép điều đó. Định dạng đầu vào và đầu ra là linh hoạt trong lý do.

Số byte thấp nhất sẽ thắng.

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

Tất cả các kết quả đầu ra có thể được hiển thị.

[] -> []
[1] -> [1]
[1,2] -> [2,2]
[2,1] -> [2,1]
[4,4,4,4] -> [4,4,4,4]
[-1,-3,-10] -> [-1,-3,-10]
[1,3,10] -> [3,3,10] [10,3,10] [1,10,10]
[1,1,2,1] -> [2,1,2,1] [1,2,2,1]
[998,64,2,-94,-789] -> [998,64,2,-94,-789]
[998,2,64,-94,-789] -> [998,64,64,-94,-789]
[3,1,4,-1,2] -> [4,1,4,-1,2] [3,4,4,-1,2] [3,2,4,-1,2] [3,1,4,2,2]
[-1,4,0,4,7,2,3] -> [4,4,0,4,7,2,3] [0,4,0,4,7,2,3] [-1,4,4,4,7,2,3] [7,4,0,4,7,2,3] [-1,7,0,4,7,2,3] [-1,4,7,4,7,2,3] [-1,4,0,7,7,2,3] [2,4,0,4,7,2,3] [-1,4,2,4,7,2,3] [3,4,0,4,7,2,3] [-1,4,3,4,7,2,3] [-1,4,0,4,7,3,3]
[3542,-12311,7662,1672,6081] -> [7662,-12311,7662,1672,6081] [3542,7662,7662,1672,6081] [3542,1672,7662,1672,6081] [6081,-12311,7662,1672,6081] [3542,6081,7662,1672,6081] [3542,-12311,7662,6081,6081]

JavaScript (ES6), 41 40 39 38 byte

Đã lưu một byte nhờ @Neil, một lời cảm ơn khác đến @ user81655

x=>x.map(c=>c<x[++i]>d?x[d=i]:c,d=i=0)

Ngay khi dường như reduceRightcuối cùng cũng có cơ hội, .maplại xuất hiện ...

Toán học, 37 byte

#/.{a___,b_,c_,d___}/;b<c:>{a,c,c,d}&

Hàm thuần túy lấy một danh sách các số thực chẵn và trả về một danh sách các số thực. Tìm cặp đầu tiên liên tiếp theo thứ tự "sai" và thay thế mục đầu tiên của cặp đó bằng mục thứ hai. Hành vi mặc định đẹp của /.phương tiện có nghĩa là nó trả về đầu vào không thay đổi khi thích hợp.

Lưu ý bên thú vị: nếu chúng ta thay thế b<cbằng !OrderedQ[{c,b}], thì hàm hoạt động trên chuỗi (và thực sự là bất kỳ loại dữ liệu nào sau khi thứ tự phù hợp được mô tả). Ví dụ, #/.{a___,b_,c_,d___}/;!OrderedQ[{c,b}]:>{a,c,c,d}&về {"programming", "puzzles", "code", "golf"}lợi nhuận đầu vào {"puzzles", "puzzles", "code", "golf"}.

JavaScript (ES6), 43 39 38 byte

a=>a[a.some(e=>e<a[++i],i=0)*i-1]=a[i]

Đầu ra bằng cách sửa đổi các mảng tại chỗ. Chỉnh sửa: Đã lưu 4 byte nhờ @ETHproductions. Đã lưu 1 byte nhờ @ user81655.

Haskell , 36 byte

f(a:r@(b:_))|a<b=b:r|1>0=a:f r
f e=e

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

Xem qua danh sách các yếu tố liên tiếp a,bvới a<bvà thay đổi chúng thành b,b.

Cải thiện từ 37 byte:

f(a:b:t)|a<b=b:b:t
f(a:t)=a:f t
f e=e

Thạch , 13 11 byte

ṫJṀ€ż¹ŒpQ-ị

Thay thế ngoài cùng bên phải của tất cả các số có thể.

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

Làm thế nào nó hoạt động

ṫJṀ€ż¹ŒpQ-ị  Main link. Argument: A (array)

 J           Yield all indices of A, i.e., the array [1, ..., len(A)].
ṫ            Dyadic tail; for index k, take all elements starting with the k-th.
             This constructs the array of suffixes.
  Ṁ€         Maximum each; map the monadic maximum atom over the suffixes.
     ¹       Identity; yield A.
    ż        Zip; construct all pairs of elements of the result to the left and the
             corresponding elements of the result to the right.
      Œp     Cartesian product. Construct all arrays that, for each index, take
             either the left or the right element.
        Q    Unique; deduplicate the resulting arrays.
         -ị  At-index -1; select the second to last result.
             The last result is A itself, the first maxima of suffixes.

MATL , 15 byte

tdt0>0whY>d*0h+

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

Tôi không phải là một fan hâm mộ lớn của giải pháp này. Nó có vẻ không hiệu quả khủng khiếp với tôi. Đặc biệt là whY>d*và 0h+các phần.

Python 2, 139 134 93 byte

a=input()
for i in range(len(a)):
 for j in a[i+1:]:
    if a[i]<j:a[i]=j;print a;exit()
print a

Rất dài, nhưng đó là một nỗ lực đầu tiên.

-5 byte nhờ các byte TemporalWolf
-41 (!!) nhờ vào Ink Ink

MATL , 13 byte

ttd0>fX>Q)2M(

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

Giải trình

Hai điều kiện sau là tương đương:

1. Có một số có số cao hơn ở bên phải của nó
2. Có một số có số cao hơn ngay bên phải của nó

Mã sử ​​dụng điều kiện 2, đơn giản hơn. Nó tính toán các mức tăng liên tiếp và tìm ra giá trị dương cuối cùng, nếu có. Đối với hai mục liên quan, nó ghi giá trị của mục thứ hai vào mục đầu tiên.

Thủ thuật này được sử dụng để xử lý trường hợp khi không thể thay thế. Cũng lưu ý rằng lập chỉ mục MATL 1dựa trên cơ sở.

Hãy sử dụng đầu vào [3,1,4,-1,2]làm ví dụ.

tt    % Get input implicitly and duplicate it twice
      % STACK: [3,1,4,-1,2], [3,1,4,-1,2], [3,1,4,-1,2]
d     % Consecutive differences
      % STACK: [3,1,4,-1,2], [3,1,4,-1,2], [-2  3 -5  3]
0>    % Are they positive?
      % STACK: [3,1,4,-1,2], [3,1,4,-1,2], [0 1 0 1]
f     % Find indices of all positive differences. Result may be empty
      % STACK: [3,1,4,-1,2], [3,1,4,-1,2], [2 4]
X>    % Maximum index with a positive difference. Empty input remains as empty
      % STACK: [3,1,4,-1,2], [3,1,4,-1,2], 4
Q     % Add 1. Since the addition is elementwise, empty input remains as empty
      % STACK: [3,1,4,-1,2], [3,1,4,-1,2], 5
)     % Get the entry of the input at that position
      % STACK: [3,1,4,-1,2], 2
2M    % Push maximum index with a positive difference, again
      % STACK: [3,1,4,-1,2], 2, 4
(     % Assign to that position. Implicitly display
      % STACK: [3,1,4,2,2]

Haskell , 34 33 byte

Điều này dựa trên câu trả lời của xnor , người đề nghị tôi tự đăng nó.

EDIT: xnor tìm thấy một byte để lưu.

f(a:r@(b:_))=max(b:r)$a:f r
f e=e

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

Về cơ bản, tôi quan sát thấy rằng sự phân nhánh của phương thức xnor luôn kết thúc bằng việc chọn bất kỳ biểu thức nhánh nào là lớn nhất, vì Haskell sử dụng thứ tự từ điển cho các danh sách. (Trường hợp khia==b cũng hoạt động vì f r>=r, có thể được chứng minh riêng bằng cảm ứng.)

Đặt khác nhau, bất cứ khi nào b:r > a:f r, sau đób:r là một câu trả lời chính xác, và nếu không chúng ta có thể tái diễn a:f r.

Vì vậy, thay vì kiểm tra a<btrước, tôi chỉ cần tính cả hai biểu thức và lấy mức tối đa. Điều này có thể mang lại một cú đánh theo cấp số nhân, mặc dù sự lười biếng của Haskell tránh điều đó trừ khi avà bbằng nhau.

Python 3, 79 byte

def f(x):
 for i,a in enumerate(x):
  m=max(x[i+1:])
  if m>a:x[i]=m;break

Đột biến mảng ban đầu (danh sách) được cung cấp cho nó. Tôi không vui vì đây không phải là lambda và tôi chắc chắn có những tối ưu hóa tốt hơn; Tôi hy vọng sẽ giải quyết những vấn đề này sau.

Giải thích ngắn gọn

Nó lấy tối đa của mảng qua phần tử hiện tại (bắt đầu bằng zeroth). Sau đó, nó so sánh nó với chính phần tử: nếu max lớn hơn, thay thế phần tử hiện tại bằng nó và dừng lại, nếu không, tăng dần một và tiếp tục thử nó.

Ruby, 66 61 byte

->a{i=r=-1;a.map{|e|m=a[i+=1,a.size].max;r&&m>e ?(r=!r;m):e}}

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

C, 47 byte

f(p,n)int*p;{n>1?*p<p[1]?*p=p[1]:f(p+1,n-1):0;}

Việc thực hiện đệ quy lấy đầu vào của nó là một con trỏ tới phần tử đầu tiên của một mảng và độ dài của mảng. Sửa đổi các mảng tại chỗ.

SWI-Prolog, 70 byte

f([H|T],[S|T]):-max_list(T,S),S>H,!.
f([H|T],[H|R]):-f(T,R),!.
f(I,I).

Mệnh đề đầu tiên thay thế phần tử đầu tiên của danh sách bằng giá trị tối đa của phần còn lại của danh sách, nhưng chỉ khi max này lớn hơn. Mệnh đề thứ hai gọi đệ quy vị ngữ cho phần đuôi của danh sách. Nếu không có mệnh đề nào thành công, mệnh đề thứ ba chỉ cần trả về đầu vào.

Sự trở lại này chỉ là một trong những giải pháp có thể. Việc tìm tất cả chúng với mã rất giống nhau là chuyện nhỏ, nhưng trong trường hợp không thể thay đổi thì cần nhiều byte hơn để xử lý.

Thí dụ:

?- f([-1,4,0,4,7,2,3], O).
O = [7, 4, 0, 4, 7, 2, 3]

R, 71 byte

a=scan()
l=length(a) 
lapply(1:l,function(x){
  a[x]=max(a[x:l])
  a
})

C, 80 byte

i,j;f(l,n)int*l;{for(i=0;i<n;++i)for(j=i;++j<n;)if(l[i]<l[j]){l[i]=l[j];j=i=n;}}

Gọi với:

int main()
{
    int a[5]={3,1,4,-1,2};
    f(a,5);
    for(int k=0;k<5;++k)
        printf("%d ", a[k]);
}

Python 2, 89 byte

Dùng thử trực tuyến -1 byte nhờ @TemporalWolf
-25 byte nhờ @ValueInk
-7 byte nhờ @Cole

Hàm biến đổi mảng đầu vào

def F(A):
 for i in range(len(A)):
    r=[y for y in A[i+1:]if y>A[i]]
    if r:A[i]=r[0];break

Nếu không cần dừng lại sau lần lặp đầu tiên, nó sẽ đẹp hơn một chút

Python 2, 60 byte

f=lambda x:x and[x[:1]+f(x[1:]),[max(x)]+x[1:]][x[0]<max(x)]

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

Giải thích: Kiểm tra đệ quy nếu một phần tử đã cho nhỏ hơn maxphần tử trong phần còn lại của danh sách. Nếu vậy, trả về danh sách bằng cách maxthay thế phần tử đầu tiên.

TI-Basic, 72 byte

Prompt L1
If 2≤dim(L1
Then
For(A,1,dim(L1)-1
For(B,A,dim(L1
If L1(A)<L1(B
Then
L1(B→L1(A
Goto E
End
End
End
End
Lbl E
L1

Giải trình:

Prompt L1          # 4 bytes, input list
If 2≤dim(L1        # 7 bytes, if the list has 2 or 1 element(s), skip this part and return it
Then               # 2 bytes
For(A,1,dim(L1)-1  # 12 bytes, for each element in the list other than the last
For(B,A,dim(L1     # 9 bytes, for each element after that one
If L1(A)<L1(B      # 12 bytes, if the second is larger than the first
Then               # 2 bytes
L1(B→L1(A          # 10 bytes, replace the first with the second
Goto E             # 3 bytes, and exit
End                # 2 bytes
End                # 2 bytes
End                # 2 bytes
End                # 2 bytes
Lbl E              # 3 bytes
L1                 # 2 bytes, implicitly return L1

sh, 118 byte

Số nguyên đầu vào được truyền dưới dạng đối số cho tập lệnh.

l=("$@");for i in "$@";{ for j in "$@";{(($i<$j))&&{ l[$x]=$j;echo ${l[@]};exit;};};shift;x=`expr $x+1`;};echo ${l[@]}

Phá vỡ:

l=("$@");                      #copy original list
for i in "$@";{ for j in "$@"; #check all elements j that follow element i in list
{(($i<$j))&&{ l[$x]=$j;echo ${l[@]};exit;};};   #if i<j, make i=j; print list, done
shift;                         #makes sure that i is compared only to j that occur after it
x=`expr $x+1`;};               #keeps track of i'th position in the list
echo ${l[@]}                   #prints list if it was unchanged

PHP, 88 byte

<?for(;$i+1<$c=count($a=$_GET)&&$a[+$i]>=$a[++$i];);$i>=$c?:$a[$i-1]=$a[$i];print_r($a);

Phá vỡ

for(;
$i+1<($c=count($a=$_GET))  # first condition end loop if the item before the last is reach 
&&$a[+$i]>=$a[++$i] # second condition end loop if item is greater then before 
;);
$i>=$c?:$a[$i-1]=$a[$i]; # replace if a greater item is found
print_r($a); #Output

Haskell, 48 byte

f(b:l)|l>[],m<-maximum l,b<m=m:l|1<2=b:f l
f x=x

Ví dụ sử dụng: f [1,1,2,1]-> [2,1,2,1]. Hãy thử trực tuyến!.

Nếu danh sách đầu vào có ít nhất một phần tử, liên kết bvới phần tử đầu tiên và lphần còn lại của danh sách. Nếu lkhông trống và bnhỏ hơn mức tối đa l, trả về mức tối đa theo sau l, trả về khác btheo sau là một cuộc gọi đệ quy của f l. Nếu danh sách đầu vào trống, trả lại nó.

Vợt 202 byte

(let((g(λ(L i n)(for/list((c(in-naturals))(l L))(if(= c i)n l))))(ol'()))
(for((c(in-naturals))(i L))(for((d(in-range c(length L)))#:when(>(list-ref L d)i))
(set! ol(cons(g L c(list-ref L d))ol))))ol)

Ung dung:

(define (f L)
  (let ((replace (λ (L i n)   ; sub-function to replace i-th item in list L with n;
                   (for/list ((c (in-naturals))
                              (l L))
                     (if (= c i) n l))))
        (ol '()))             ; outlist initially empty; 
    (for ((c (in-naturals))               ; for each item in list
          (i L))
      (for ((d (in-range c (length L)))   ; check each subsequent item in list
            #:when (> (list-ref L d) i))  ; if greater, replace it in list
        (set! ol (cons (replace L c (list-ref L d)) ol)))) ; and add to outlist.
    ol))          ; return outlist.

Kiểm tra:

(f '(3 1 4 -1 2))

Đầu ra:

'((3 1 4 2 2) (3 2 4 -1 2) (3 4 4 -1 2) (4 1 4 -1 2))

C, 67 byte

Chạy đơn, 67 byte Live

j;f(l,i)int*l;{j=i-1;while(i-->0)while(j-->0)l[j]=fmax(l[i],l[j]);}

Bước đơn, 78 byte Live

j;f(l,i)int*l;{j=i-1;while(i-->0)while(j-->0)if(l[j]<l[i]){l[j]=l[i];return;}}

Đuôi Maxima, 96 byte Live

x;i;j;f(l,n)int*l;{do{x=0;for(i=0;i<n;i++)for(j=0;j<i;j++)if(l[j]<l[i])l[j]=l[i],x=1;}while(x);}

Python 3 , 103 102 byte

lambda a:([a[:i]+[max(a[i:])]+a[i+1:]for i in range(len(a))if-~i==len(a)or max(a[i+1:])>a[i]]+[[]])[0]

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