Introducción

Suponga que desea calcular los máximos de cola de una lista de números, es decir, el máximo de cada sufijo no vacío. Una forma de hacerlo es elegir repetidamente un número y reemplazarlo por un número más alto que ocurra después, hasta que esto ya no sea posible. En este desafío, su tarea es realizar un paso de este algoritmo.

La tarea

Su entrada es una lista de enteros L , que pueden estar vacíos. Su salida será la lista L donde exactamente un número L _i ha sido reemplazado por otro L _j , donde L _i <L _j e i <j .

En otras palabras, deberá reemplazar un número con un número mayor que ocurra después.

Puedes elegir i y j libremente entre todos los pares válidos, y la elección puede ser no determinista.

Si tales i y j no existen (es decir, L no aumenta), su salida será L sin cambios.

Ejemplo

Considere la entrada L = [3, 1, 4, -1, 2] . Las posibles operaciones son reemplazar 3 por 4 , reemplazar 1 por 4 , reemplazar 1 por 2 o reemplazar -1 por 2 . Por lo tanto, las salidas posibles son:

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

Si repite la operación suficientes veces, el resultado final será [4,4,4,2,2] , que es precisamente la lista de máximos de cola de L .

Reglas y puntaje

Puede escribir un programa completo o una función. En el último caso, puede modificar la entrada en su lugar en lugar de devolver una nueva matriz, si su idioma lo permite. Los formatos de entrada y salida son flexibles dentro de lo razonable.

El conteo de bytes más bajo gana.

Casos de prueba

Se muestran todas las salidas posibles.

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

Guardado un byte gracias a @Neil, otro gracias a @ user81655

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

Justo cuando parece reduceRightque finalmente podría tener una oportunidad, .mapaparece una vez más ...

Mathematica, 37 bytes

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

Función pura tomando incluso una lista de números reales y devolviendo una lista de números reales. Busca el primer par de entradas consecutivas en el orden "incorrecto" y reemplaza el primero de ese par con el segundo. El buen comportamiento predeterminado de /.significa que devuelve la entrada sin alterar cuando sea apropiado.

Nota al margen divertida: si reemplazamos b<ccon !OrderedQ[{c,b}], entonces la función funciona en cadenas (y realmente cualquier tipo de datos una vez que se describe el orden apropiado). Por ejemplo, #/.{a___,b_,c_,d___}/;!OrderedQ[{c,b}]:>{a,c,c,d}&en la entrada {"programming", "puzzles", "code", "golf"}devuelve {"puzzles", "puzzles", "code", "golf"}.

JavaScript (ES6), 43 39 38 bytes

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

Salidas modificando la matriz en el lugar. Editar: Guardado 4 bytes gracias a @ETHproductions. Guardado 1 byte gracias a @ user81655.

Haskell , 36 bytes

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

Pruébalo en línea!

Mire a través de la lista elementos consecutivos a,bcon a<by cámbielos a b,b.

Mejorado de 37 bytes:

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

Jalea , 13 11 bytes

ṫJṀ€ż¹ŒpQ-ị

Reemplaza el más a la derecha de todos los números posibles.

Pruébalo en línea!

Cómo funciona

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

tdt0>0whY>d*0h+

Pruébalo en línea!

No soy un gran admirador de esta solución. Me parece terriblemente ineficiente. Particularmente las secciones whY>d*y 0h+.

Python 2, 139 134 93 bytes

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

Terriblemente largo, pero es un primer intento.

-5 bytes gracias a TemporalWolf
-41 (!!) bytes gracias a Value Ink

MATL , 13 bytes

