Implementa Lazy Drop Sort

26

Questa sfida descrive già dropsort. Tuttavia, sono un po 'pigro e ho solo bisogno che il mio array sia un po' più ordinato di prima, non ha bisogno di essere ordinato fino in fondo .

In Drop Sort, eliminiamo ogni elemento meno di qualsiasi elemento prima di esso. In Lazy Drop Sort, eliminiamo ogni elemento meno di quello strettamente precedente .

Ecco un esempio Considera il seguente array:

8 6 9 9 7 2 3 8 1 3

Contrassegniamo ogni elemento meno di quello precedente.

8 6 9 9 7 2 3 8 1 3
  ^     ^ ^     ^

Nota come né è 3stato contrassegnato, né l'ultimo 8. Sono tutti più grandi del singolo elemento alla loro sinistra.

Completando l'algoritmo, rimuovendo gli elementi contrassegnati, otteniamo:

8 9 9 3 8 3

Che fondamentalmente sembra più ordinato. Tipo. Sono pigro.

Il tuo compito, come avrai già dedotto, è implementare questo algoritmo.

L'input è un array di almeno 1 numero intero positivo compreso tra 1 e 9, quindi puoi prendere anche una stringa di cifre.

Questo è code-golf , vince meno byte!

Casi di prova aggiuntivi:

1
1

1 2 3
1 2 3

5 3 1
5

1 2 3 2 1
1 2 3

1 1 1 9 9 9 1 1 1 9 9 9 1 1 1
1 1 1 9 9 9 1 1 9 9 9 1 1

9 9
9 9

5 2 4 2 3
5 4 3
code-golf  array-manipulation  sorting 
— Pavel
fonte
Può essere una funzione o deve essere un programma completo?
— rafa11111,
@ rafa11111 O va bene
— Pavel
Nel caso sia una funzione, l'array di input può essere codificato nel programma principale? E la lunghezza dell'array può essere passata come input per la funzione?
— rafa11111,
@ rafa11111 L'ingresso non può essere codificato nella funzione stessa. Non importa come la funzione ottiene questo input nel programma di test. Puoi prendere una lunghezza di array solo se stai usando C / C ++ o un'altra lingua in cui questo è l'unico modo per determinare la lunghezza di un array.
— Pavel

Risposte:

6

Buccia , 4 byte

m←ġ<

Provalo online!

Spiegazione

m←ġ<
  ġ<    Group the numbers into decreasing sequences
m←      Keep the first element of each sequence
— Leo
fonte
15

JavaScript (ES6), 28 25 byte

Salvato 3 byte grazie a @Shaggy

a=>a.filter(n=>~-a<(a=n))

Provalo online!

— Arnauld
fonte
2
n=>p<=nsarebbe stato fantastico ;-)
— ETHproductions
4
@ETHproductions Per +4 byte, (n=p)=>p<=(p=n)funziona bene;)
— Arnauld
questa risposta mi sta facendo impazzire, perché non esplode quando si tenta di accedere pper la prima volta, quando non è ancora definito?
— Brian H.
1
@Shaggy Sembra sicuro. Si aggiorna quando torno di fronte a un computer. Grazie!
— Arnauld,
2
@Pavel aè inizialmente impostato sull'array di input e a-1si tradurrebbe in NaN(a meno che non contenga un singolo intero, nel qual caso è costretto a questo intero).
— Arnauld,
6

MATL , 9 8 byte

Salvato un byte grazie a Giuseppe.

0yd0<h~)

Provalo online!

Spiegazione:

0                 % Push a zero
 y                % Implicitly grab the input and duplicate it.
                  % Stack: [8 6 9 9 7 2 3 8 1 3], 0, [8 6 9 9 7 2 3 8 1 3]
  d               % The difference between each number of the last element:
                  % Stack: [8 6 9 9 7 2 3 8 1 3], 0, [-2, 3, 0, -2, -5, 1, 5, -7, 2]
   0<             % Which are negative?
                  % Stack: [8 6 9 9 7 2 3 8 1 3], 0, [1 0 0 1 1 0 0 1 0]
     h            % Concatenate. Stack: [8 6 9 9 7 2 3 8 1 3], [0 1 0 0 1 1 0 0 1 0] 
      ~           % Negate. Stack: [8 6 9 9 7 2 3 8 1 3], [1 0 1 1 0 0 1 1 0 1]
       )          % Index. Stack: [8 9 9 3 8 3]
