Giriş

Diyelim ki bir sayılar listesinin kuyruk maksima'sını, yani her boş olmayan son ekin maksimumunu hesaplamak istediğinizi varsayalım. Bunu yapmanın bir yolu, tekrar tekrar bir numara seçip, daha sonra mümkün olmadıkça, daha sonra gelen daha yüksek bir sayı ile değiştirmektir. Bu zorlukta, göreviniz bu algoritmanın bir adımını gerçekleştirmektir.

Görev

Girişiniz , boş olabilen L tamsayılarının bir listesidir . Çıktınız liste olacaktır L tam olarak bir numara L _i başka almıştır L _j , L _i <L _j ve i <j .

Başka bir deyişle, bir sayıdan sonra gelen daha yüksek sayı ile değiştirmelisiniz.

İ ve j'yi tüm geçerli çiftler arasında özgürce seçebilir ve seçim özgün olamaz.

Eğer böyle bir i ve j yoksa (yani L artmaz), çıktınız L değişmeyecektir.

Örnek

L = [3, 1, 4, -1, 2] girişini dikkate alın . Muhtemel işlem yerine vardır 3 ile 4 yerine, 1 ile 4 , yerine 1 ile 2 ya da yerine -1 ile 2 . Böylece olası çıktılar:

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

İşlemi yeterince tekrarlarsanız, sonuç , tam olarak L' nin kuyruk maksimumunun listesi olan [4,4,4,2,2] olacaktır .

Kurallar ve puanlama

Tam bir program veya bir fonksiyon yazabilirsiniz. İkinci durumda, eğer diliniz buna izin veriyorsa, yeni bir dizi döndürmek yerine girişi yerinde değiştirebilirsiniz. Giriş ve çıkış biçimleri nedensel olarak esnektir.

En düşük bayt sayısı kazanır.

Test durumları

Tüm olası çıkışlar gösterilmektedir.

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

@Neil'e, @ user81655'e başka bir bayt sayesinde kaydedildi

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

Görünüşe göre reduceRightnihayet bir şansın olabilir, .mapyine ortaya çıkar

Mathematica, 37 bayt

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

Hatta gerçek sayılar listesini alarak ve gerçek sayılar listesini döndüren saf işlev. "Yanlış" sırayla ilk ardışık giriş çiftini arar ve bu çiftin ilkini ikinci ile değiştirir. Nice'in varsayılan davranışı, /.uygun olduğunda girişi değiştirmeden döndürdüğü anlamına gelir.

Eğlenceli yan not: b<cile değiştirirsek !OrderedQ[{c,b}], işlev dizgelerde çalışır (ve uygun sıralamanın açıklanmasından sonra gerçekten herhangi bir veri türü). Örneğin, #/.{a___,b_,c_,d___}/;!OrderedQ[{c,b}]:>{a,c,c,d}&girdi {"programming", "puzzles", "code", "golf"}dönüşlerinde {"puzzles", "puzzles", "code", "golf"}.

JavaScript (ES6), 43 39 38 bayt

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

Diziyi yerinde değiştirerek çıktı verir. Düzenleme: @ETHproductions sayesinde 4 bayt kaydedildi. @ User81655 sayesinde 1 bayt kaydedildi.

Haskell , 36 bayt

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

Çevrimiçi deneyin!

Ardışık elemanları listesine bakarken a,bile a<bve bunları değiştirir b,b.

37 bayttan geliştirildi:

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

Jöle , 13 11 bayt

ṫJṀ€ż¹ŒpQ-ị

Tüm olası sayıların en sağını değiştirir.

Çevrimiçi deneyin!

Nasıl çalışır

ṫ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 bayt

tdt0>0whY>d*0h+

Çevrimiçi deneyin!

Bu çözümün büyük bir hayranı değilim. Bana korkunç derecede verimsiz geliyor. Özellikle whY>d*ve 0h+bölümleri.

Python 2, 139 134 93 bayt

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

Çok uzun, ama bu ilk deneme.

TemporalWolf sayesinde -5 bayt
, Value Ink sayesinde -41 (!!) bayt

MATL , 13 bayt

