Dropsort , diseñado por David Morgan-Mar, es un ejemplo de un "algoritmo de clasificación" de tiempo lineal que produce una lista que, de hecho, está ordenada, pero contiene solo algunos de los elementos originales. Cualquier elemento que no sea al menos tan grande como el máximo de los elementos que lo preceden simplemente se elimina de la lista y se descarta.

En esta tarea, se le dará una lista de enteros como entrada (STDIN o argumento de función, debe admitir al menos el rango de enteros con signo de 8 bits). Su tarea es clasificarlos y luego generar los elementos restantes en orden.

Puede suponer que la lista no está vacía.

Este es el código de golf, por lo que gana el programa más corto.

Casos de prueba

Input             Output
1 2 5 4 3 7       1 2 5 7
10 -1 12          10 12
-7 -8 -5 0 -1 1   -7 -5 0 1
9 8 7 6 5         9
10 13 17 21       10 13 17 21
10 10 10 9 10     10 10 10 10

Tabla de clasificación

var QUESTION_ID=61808,OVERRIDE_USER=39022;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

APL, 9 bytes

⊢(/⍨)⊢=⌈\

Este es un tren de funciones monádicas con diagrama:

┌─┼───┐  
⊢ ⍨ ┌─┼─┐
┌─┘ ⊢ = \
/     ┌─┘
      ⌈  

La versión sin tren es

{⍵/⍨⍵=⌈\⍵}

Básicamente, esto verifica si cada elemento es igual al máximo de ejecución.

Tenga en cuenta que la solución J de Martin Büttner tiene la misma longitud que esta y se publicó primero.

J, 10 9 bytes

#~(=>./\)

Versión de trabajo de mi idea de CJam (en menos bytes). P.ej:

   f =: #~(=>./\)
   f 10 10 10 9 10
10 10 10 10
   f 1 2 5 4 3 7
1 2 5 7

Explicación

Primero, obtenemos el máximo de cada prefijo, con:

    >./\

(Aquí, >.es el operador máximo, /dobla ese operador en una lista y \obtiene todos los prefijos de la entrada).

Luego comparamos la lista inicial con esos máximos para la igualdad:

  (=>./\)

Y finalmente, seleccionamos todos los elementos donde esta lista de resultados booleanos dio un 1:

#~(=>./\)

Haskell, 28

foldr(\x l->x:filter(x<)l)[] 

Una función anónima. Llámalo como

foldr(\x l->x:filter(x<)l)[] [-7, -8, -5, 0, -1, 1] 
[-7,-5,0,1]

Equivalente a la recursividad.

f[]=[]
f(x:l)=x:filter(x<)(f l)

Traducido iterativamente, iteramos sobre los elementos, y para cada uno que vemos, eliminamos los más pequeños del resto de la lista sobre la que estamos iterando. Gracias a Antisthenes por un byte guardado con (x<).

Pitón 2, 49

f=lambda a:a and f(a[:-1])+a[-1:]*(a[-1]==max(a))

JavaScript (ES6), 29

Abuso de la conversión de tipo estándar en javascript, matriz a número:

• matriz de solo 1 número => ese número
• cualquier otra matriz => NaN

d=l=>l.filter(v=>l>v?0:[l=v])

// TEST
console.log=x=>O.innerHTML+=x+'\n'

;[
  [[1,2,5,4,3,7], [1,2,5,7]]
, [[10,-1,12], [10,12]]
, [[-7,-8,-5,0,-1,1], [-7,-5,0,1]]
, [[9,8,7,6,5], [9]]
, [[10,13,17,21], [10,13,17,21]]
, [[10,10,10,9,10], [10,10,10,10]]
].forEach(t=>( i=t[0],r=d(i),x=t[1],              
  console.log('Test '+i+' -> '+r+(r+''==x+''?' OK':' Fail (expected '+x+')')))
)

<pre id=O></pre>

Octava, 27 19 bytes