— Stewie Griffin
fonte
5

Perl 5 .10.0 + -nl, 16 byte

$f>$_||say;$f=$_

Provalo online!

— Wastl
fonte
1
Traduzione in Perl 6perl6 -ne '$/>$_||.say;$/=$_'
— Brad Gilbert b2gills
@Brad perl6 è una lingua diversa (non è nemmeno compatibile con le versioni precedenti) Post it!
— wastl
Ne ho scritto uno che era più idiomatico Perl 6, ma era più lungo. Anche uno dei motivi per cui inserisco qui è mostrare la lingua e spiegarla. Pubblicare quella traduzione non fa altro che dimostrare che si tratta di una versione leggermente più dettagliata di Perl. Fondamentalmente non soddisfa nessuno dei motivi per cui pubblico su questo sito.
— Brad Gilbert b2gills
4

Stax , 5 byte

âÿ╠╦░

Esegui ed esegui il debug online

Disimballando, svincolando e commentando il codice, otteniamo questo.

Z   Push a zero under the input
f   Use the rest of the program as a filter on the input.  Output passing elements.
>   Current element is greater than previous?
_~  Push current element to the input stack; when the main stack is empty, pops fall back to this
!   Logical not; applies to the result of the greater-than

Esegui questo

L'ordinamento delle istruzioni è imbarazzante ma c'è una ragione per questo. L'imballaggio del codice sorgente Stax non sempre produce lo stesso output di dimensioni per lo stesso input di dimensioni. Fondamentalmente, hai la possibilità di salvare un byte se l'ultimo carattere della sorgente ha un codice carattere più basso. Bene, !ha uno dei codici più bassi che puoi ottenere per un personaggio stampabile. (33 in particolare) Molti programmi stax ASCII a 6 byte non possono contenere pacchetti più piccoli. Ma se finiscono con una !, allora possono. Quindi il motivo di questo particolare ordinamento delle istruzioni è quello di garantire che la logica non finisca alla fine del programma.

— ricorsivo
fonte
4

J, 12 byte

#~1,2&(<:/\)

Spiegazione:

#~1,2&(<:/\)    | Whole function, executed as a hook
       <:/      | Distribute <: (greater or equal) over an array
    2&(   \)    | Apply to each sub array of length 2
  1,            | Append a 1 to the front
#~              | Choose elements from the original array

Esempi:

    2&(<:/\) 8 6 9 9 7 2 3 8 1 3
0 1 1 0 0 1 1 0 1
    1,2&(<:/\) 8 6 9 9 7 2 3 8 1 3
1 0 1 1 0 0 1 1 0 1
    (1 0 1 1 0 0 1 1 0 1) # 8 6 9 9 7 2 3 8 1 3
8 9 9 3 8 3
    f =: #~1,2&(<:/\)
    f 8 6 9 9 7 2 3 8 1 3
8 9 9 3 8 3

Provalo online!

— Bolce Bussiere
fonte
Bella soluzione! Ho aggiunto un link TIO per il tuo codice.
— Galen Ivanov,
4

Gelatina , 6 byte

>Ɲ0;¬×

L'I / O è sulle stringhe.

Provalo online!

— Dennis
fonte
Sono curioso, perché operare su stringhe e non su array? Mi è stato detto che Jelly è cattiva nelle corde.
— Pavel,
2
È. ×non dovrebbe funzionare per la ripetizione del personaggio, ma lo fa.
— Dennis,
4

Java 8, 66 55 48 byte

l->{for(int i=0;;)if(i>(i=l.next()))l.remove();}

-11 byte dopo un suggerimento da @ OlivierGrégoire .
-7 byte in più grazie a @ OlivierGrégoire .

Spiegazione:

Provalo online.

l->{                     // Method with Integer-ListIterator parameter and no return-type
  for(int i=0;;)         //  Loop over all items
    if(i>(i=l.next()))   //   If the current item is larger than the next
      l.remove();}       //    Remove this next item
— Kevin Cruijssen
fonte
Perché tutti iniziano a usare ~0quando è fondamentalmente-1 . Personalmente sceglierei la soluzione più intuitiva se il conteggio dei byte ha la stessa lunghezza (tranne per while(...)vs for(;...;), nel qual caso preferisco il for. Grazie per altri -7 byte, però. :)
— Kevin Cruijssen
È perché sto male con il complemento 2 ... Sono così cattivo che volevo dire Integer.MIN_VALUE(che è allora 1<<31, immagino ...) ;-)
— Olivier Grégoire
4

Ottava , 21 byte

@(x)x(~[0,diff(x)<0])

Provalo online!

Spiegazione:

Prendi un vettore xcome input e crea un vettore [0, diff(x)<0], dove si diff(x)trova un vettore con la differenza tra tutti gli elementi adiacenti. Mantieni solo quelli negativi confrontandoli con zero, dandoci un elenco di tutti gli elementi che vogliamo eliminare.

Selezioniamo quindi gli elementi dal vettore di input che vogliamo mantenere.

— Stewie Griffin
fonte
4

V , 25 byte

òjälá k$yl+@"òç-/d
ç /dw

Provalo online!

hexdump:

00000000: f26a e46c e120 6b24 796c 2b40 2218 f2e7  .j.l. k$yl+@"...
00000010: 2d2f 640a e720 2f64 77                   -/d.. /dw

La peggior lingua per il lavoro. Ma l'ho fatto per un coraggio .

— DJMcMayhem
fonte
6
Nota a margine : ojalá è spagnolo per fortuna .
— Dennis,
2
@dennis È fantastico. A cosa serve lo k$yl+@"òç-/dspagnolo?
— DJMcMayhem
7
k$yl+@"òç-/dpotrebbe essere liberamente tradotto come Ouch, chi diavolo ha lasciato aperta quella porta dell'armadio?
— Luis Mendo,
3

triangularity , 71 byte

.....).....
....IEL....
...)rFD)...
..2+)IE)w..
.+h)2_stDO.
={M)IEm}...

Provalo online!

Come funziona?

) IEL) rFD) 2+) IE) w + h) 2_stDO = {M) IEm} - Programma completo.
) IE - Ottieni il 0o input I e valutalo.
   L) r - E spingere l'intervallo [0 ... lunghezza di I).
      F {- Filtra gli interi in questo intervallo che soddisfano:
       D) 2+) IE) w + h) 2_stDO = - Questa condizione. Esegue ciascun elemento E in modo separato
                                    impila e scarta quelli che non soddisfano i criteri.
       D) 2+: duplica e aggiungi 2 alla seconda copia.
           ) IE - Recupera di nuovo I.
              ) - Spingere uno 0 nello stack.
               w - Avvolgere lo 0 in un elenco. [0]
                + - Preparalo a I.
                 h - Testa. Tagliare gli elementi dopo l'indice E + 2.
                  ) 2_ - Letterale -2.
                     st - Coda.
                       DO = - Controlla se il risultato è invariante rispetto all'ordinamento.
                           M) IEm} - Ultima parte: indicizzazione nell'input.
                           M} - Per ciascun indice che soddisfa le condizioni:
                            ) IEm - Recupera l'elemento I in quella posizione.
