Вступ

Припустимо, ви хочете обчислити максимум хвоста у списку чисел, тобто максимум кожного непустого суфікса. Один із способів зробити це - неодноразово вибирати одне число і замінювати його більш високим числом, яке виникає після нього, поки це вже неможливо. У цьому завданні ваше завдання - виконати один крок цього алгоритму.

Завдання

Ваш вхід - це список цілих чисел L , який може бути порожнім. Вашим результатом повинен бути список L, де саме одне число L _i було замінено іншим L _j , де L _i <L _j і i <j .

Іншими словами, ви заміните одне число на більш високе число, яке виникає після нього.

Ви можете вибирати i і j вільно серед усіх дійсних пар, і вибір може бути недетермінованим.

Якщо такий я і J не існує (тобто L не збільшується), ваш вихід повинен бути L незмінним.

Приклад

Розглянемо вхід L = [3, 1, 4, -1, 2] . Можливі операції - замінити 3 на 4 , замінити 1 на 4 , замінити 1 на 2 або замінити -1 на 2 . Таким чином можливими виходами є:

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

Якщо ви повторите операцію досить багато раз, то кінцевий результат буде [4,4,4,2,2] , що саме список хвостових максимумів L .

Правила та оцінка

Ви можете написати повну програму або функцію. В останньому випадку ви можете змінити ввід на місці замість повернення нового масиву, якщо ваша мова дозволяє це. Формати введення та виведення є гнучкими в межах причини.

Виграє найменший байт.

Тестові справи

Показані всі можливі виходи.