@(a)a(cummax(a)==a)

Pyth, 12 bytes

eMfqeTeST._Q

Verifique todos los casos de prueba a la vez.

Cómo funciona

         ._Q  Compute all prefixes of the input.
  f           Filter; for each T in the prefixes:
    eT          Retrieve the last element of T.
      eST       Sort T and retrieve its last element.
   q            Check for equality.
              Keep T if q returned True.
eM            Select the last element of each kept T.

Brachylog , 5 bytes

⊇ᶠ↔ᵒt

Pruébalo en línea!

Jalea , 5 bytes

ŒPUÞṪ

Pruébalo en línea!

Explicación

⊇ᶠ↔ᵒt    ŒPUÞṪ
⊇ᶠ       ŒP       On all subsequences of {the input}
   ᵒ        Þ     sort by
  ↔        U      their reverse
    t        Ṫ    then take the last element (i.e. the maximum as given by the sort)

Esta es una situación rara: puedo usar un algoritmo que (por lo que pude ver con un descremado rápido) que nadie está usando hasta ahora, y de alguna manera termina la misma longitud en dos idiomas de golf muy diferentes con una sintaxis muy diferente y conjuntos integrados, con una correspondencia 1 a 1 entre los programas (¡los comandos están incluso en el mismo orden!). Así que parecía tener más sentido combinarlos, en cierto modo, son el mismo programa, y ​​lo escribí en ambos idiomas para ver cuál era más corto, que enviarlos por separado.

La idea básica aquí es que el dropsort de una lista es su subsecuencia con el reverso lexicográfico máximo. Curiosamente, ni Brachylog ni Jelly tienen una función integrada para encontrar el máximo por una función en particular (Jelly tiene una función integrada para devolver todos los máximos por una función en particular, pero eso devolvería una lista única que contiene el resultado en lugar del resultado mismo, y tampoco es más corto que hacerlo de esta manera). Entonces, en cambio, generamos todas las subsecuencias posibles, ordenamos por reversa, tomamos la última.

La razón por la que funciona el "reverso máximo lexicográficamente" es que la salida elegida debe terminar (por lo tanto, su reversa debe comenzar) con el número más alto en la lista de entrada (es fácil ver que la salida de dropsort siempre terminará con eso), y así puede No contiene nada después de eso (porque tomar subsecuencias preserva el orden). Repita inductivamente y terminamos con la definición de dropsort.

Mathematica, 26 Bytes

DeleteDuplicates[#,#>#2&]&

R, 29 26 bytes

function(x)x[x>=cummax(x)]

Esto crea un objeto de función que acepta un vector xy regresa xdespués de eliminar todos los elementos que no sean al menos tan grandes como el máximo acumulado de x.

¡Guardado 3 bytes gracias a flodel!

K, 11 bytes

{x@&~x<|\x}

En acción:

  f: {x@&~x<|\x}
  f'(1 2 5 4 3 7
     10 -1 12
     -7 -8 -5 0 -1 1
     9 8 7 6 5
     10 13 17 21
     10 10 10 9 10)

(1 2 5 7
 10 12
 -7 -5 0 1
 ,9
 10 13 17 21
 10 10 10 10)

Java, 82 bytes

void f(int[]a){int m=a[0];for(int n:a){System.out.print(m>n?"":n+" ");m=n>m?n:m;}}

Aquí hay un bucle de salida simple. Simplemente mantiene el máximo my compara cada elemento.

Perl, 33 bytes

Código de 32 bytes + -p

$p=$_;s/\S+ ?/$&>=$p&&($p=$&)/ge

Si los espacios adicionales son aceptables en la salida, pueden ser 31 bytes al eliminar y ?. Acepta una cadena (o número de cadenas separadas por nueva línea) a través de STDIN:

perl -pe'$p=$_;s/\S+ ?/$&>=$p&&($p=$&)/ge' <<< '-7 -8 -5 0 -1 1'
-7 -5 0 1