ttd0>fX>Q)2M(

Pruébalo en línea!

Explicación

Las siguientes dos condiciones son equivalentes:

1. Hay un número que tiene un número más alto a su derecha
2. Hay un número que tiene un número más alto inmediatamente a su derecha

El código usa la condición 2, que es más simple. Calcula incrementos consecutivos y encuentra el último positivo, si lo hay. Para las dos entradas involucradas, escribe el valor de la segunda entrada en la primera.

Este truco se usa para manejar el caso cuando no se puede realizar ninguna sustitución. Tenga en cuenta también que la indexación MATL está 1basada en.

Usemos la entrada [3,1,4,-1,2]como ejemplo.

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 bytes

Esto se basa en la respuesta de xnor , quien sugirió que lo publicara yo mismo.

EDITAR: xnor encontró un byte para guardar.

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

Pruébalo en línea!

Básicamente, observé que la ramificación del método de xnor siempre termina eligiendo la expresión de rama más grande, ya que Haskell usa el orden lexicográfico para las listas. (El caso cuando a==btambién funciona porque f r>=r, que se puede probar por separado por inducción).

Dicho de otra manera, siempre que sea b:r > a:f r, entonces b:res una respuesta correcta, y de lo contrario podemos recurrir aa:f r .

Entonces, en lugar de verificar a<bpor adelantado, solo calculo ambas expresiones y tomo el máximo. Esto podría dar una explosión exponencial, aunque la pereza de Haskell evita que a menos que ay bson iguales.

Python 3, 79 bytes

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

Muta la matriz original (lista) que se le ha dado. No estoy contento de que esto no sea una lambda y estoy seguro de que hay mejores optimizaciones; Espero abordarlos más tarde.

Breve explicacion

Lleva el máximo de la matriz más allá del elemento actual (comenzando con el cero). Luego compara esto con el elemento en sí: si el máximo es mayor, reemplace el elemento actual con él y pare, de lo contrario, incremente en uno y siga intentándolo.

Ruby, 66 61 bytes

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

Pruébalo en línea!

C, 47 bytes

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

Implementación recursiva que toma como entrada un puntero al primer elemento de una matriz y la longitud de la matriz. Modifica la matriz en su lugar.

SWI-Prolog, 70 bytes

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

La primera cláusula reemplaza el primer elemento de la lista con el valor máximo del resto de la lista, pero solo si este máximo es mayor. La segunda cláusula recurrentemente llama al predicado para el final de la lista. Si ninguna de estas cláusulas tiene éxito, la tercera cláusula simplemente devuelve la entrada.

Este retorno solo es una de las posibles soluciones. Es trivial encontrarlos a todos con un código muy similar, pero el caso en que no es posible cambiar requiere muchos más bytes.

Ejemplo:

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

R, 71 bytes

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

C, 80 bytes

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

Llamar con:

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 bytes

Pruébelo en línea -1 byte gracias a @TemporalWolf
-25 bytes gracias a @ValueInk
-7 bytes gracias a @Cole

Función que muta la matriz de entrada

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

Si no hubiera necesidad de detenerse después de la primera iteración, sería un poco más bonito

Python 2, 60 bytes

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

Pruébalo en línea!

Explicación: Verifica recursivamente si un elemento dado es menor que el maxelemento en el resto de la lista. Si es así, devuelve la lista con la maxsustitución del primer elemento.

TI-Basic, 72 bytes

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

Explicación:

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 bytes

Los enteros de entrada se pasan como argumentos al script.

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

Descompostura:

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 bytes

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

Descompostura

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 bytes

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

Ejemplo de uso: f [1,1,2,1]-> [2,1,2,1].Pruébalo en línea!.

Si la lista de entrada tiene al menos un elemento, enlace bal primer elemento y lal resto de la lista. Si lno está vacío y es binferior al máximo de l, devuelve el máximo seguido de l, de lo contrario, devuelve bseguido de una llamada recursiva de f l. Si la lista de entrada está vacía, devuélvala.

Raqueta 202 bytes

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

Sin golf:

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

Pruebas:

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

Salida:

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

C, 67 bytes

Ejecución única, 67 bytes en vivo

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

Paso único, 78 bytes en vivo

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

Cola máxima, 96 bytes en vivo

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 , 103102 bytes

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]

Pruébalo en línea!