— Mr. Xcoder
fonte
2
Per curiosità (dal momento che sei il creatore di Triangularity): perché non fare qualcosa di simile come Hexagony / Cubically, in cui un pezzo di codice viene automaticamente riempito con i punti no-op? Quindi questo programma sarebbe )IEL)rFD)2+)IE)w+h)2_stDO={M)IEm}quale si espanderebbe alla tua risposta attuale?
— Kevin Cruijssen,
@KevinCruijssen Perché in realtà stavo pianificando di trasformare la triangolarità in un esolang 2D, ma ho rinunciato all'idea, quindi sono rimasto fedele al mio modello precedente. Penso che presto apporterò alcune importanti modifiche quando rilascerò Triangularity v2. (Inoltre è abbastanza divertente giocare a golf nella sua forma attuale, perché un semplice salvataggio in linea a 1 byte potrebbe invece salvarti 20: D ... Si applica anche retroattivamente quando si
— risolvono le
Bene, anche se hai intenzione di rilasciarlo come esolang 2D, il mio commento rimane (in qualche modo). )IEL)rFD)2+)IE)w+h)2_stDO={M)IEm}sarebbe il tuo codice, si espanderebbe al tuo modello attuale e quindi eseguirà i comandi 2D su quel modello espanso. EDIT: .....).....\n....IEL....\n...)rFD)...\n..2+)IE)w..\n.+h)2_stDO.\n={M)IEm}...e .....).........IEL.......)rFD).....2+)IE)w...+h)2_stDO.={M)IEm}...e )IEL)rFD)2+)IE)w+h)2_stDO={M)IEm}tutti e tre sarebbero esattamente lo stesso programma.
— Kevin Cruijssen,
3

Wolfram Language (Mathematica) , 33 byte