perl -pe'$p=$_;s/\S+ ?/$&>=$p&&($p=$&)/ge' <<< '10 10 10 9 10'
10 10 10 10

Pitón 3, 67

Bastante fuerza bruta. Lo cambié a una función, porque omití que era una respuesta válida.

def f(i):
 s=[i[0]]
 for n in i[1:]:
  if s[-1]<=n:s+=[n]
 return s

Versión sin golf:

input_numbers = input().split()
sorted_numbers = []
previous_number = int(input_numbers[0])
for number in map(int, input_numbers):
    if previous_number <= number:
        sorted_numbers.append(number)
        previous_number = number
print(sorted_numbers)

Haskell, 38 37 bytes

Guardado 1 byte gracias a JArkinstall .

f(x:y:s)|x>y=f$x:s|1>0=x:f(y:s)
f s=s

C# - 6864 o 132127 caracteres

int[]f(int[]b){return b.Where((v,i)=>i<1||b[i-1]<=v).ToArray();}

Whereen este caso está iterando por la lista, y para cada elemento ven el índice ide la lista, evalúa la expresión booleana. Si la expresión se evalúa como verdadera, entonces el elemento se agrega al resultado. El único truco real para la expresión booleana es que C # cortocircuitos o evaluación tan pronto como una condición se evalúa como verdadera. Esto evita la IndexOutOfRangeExceptionexcepción y mantiene el primer elemento en la lista.

Si la entrada y la salida tienen que ser cadenas (no podría asegurarlo, así que lo dejaré al OP y al resto de ustedes para que decidan).

string t(string b){var c=b.Split(' ').Select(d=>int.Parse(d)).ToList();return String.Join(" ",c.Where((v,i)=>i<1||c[i-1]<=v));}

Descomprimir eso da un poco:

string t(string b) 
{
    var c=b.Split(' ').Select(d=>int.Parse(d)).ToList();
    return String.Join(" ",c.Where((v, i)=>i<1||c[i-1]<=v));
}

En este caso, la segunda línea de la función está utilizando exactamente la misma lógica que la anterior. Los Selectagarra los elementos de la lista y convierte a int. La llamada a ToList¹ obliga a la selección a ser evaluada, y la convierte varen una List<int>en tiempo de compilación, de modo que Whereestá operando en una colección de enteros.

Pruébalo en C # Pad

Gracias a VisualMelon por ayudar a recortar 4 bytes y 5 bytes respectivamente. :)

_{1 lista de tutú?}

CJam, 15 bytes

q~{_2$<{;}&}*]p

Pruébelo en línea en el intérprete de CJam .

Cómo funciona

q~               Read an evaluate all input.
  {        }*    Reduce; push the first element; or each remaining element:
   _2$           Copy the topmost and second topmost element from the stack.
      <          Check if the topmost is smaller than the second topmost.
       {;}&      If it is, remove it from the stack.
             ]   Wrap the stack i an array.
              p  Print.

PowerShell , 32 bytes

$args|?{$e-eq$p-or$_-ge$p;$p=$_}

Pruébalo en línea!

Menos golfizado:

$args|?{
    $empty -eq $previous -or $_ -ge $previous
    $previous = $_
}

C: 73 bytes

int i,j;i=j=INT_MIN;while(scanf("%d",&j)!=EOF)if(j>=i)printf("%d",j),i=j;

o

C: 49 bytes

(Si se permite el encabezado de aduanas para competiciones de codegolf)

I z,y;z=y=INT_MIN;w(s(D,&y)!=E)i(y>z)p(D,y),z=y;}

Todavía no puede vencer a CJam, pero al menos esto permite vencer a algunos otros idiomas.

Burlesque, 13 bytes

Solución de 11 bytes que pasa los casos de prueba:

-.2CO:so)[~

Prueba en línea aquí .

Explicación:

-. -- prepend head of list to list
2CO -- n-grams (sliding window) of size 2
:so -- filter sorted lists
)[~ -- map last

Sin embargo, esta versión solo funciona utilizando el hecho de que no hay dos números más pequeños entre dos números. De lo contrario, use la versión a continuación (que es 13B):

Versiones mas antiguas:

J-]{cm-1.>}LO

Prueba en línea aquí. Explicación:

J -- duplicate
-] -- head
{
  cm -- compare (returning -1,0 or 1)
  -1.> -- greater than -1
}LO -- Loop

Si también elimina números iguales, podría .>usar solo en lugar de usar cm. Además, si las listas solo contienen números positivos, puede usar cualquiera 0o en -1lugar de J-].

Minkolang 0.9 , 18 bytes

ndN(nd1R`2&dN$I$).

Pruébalo aquí

Explicación

ndN                Take first integer from input
(         $I$).    Repeat until the input is empty and then stop.
 nd1R`             Is the next integer less than the previous one?
      2&dN         If not (i.e., it's greater than or equal to), print it.

Ruby, 41 37 caracteres

->a{m=a[0];a.map{|n|m>n ?p: m=n}-[p]}

Ejecución de muestra:

2.1.5 :001 > [
2.1.5 :002 >     [1, 2, 5, 4, 3, 7],
2.1.5 :003 >     [10, -1, 12],
2.1.5 :004 >     [-7, -8, -5, 0, -1, 1],
2.1.5 :005 >     [9, 8, 7, 6, 5],
2.1.5 :006 >     [10, 13, 17, 21],
2.1.5 :007 >     [10, 10, 10, 9, 10],
2.1.5 :008 > ].each{ |test| p ->a{m=a[0];a.map{|n|m>n ?p: m=n}-[p]}[test] }
[1, 2, 5, 7]
[10, 12]
[-7, -5, 0, 1]
[9]
[10, 13, 17, 21]
[10, 10, 10, 10]

NARS2000 APL, 13 bytes

NARS2000 es un intérprete APL gratuito para Windows; incluye funciones de múltiples conjuntos a las que se accede con el ⍦operador.

(+⍦∩⌈\)

Esta es una bifurcación monádica que toma la intersección de múltiples conjuntos ( ⍦∩) de la entrada ( +) * y la lista de máximos de ejecución ( ⌈\).

Como ⍦no es un carácter APL estándar en las codificaciones heredadas de APL de un byte, debemos usar UTF-8, lo que hace que los ⍦∩⌈caracteres sean de tres bytes cada uno. Elegí en +lugar de ⊢guardar dos bytes.

NARS2000 admite horquillas, que pueden integrarse en trenes sin paréntesis, pero a diferencia de Dyalog, no permite la asignación de una función sin incluir la función entre paréntesis.

* +es un conjugado técnicamente complejo, pero la entrada es real.

> <> con la bandera -v, 36 31 + 2 = 33 bytes

:&\o " "&n:~& <
~ >l?!;:&:&(?!^

Ingrese la lista en la pila con -v para que el primer elemento de la lista esté en la parte superior de la pila. Imprimirá la lista ordenada con un espacio final.

Prueba de funcionamiento :

$ for input in "1 2 5 4 3 7" "10 -1 12" "-7 -8 -5 0 -1 1" "9 8 7 6 5" "10 13 17 21" "10 10 10 9 10"; do echo $input '-> ' $(python fish.py dropsort.fsh -v $(echo $input | tac -s ' ')); done

1 2 5 4 3 7 ->  1 2 5 7

10 -1 12 ->  10 12

-7 -8 -5 0 -1 1 ->  -7 -5 0 1

9 8 7 6 5 ->  9

10 13 17 21 ->  10 13 17 21

10 10 10 9 10 ->  10 10 10 10

Editar: guardado 5 bytes gracias a Fongoid

Python, 102 99 94 + 5 6 líneas nuevas no finales de archivo = 107 105 100 bytes

(Usé pestañas para sangrar)

def d(l):
    j=b=0;m=l[j];r=[]
    for i in l:
        (m,b)=[(m,0),(i,1)][i>=m]
        if b>0:r+=[i]
        j+=1
    l[:]=r

No es el mejor que existe, pero esta es mi primera oportunidad de jugar golf en código. No se pudo encontrar una manera de ordenar la lista en línea sin encontrarse con errores relacionados con la eliminación, por lo que moví los elementos ordenados a una lista temporal.

EDITAR: list.append () es más corto que hacerlo de la manera fea

r + = [i] era más corto que list.append (); gracias njzk2 !

Scala: 232 126 120 bytes

def f(x:Int*)=(Seq[Int]()/:x)((r,y)=>r.headOption.filter(y>=).map(_=>y+:r).getOrElse(if(r.isEmpty) y+:r else r)).reverse

Scala, 54 bytes

def f(x:Int*)=(x:\Seq[Int]())((y,r)=>y+:r.filter(y<=))

Sin golf:

def dropSort(xs: Seq[Int]): Seq[Int] =
  xs.foldRight(Seq.empty[Int]) { (x, result) =>
    x +: result.filter(r => r >= x)
  }

Tiny Lisp, 107 bytes

( Este lenguaje solo se publicó después de esta pregunta, por lo que esta respuesta se queda sin competencia. No es que tuviera ninguna oportunidad de ganar. El lenguaje más tarde evolucionó aún más para tener más buildins que los que usé aquí, pero me quedo con el versión que implementé originalmente en 2015. Esta respuesta aún funciona con el nuevo intérprete oficial , aunque da algunas advertencias porque defino un parámetro aque sombrea el nuevo buildin a(para agregar). _{Gracias a DLosc por el enlace TIO} ) _.

(d r(q((m a)(i a(i(l(h a)m)(r m(t a))(c(h a)(r(h a)(t a))))()))))(d ds(q((b)(i b(c(h b)(r(h b)(t b)))()))))

Esto define una función ds(y su función auxiliar recursiva r) que clasifica su argumento, que debe ser una lista de enteros.

r no es una función recursiva de cola, por lo que para listas muy largas esto podría generar un desbordamiento de pila.

Sin golf:

(d r
   (q((m a)
      (i a
         (i (l (h a) m)
            (r m (t a))
            (c (h a)
               (r (h a) (t a))
             )
          )
         ()
       )
   ) )
 )
(d ds
  (q(
      (b)
      (i b
        (c (h b)
           (r (h b) (t b))
         )
        ()
       )
   ) )
 )

Aquí hay algunos ejemplos de cómo usar esto (con los casos de prueba de la pregunta):

(d list (q (args args)))
(d -
   (q( (n)
       (s 0 n)
    ) )
 ) 

(ds (list 1 2 5 4 3 7))
(ds (list 10 (- 1) 12))
(ds (list (- 7) (- 8) (- 5) 0 (- 1) 1))
(ds (list 9 8 7 6 5))
(ds (list 10 13 17 21))
(ds (list 10 10 10 9 10))

(Sí, -7no es un literal entero, por lo que tenemos que definir una función para representarlos). Salida:

list
-
(1 2 5 7)
(10 12)
(-7 -5 0 1)
(9)
(10 13 17 21)
(10 10 10 10)

Jalea, 5 bytes

=»\Tị

Tenga en cuenta que el desafío es anterior a la creación de Jelly.

Pruébalo en línea!

Cómo funciona

=»\Tị  Main link. Argument: A (list)

 »\    Yield the cumulative maxima of A.
=      Perform element-by-element comparison.
       Yields 1 iff A[n] = max(A[1], ..., A[n]).
   T   Get all indices of truthy elements.
    ị  Retrieve the items of A at those indices.

Mathematica, 27 bytes

Pick[#,#-Max~FoldList~#,0]&