Dropsort , progettato da David Morgan-Mar, è un esempio di "algoritmo di ordinamento" a tempo lineare che produce un elenco che, in effetti, è ordinato, ma contiene solo alcuni degli elementi originali. Qualsiasi elemento che non sia grande almeno quanto il massimo degli elementi che lo precedono viene semplicemente rimosso dall'elenco e scartato.

In questa attività, ti verrà fornito un elenco di numeri interi come input (STDIN o argomento della funzione, ti viene richiesto di supportare almeno l'intervallo di numeri interi con segno a 8 bit.) Il tuo compito è di ridimensionarli e quindi generare gli elementi rimanenti in ordine.

Si può presumere che l'elenco non sia vuoto.

Questo è il golf del codice, quindi vince il programma più breve.

Casi test

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

Classifica

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 byte

⊢(/⍨)⊢=⌈\

Questo è un treno di funzioni monadico con diagramma:

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

La versione non ferroviaria è

{⍵/⍨⍵=⌈\⍵}

Questo in sostanza controlla se ogni elemento è uguale al massimo corrente.

Si noti che la soluzione J di Martin Büttner ha la stessa lunghezza di questa ed è stata pubblicata per prima.

J, 10 9 byte

#~(=>./\)

Versione funzionante della mia idea di CJam (in meno byte). Per esempio:

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

Spiegazione

Innanzitutto, otteniamo il massimo di ciascun prefisso, con:

    >./\

(Qui >.è l'operatore massimo, /piega quell'operatore in un elenco e \ottiene tutti i prefissi dell'input.)

Quindi confrontiamo l'elenco iniziale con quei massimi per l'uguaglianza:

  (=>./\)

E infine, selezioniamo tutti gli elementi in cui questo elenco di risultati booleani ha dato un 1:

#~(=>./\)

Haskell, 28 anni

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

Una funzione anonima. Chiamalo come

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

Equivalente alla ricorsione

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

Tradotto in modo iterativo, ripetiamo gli elementi e, per ognuno di essi, rimuoviamo quelli più piccoli di esso dal resto dell'elenco su cui stiamo ripetendo. Grazie ad Antisthenes per un byte salvato con (x<).

Python 2, 49

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

JavaScript (ES6), 29

Abuso della conversione di tipo standard in javascript, array in numero:

• array di solo 1 numero => quel numero
• qualsiasi altro array => 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>

Ottava, 27 19 byte

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

Pyth, 12 byte

eMfqeTeST._Q

Verifica tutti i casi di test contemporaneamente.

Come funziona

         ._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 byte

⊇ᶠ↔ᵒt

Provalo online!

Gelatina , 5 byte

ŒPUÞṪ

Provalo online!

Spiegazione

⊇ᶠ↔ᵒ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)

Questa è una situazione rara: riesco ad usare un algoritmo che (per quanto potrei dire con una breve scrematura) nessuno sta usando finora, e in qualche modo finisce con la stessa lunghezza in due linguaggi golf molto diversi con sintassi molto diversa e set predefiniti, con una corrispondenza 1 a 1 tra i programmi (i comandi sono anche nello stesso ordine!). Quindi sembrava avere più senso combinarli - in un certo senso, questi sono lo stesso programma, e l'ho scritto in entrambe le lingue per vedere quale era più breve - piuttosto che presentarli separatamente.

L'idea di base qui è che il dropsort di un elenco è la sua sottosequenza con il contrario lessicograficamente massimo. Stranamente, né Brachylog né Jelly hanno un builtin per trovare il massimo con una funzione particolare (Jelly ha un builtin per restituire tutti i massimi con una funzione particolare, ma che restituirebbe un elenco singleton contenente il risultato anziché il risultato stesso, e inoltre non è nemmeno più breve di farlo in questo modo). Quindi, invece, generiamo tutte le sottosequenze possibili, ordiniamo al contrario, prendiamo l'ultima.

Il motivo per cui "inversione massima lessicograficamente" funziona è che l'output scelto deve terminare (quindi il suo reverse deve iniziare) con il numero più alto nell'elenco di input (è facile vedere che l'output dropsort finirà sempre con quello), e quindi può dopo non contiene nulla (perché prendere le sottosequenze mantiene l'ordine). Ripeti induttivamente e finiamo con la definizione di dropsort.

Mathematica, 26 byte

DeleteDuplicates[#,#>#2&]&

R, 29 26 byte

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

Questo crea un oggetto funzione che accetta un vettore xe ritorna xdopo aver rimosso tutti gli elementi non almeno grandi quanto il massimo cumulativo di x.

Salvato 3 byte grazie a flodel!

K, 11 byte

{x@&~x<|\x}

In azione:

  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 byte

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

Ecco un semplice ciclo di output. Mantiene solo il massimo me confronta ogni elemento.

Perl, 33 byte

Codice 32 byte + -p

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

Se gli spazi aggiuntivi sono accettabili nell'output, possono essere 31 byte rimuovendo e ?. Accetta una stringa (o numero di stringhe separate da nuova riga) tramite 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

Python 3, 67

Forza piuttosto bruta. Modificato in una funzione, perché mi mancava che fosse una risposta valida.

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

Versione non golfata:

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 byte

Salvato 1 byte grazie a JArkinstall .

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

C # - 6864 o 132127 personaggi

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

Wherein questo caso sta iterando attraverso l'elenco e, per ogni elemento vall'indice idell'elenco, valuta l'espressione booleana. Se l'espressione viene valutata vera, l'elemento viene aggiunto al risultato. L'unico vero trucco dell'espressione booleana è che i cortocircuiti o la valutazione C # non appena una condizione viene valutata vera. Ciò impedisce l' IndexOutOfRangeExceptioneccezione e mantiene il primo elemento nell'elenco.

Se l'input e l'output devono essere stringhe (non potrei dirlo con certezza, quindi lo lascerò all'OP e al resto di voi a decidere.)

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

Decomprimere che dà un po ':

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

In questo caso, la seconda riga della funzione utilizza esattamente la stessa logica di cui sopra. Le Selectafferra gli elementi della lista e converte loro int. La chiamata a ToList¹ impone di valutare la selezione e la trasforma varin a List<int>in fase di compilazione, in modo che Whereoperi su una raccolta di numeri interi.

Provalo su C # Pad

Grazie a VisualMelon per l'aiuto a tagliare rispettivamente 4 byte e 5 byte. :)

_{1 elenco tutu?}

CJam, 15 byte

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

Provalo online nell'interprete CJam .

Come funziona

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 byte

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

Provalo online!

Meno golf:

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

C: 73 byte

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

o

C: 49 byte

(Se è consentita l' intestazione doganale per le competizioni di codegolf)

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

Non riesco ancora a battere CJam, ma almeno questo permette di battere poche altre lingue.

Burlesque, 13 byte

Soluzione a 11 byte che supera i casi di test:

-.2CO:so)[~

Prova online qui .

Spiegazione:

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

Tuttavia, questa versione funziona solo utilizzando il fatto che non ci sono due numeri più piccoli tra due numeri. Altrimenti usa la versione seguente (che è 13B):

Versioni precedenti:

J-]{cm-1.>}LO

Prova online qui. Spiegazione:

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

Se anche tu avessi lasciato cadere numeri uguali, potresti semplicemente .>usare invece di usare cm. Inoltre, se gli elenchi contengono solo numeri positivi è possibile utilizzare uno 0o -1anziché J-].

Minkolang 0.9 , 18 byte

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

Provalo qui.

Spiegazione

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.

Rubino, 41 37 caratteri

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

Esecuzione di esempio:

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]

APL NARS2000, 13 byte

NARS2000 è un interprete APL gratuito per Windows; include funzionalità multiset accessibili con l' ⍦operatore.

(+⍦∩⌈\)

Questo è un fork monadico che accetta l'intersezione multiset ( ⍦∩) dell'input ( +) * e l'elenco dei valori massimi in esecuzione ( ⌈\).

Poiché ⍦non è un carattere APL standard nelle codifiche legacy APL a un byte, è necessario utilizzare UTF-8, rendendo i ⍦∩⌈caratteri tre byte ciascuno. Ho scelto +invece di ⊢salvare due byte.

NARS2000 supporta le forcelle, che possono essere integrate in treni senza parentesi, ma a differenza di Dyalog non consente l'assegnazione a una funzione senza racchiudere la funzione tra parentesi.

* +è un coniugato tecnicamente complesso, ma l'input è reale.

> <> con -v flag, 36 31 + 2 = 33 byte

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

Immettere l'elenco sullo stack con -v in modo che il primo elemento dell'elenco si trovi nella parte superiore dello stack. Stamperà l'elenco dropsorted con uno spazio finale.

Prova :

$ 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

Modifica: salvato 5 byte grazie a Fongoid

Python, 102 99 94 + 5 6 newline non finali del file = 107 105 100 byte

(Ho usato le schede per il rientro)

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

Non è il migliore là fuori, ma questo è il mio primo colpo al code golf. Impossibile trovare un modo per ordinare l'elenco in linea senza incorrere in bug relativi alla rimozione, quindi ho spostato gli elementi ordinati in un elenco temporaneo.

EDIT: list.append () è più breve di farlo nel modo brutto

r + = [i] era più corto di list.append (); grazie njzk2 !

Scala: 232 126 120 byte

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 byte

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

Ungolfed:

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

Piccolo Lisp, 107 byte

( Questa lingua è stata pubblicata solo dopo questa domanda, quindi questa risposta è fuori concorso. Non che avesse alcuna possibilità di vincere. La lingua in seguito si è evoluta ulteriormente per avere più buildin di quelli che ho usato qui, ma sto con versione che avevo originariamente implementato nel 2015. Questa risposta funziona ancora con il più recente interprete ufficiale , anche se fornisce alcuni avvertimenti perché definisco un parametro ache ombreggia il nuovo buildin a(per l'aggiunta). _{Grazie a DLosc per il collegamento 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)))()))))

Questo definisce una funzione ds(e la sua funzione helper ricorsiva r) che ordina il suo argomento, che deve essere un elenco di numeri interi.

r non è una funzione ricorsiva della coda, quindi per elenchi molto lunghi questo potrebbe incorrere in un overflow dello stack.

Ungolfed:

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

Ecco alcuni esempi su come usare questo (con i casi test dalla domanda):

(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ì, -7non è un valore intero letterale, quindi dobbiamo definire una funzione per rappresentarli.) Output:

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

Gelatina, 5 byte

=»\Tị

Nota che la sfida precede la creazione di Jelly.

Provalo online!

Come funziona

=»\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 byte

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