ttd0>fX>Q)2M(

Çevrimiçi deneyin!

açıklama

Aşağıdaki iki koşul eşdeğerdir:

1. Sağında daha yüksek bir sayı olan bir sayı var
2. Hemen sağında daha yüksek bir sayı olan bir sayı var

Kod, daha basit olan koşul 2'yi kullanır. Ardışık artışları hesaplar ve varsa son pozitif olanı bulur. İlgili iki giriş için, ikinci girişin değerini ilkine yazar.

Bu numara , oyuncu değişikliği yapılamadığında davayı ele almak için kullanılır. Ayrıca MATL indekslemenin -basli olduğuna dikkat edin 1.

Girdiyi [3,1,4,-1,2]örnek olarak kullanalım .

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 bayt

Bu, xnor'ın cevabına dayanarak, kendim göndermemi önerdi.

EDIT: xnor kaydetmek için bir bayt buldu.

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

Çevrimiçi deneyin!

Temel olarak, xnor'ın yönteminin dallanmasının her zaman şube ifadelerinden hangisinin en büyük olacağını seçmesinin bittiğini gözlemledim, çünkü Haskell listelerde sözlük sıralamasını kullanıyor. (Aynı a==bzamanda çalıştığı zaman da f r>=r, çünkü bunlar indüksiyonla ayrı ayrı ispatlanabilirler.)

Başka bir deyişle, ne zaman b:r > a:f r, o zaman b:rdoğru bir cevaptır ve aksi takdirde tekrarlayabiliriz a:f r.

Bu yüzden a<bönceden kontrol etmek yerine, sadece iki ifadeyi de hesaplıyorum ve maksimumda kullanıyorum. Haskell'ın tembellik sürece önler ancak bu, üstel ayaklanmalarını verebilir ave beşittir.

Python 3, 79 bayt

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

Verilen orijinal diziyi (listeyi) dönüştürür. Bunun bir lambda olmadığı için mutsuzum ve daha iyi optimizasyonlar olduğundan eminim; İnşallah bunları daha sonra ele alacağım.

Kısa açıklama

Geçerli öğeyi geçen dizinin en üstünü alır (sıfırdan başlayarak). Daha sonra bunu elementin kendisiyle karşılaştırır: eğer max daha büyükse, mevcut elementi onunla değiştirin ve durun, aksi halde bir artırın ve denemeye devam edin.

Ruby, 66 61 bayt

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

Çevrimiçi deneyin!

C, 47 bayt

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

Girdi olarak bir dizinin ilk elemanına bir işaretçi ve dizinin uzunluğunu alarak yinelemeli uygulama. Diziyi yerinde değiştirir.

SWI-Prolog, 70 bayt

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

İlk fıkra, listenin ilk elemanını listenin geri kalanının maksimum değeri ile değiştirir, ancak bu maksimum değer daha büyükse. İkinci fıkra tekrar tekrar listenin kuyruğuna ilişkin ifadeyi çağırır. Bu maddelerden hiçbiri başarılı olmazsa, üçüncü madde basitçe girdiyi döndürür.

Bu, olası çözümlerden yalnızca bir tanesi. Bunları benzer kodla bulmak önemsizdir, ancak daha sonra hiçbir değişikliğin mümkün olmadığı durumlar işlemek için daha fazla bayt alır.

Örnek:

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

R, 71 bayt

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

C, 80 bayt

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

İle ara:

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 bayt

@ValueInk
-7 byte sayesinde @TemporalWolf -25 byte ile çevrimiçi -1 byte, @Cole sayesinde

Girdi dizisini değiştiren işlev

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

İlk yinelemeden sonra durmaya gerek kalmazsa, biraz daha güzel olurdu

Python 2,60 bayt

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

Çevrimiçi Deneyin!

Açıklama: Belirli bir öğenin maxlistenin geri kalan kısmındaki öğeden daha az olup olmadığını tekrar tekrar kontrol eder . Öyleyse max, ilk öğeyi değiştirerek listeyi döndürür .

TI-Basic, 72 bayt

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

Açıklama:

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 bayt

Giriş tamsayıları betiğe argüman olarak iletilir.

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

Yıkmak:

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 Bayt

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

Yıkmak

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 bayt

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

Kullanım örneği: f [1,1,2,1]-> [2,1,2,1]. Çevrimiçi deneyin! .

Giriş listesinde en az bir öğe varsa, bilk öğeye ve llistenin geri kalanına bağlayın. Eğer lboşaltıp değil bmaksimum daha az l, bunu takiben maksimum dönüş l, başka dönüş bbir özyinelemeli çağrı izledi f l. Giriş listesi boşsa, geri gönderin.

Raket 202 bayt

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

Ungolfed:

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

Test yapmak:

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

Çıktı:

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

C, 67 bayt

Tek Çalıştır, 67 byte Canlı

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

Tek Adım, 78 Bayt Canlı

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

Kuyruk Maxima, 96 byte Canlı

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 bayt

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]

Çevrimiçi deneyin!