Pick[#,Arg[#-{0}~Join~Most@#],0]&

Provalo online!

Come funziona

Il codice # - {0}~Join~Most@#trasforma un array {a,b,c,d,e,f}in {a,b-a,c-b,d-c,e-d,f-e}. Applicando Arga questo imposta numeri negativi a Pie numeri non negativi a 0.

Pick[#, ..., 0]&seleziona le voci di #dove ...ha un 0: nel nostro caso, esattamente gli elementi che producono un numero non negativo quando si sottrae l'elemento precedente. In altre parole, queste sono esattamente le voci che vogliamo conservare durante il lazydropsorting.

— Misha Lavrov
fonte
3

Meraviglia , 27 byte

-> ':1.!> 'sS#<=.cns2.++[0]

Esempio di utilizzo:

(-> ':1.!> 'sS#<=.cns2.++[0])[8 6 9 9 7 2 3 8 1 3]

Spiegazione

Versione non golfata:

(map get 1).(fltr sS <=).(cns 2).(++ [0])

Prepara 0, ottieni un elenco di coppie consecutive, mantieni gli elementi dell'elenco dove primo numero <= secondo numero, ottieni il secondo numero di ogni coppia.

— Mama Fun Roll
fonte
3

Wolfram Language (Mathematica) , 20 byte

#&@@@Split[#,##>0&]&
(* or *)
Max/@Split[#,##>0&]&

Provalo online!

Spiegazione

Input = {8, 6, 9, 9, 7, 2, 3, 8, 1, 3}

Split[#,##>0&]

Raggruppa elementi consecutivi che stanno rigorosamente diminuendo: {{8, 6}, {9}, {9, 7, 2}, {3}, {8, 1}, {3}}

#&@@@

Prendi il primo elemento di ciascuno: {8, 9, 9, 3, 8, 3}

— JungHwan Min
fonte
##>0è elegante e tutto, ma in realtà non salva nulla #>#2qui;) (che farebbe funzionare il tuo programma con numeri interi arbitrari, ma non è necessario).
— Martin Ender,
3

SWI-Prolog, 44 byte

[A,B|C]-[A|E]:-B<A,[B|C]-[B|E];[B|C]-E. L-L.

Utilizzo: chiamare " Elenco -X" dove Elenco è un elenco racchiuso tra parentesi, separato da virgola, ad es. [1,4,5,1,11,6,7].

— ashtraypettingzoo
fonte
1
Benvenuti nel sito! :)
— DJMcMayhem
2

APL + WIN, 14 byte

Richiede l'inserimento dello schermo di un vettore di numeri interi.

(1,1>2-/v)/v←⎕
— Graham
fonte
2

05AB1E , 6 byte

ĆÁü›_Ï

Provalo online!

Spiegazione

Ć        # append the head of the list
 Á       # rotate right
  ü›     # apply pair-wise greater-than
    _    # logical negate each
     Ï   # keep elements of input that are true in this list
— Emigna
fonte
2

Kotlin , 39 byte

a->a.filterIndexed{i,v->i<1||v>=a[i-1]}

Provalo online!

Filtra gli elementi che sono il primo elemento (indice == 0 o anche un indice più breve <1) OPPURE il valore corrente è maggiore o uguale all'elemento precedente (a [i-1]).

— Makotosan
fonte
2

K4 , 10 byte

Soluzione:

x_/|&<':x:

Esempio:

q)k)x_/|&<':x:8 6 9 9 7 2 3 8 1 3
8 9 9 3 8 3

Spiegazione:

Trova indici in cui l'elemento è inferiore al precedente, rimuovi questi indici dall'input

x_/|&<':x: / the solution
        x: / store input as x
     <':   / less-than each-previous
    &      / indices where true
   |       / reverse
 _/        / drop-over
x          / the input
— streetster
fonte
2

Attache , 24 byte

{Mask[1'(Delta!_>=0),_]}

Provalo online!

Spiegazione

Maskseleziona tutti gli elementi dal suo secondo argomento che corrispondono agli elementi di verità nel suo primo argomento. 1'(Delta!_>=0)calcola gli indici che corrispondono agli elementi che dovrebbero essere presenti nell'array finale.

Altri tentativi

28 byte (senza punti): ~Mask#(1&`'##Delta#`>=#C[0])

32 byte: {Mask[1'(&`<= =>Slices[_,2]),_]}

— Conor O'Brien
fonte
2

C # (.NET Core) , 33 + 18 = 51byte

x=>x.Where((a,n)=>n<1||x[n-1]<=a)

Provalo online!

sostanzialmente l'istruzione è dove x è il primo int dell'array, oppure è maggiore o uguale al numero precedente, conservalo. Altrimenti rilasciarlo.

— Dennis.Verweij
fonte
1
Puoi restituire un IEnumerable. Non ToArray()serve
— Pavel,
@Pavel Avrei bisogno di aggiungere un riferimento in più System.Collections, e ciò annullerebbe tutti i byte salvati per rimuovere il ToArray().
— Dennis.Verweij,
No, dal momento che non farai riferimento IEnumerablenella risposta, semplicemente utilizzandola come tipo di ritorno.
— Pavel,
@Pavel, grazie, a volte non sono sicuro di quando contare i byte o no ... scusa
— Dennis.Verweij
1

Swift 4 , 56 55 byte

{var l=0;print($0.filter{($0>=l,l=$0).0})}as([Int])->()

Provalo online!

Spiegazione

{var l=0;           // Declare variable l
print($0.filter{(   // Print every element e in the input
  $0>=l,            //   where e >= l
  l=$0).0})         //   And set l to e
}as([Int])->()      // Set the input type to integer array
— Herman L
fonte
1

Gelatina , 9 byte

0;>ƝżµḢÐṂ

Provalo online!

Sembra piuttosto ingombrante, non sarebbe così sorpreso se ci fosse un modo migliore.

0;>ƝżµḢÐṂ
   Ɲ       For each adjacent pair in the input...
  >        ...is the first element greater than the second? (yields a list of 0/1)
0;         prepend a zero to this list (always keep the first element)
    ż      zip with the input
     µ     new monadic link
       ÐṂ  keep elements of the list with minimal value of... (Ðḟ would have worked here and been slightly more clear but I'll leave it as it is)
      Ḣ    ...their first element
— dylnan
fonte
1

Brain-Flak , 136 , 120 byte

((())){{}([{}]({}))([({}<(())>)](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}{{}(({})<>)(())(<>)}{}([][()])}{}{}<>{{}({}<>)<>}<>

Qui è formattato e "leggibile" .

((()))
{
    {}

    ([{}]({}))

    ([({}<(())>)](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}

    {
        {}(({})<>)(())(<>)
    }

    {}

    ([][()])

}{}{}<>

{
    {}
    ({}<>)<>
}<>

Provalo online!

— DJMcMayhem
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.