[] -> []
[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 байт

Збережений байт завдяки @Neil, ще один завдяки @ user81655

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

Тільки коли, здається, reduceRightнарешті є шанс, .mapз’являється ще раз ...

Математика, 37 байт

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

Чиста функція взяття списку реальних чисел і повернення списку реальних чисел. Шукає першу пару послідовних записів у "неправильному" порядку і замінює першу з цих пар на другу. Приємна поведінка за замовчуванням /.означає, що він повертає вхід без змін, коли це доречно.

Примітна сторона: якщо ми замінимо b<cна !OrderedQ[{c,b}], функція працює на рядках (і справді будь-якого типу даних, як тільки буде описано відповідне впорядкування). Наприклад, #/.{a___,b_,c_,d___}/;!OrderedQ[{c,b}]:>{a,c,c,d}&на вхідних {"programming", "puzzles", "code", "golf"}поверненнях {"puzzles", "puzzles", "code", "golf"}.

JavaScript (ES6), 43 39 38 байт

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

Виводиться шляхом зміни масиву на місці. Редагувати: збережено 4 байти завдяки @ETHproductions. Збережено 1 байт завдяки @ user81655.

Haskell , 36 байт

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

Спробуйте в Інтернеті!

Перегляньте список послідовних елементів a,bіз a<bта змініть їх на b,b.

Покращено з 37 байтів:

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

Желе , 13 11 байт

ṫJṀ€ż¹ŒpQ-ị

Замінює правий край з усіх можливих цифр.

Спробуйте в Інтернеті!

Як це працює

ṫ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 байт

tdt0>0whY>d*0h+

Спробуйте в Інтернеті!

Я не є великим прихильником цього рішення. Мені це здається жахливо неефективним. Особливо whY>d*і 0h+секції.

Python 2, 139 134 93 байт

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

Страшенно довго, але це перша спроба.

-5 байт завдяки TemporalWolf
-41 (!!) байтів завдяки Value Ink

MATL , 13 байт

ttd0>fX>Q)2M(

Спробуйте в Інтернеті!

Пояснення

Наступні дві умови еквівалентні:

1. Є число, яке має більшу кількість праворуч
2. Є число, яке має вищу цифру одразу праворуч

У коді використовується умова 2, яка простіше. Він обчислює послідовні кроки і знаходить останні позитивні, якщо такі є. Для двох залучених записів він записує значення другого запису першого.

Цей трюк використовується для вирішення випадку, коли заміни неможливо зробити. Зауважимо також, що індексація MATL 1базується.

Давайте використаємо вхідний [3,1,4,-1,2]приклад.

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 байт

На цьому ґрунтується відповіді xnor , який запропонував я опублікувати його сам.

EDIT: xnor знайшов байт для збереження.

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

Спробуйте в Інтернеті!

В основному я зауважував, що розгалуження методу xnor завжди закінчується вибором того, який із гілок виразів є найбільшим, оскільки Haskell використовує лексикографічне упорядкування списків. (Випадок, коли a==bтакож працює, тому f r>=rщо це можна довести окремо індукцією.)

Ставити по-різному, коли завгодно b:r > a:f r , то b:rє правильна відповідь, а в іншому випадку ми можемо рекурсию a:f r.

Тож замість того, a<bщоб заздалегідь перевірити , я просто обчислюю обидва вирази і беру максимум. Це може призвести до експоненціального пориву, хоча лінь Хаскелла уникає цього, якщо тільки aі не bбуде рівним.

Python 3, 79 байт

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

Змінює оригінальний масив (список), наданий йому. Я незадоволений, що це не лямбда, і я впевнений, що є кращі оптимізації; Сподіваюся, я звернуся до них пізніше.

Коротке пояснення

Він займає максимум масиву повз поточного елемента (починаючи з нуля). Потім він порівнює це з самим елементом: якщо макс більший, замініть на нього поточний елемент і зупиніть, інакше зросте на один і продовжуйте намагатися.

Рубі, 66 61 байт

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

Спробуйте в Інтернеті!

C, 47 байт

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

Рекурсивна реалізація, приймаючи за вхід вказівник на перший елемент масиву та довжину масиву. Змінює масив на місці.

SWI-Prolog, 70 байт

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

Перший пункт замінює перший елемент списку максимальним значенням решти списку, але лише якщо цей макс більший. Другий пункт рекурсивно викликає присудок для хвоста списку. Якщо жоден із цих пунктів не вдається, третій пункт просто повертає вхідні дані.

Це повернення лише одне з можливих рішень. Банально знайти їх із дуже схожим кодом, але тоді випадок, коли неможливо змінити, займає набагато більше байтів.

Приклад:

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

R, 71 байт

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

C, 80 байт

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

Телефонуйте за допомогою:

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 байт

Спробуйте в Інтернеті -1 байт завдяки @TemporalWolf
-25 байт завдяки @ValueInk
-7 байт завдяки @Cole

Функція, яка мутує вхідний масив

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

Якби не було потреби зупинятися після першої ітерації, було б трохи красивіше

Python 2, 60 байт

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

Спробуйте в Інтернеті!

Пояснення: Рекурсивно перевіряє, чи заданий елемент менше, ніж maxелемент в решті списку. Якщо так, повертає список із maxзаміною першого елемента.

TI-Basic, 72 байти

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

Пояснення:

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

ш, 118 байт

Цілі числа введення передаються як аргументи до сценарію.

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

Зламатися:

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 байт

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

Зламатися

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 байт

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

Приклад використання: f [1,1,2,1]-> [2,1,2,1]. Спробуйте в Інтернеті!.

Якщо у вхідному списку є щонайменше один елемент, прив'яжіть bдо першого елемента та lдо решти списку. Якщо lпорожній і bменший за максимум l, поверніть максимальний, за яким слід l, а інше повернути, bа потім повторюваний виклик f l. Якщо список вводу порожній, поверніть його.

Ракетка 202 байти

(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)

Безголівки:

(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.

Тестування:

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

Вихід:

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

C, 67 байт

Один запуск, 67 байт в прямому ефірі

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

Один крок, живуть 78 байт

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

Хвіст Максима, 96 байт 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 байти

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]

Спробуйте в Інтернеті!