ordinamento di un elenco in Groovy in modo insolito

Question

ho una lista di, consente di dire [gatto, cane, mucca, cavallo], che voglio da ordinare nel modo seguente

• se Cat è in la lista dovrebbe venire prima
• se la Mucca è nella lista dovrebbe venire il secondo
• Il resto degli elementi dovrebbe venire dopo in ordine alfabetico.

Qualche suggerimento su come questo potrebbe essere fatto in Groovy?

Answer 1

La risposta di Tim è abbastanza intelligente. Personalmente sono più un fan del solo utilizzo delle operazioni di lista in quanto il codice che genera è leggermente più facile da leggere.

def highPriority = [ 'Cat', 'Cow' ] 

def list = [ 'Armadillo', 'Dog', 'Cow', 'Zebra', 'Horse', 'Cow', 'Cat' ] 

def remainder = (list - highPriority).sort() 

list.retainAll(highPriority) 

list.sort{ highPriority.indexOf(it) } + remainder 

Che vi darà due volte Cow. Se non vuoi duplicati, l'uso di intersect è abbastanza semplice.

def highPriority = [ 'Cat', 'Cow' ] 

def list = [ 'Armadillo', 'Dog', 'Cow', 'Zebra', 'Horse', 'Cow', 'Cat' ] 

list.intersect(highPriority).sort{ highPriority.indexOf(it) } + (list - highPriority).sort() 

Answer 2

Questo dovrebbe farlo:

// Define our input list 
def list = [ 'Armadillo', 'Cat', 'Dog', 'Cow', 'Zebra', 'Horse', 'Cow' ] 

// Define a closure that will do the sorting 
def sorter = { String a, String b, List prefixes=[ 'Cat', 'Cow' ] -> 
    // Get the index into order for a and b 
    // if not found, set to being Integer.MAX_VALUE 
    def (aidx,bidx) = [a,b].collect { prefixes.indexOf it }.collect { 
    it == -1 ? Integer.MAX_VALUE : it 
    } 
    // Compare the two indexes. 
    // If they are the same, compare alphabetically 
    aidx <=> bidx ?: a <=> b 
} 

// Create a new list by sorting using our closure 
def sorted = list.sort false, sorter 

// Print it out 
println sorted 

che le stampe:

[Cat, Cow, Cow, Armadillo, Dog, Horse, Zebra] 

Ho commentato a cercare di spiegare ogni passaggio che ci vuole. Aggiungendo gli elementi prefisso predefinito come parametro opzionale sulla chiusura sorter, significa che siamo in grado di fare cose come questa per modificare l'impostazione predefinita:

// Use Dog, Zebra, Cow as our prefix items 
def dzc = list.sort false, sorter.rcurry([ 'Dog', 'Zebra', 'Cow' ]) 
println dzc 

che stamperà l'elenco ordinato come:

[Dog, Zebra, Cow, Cow, Armadillo, Cat, Horse] 

Answer 3

Se non si dispone di elementi duplicati, si può provare questo:

def highPriority = [ 'Cat', 'Cow' ] 
def list = [ 'Armadillo', 'Dog', 'Cow', 'Zebra', 'Horse', 'Cat' ] 
highPriority + list.minus(highPriority).sort() 

Answer 4

ispirato tomas' answer:

def highPriority = [ 'Cat', 'Cow' ] 
def list = [ 'Armadillo', 'Cat', 'Dog', 'Cow', 'Zebra', 'Horse', 'Cow' ] 

// Group animals by priority. 
def groups = list.groupBy { it in highPriority ? it : 'rest' } 
// High priority animals are sorted by priority and the rest alphabetically. 
def sorted = highPriority.collectMany { groups[it] } + groups['rest'].sort() 

assert sorted == ['Cat', 'Cow', 'Cow', 'Armadillo', 'Dog', 'Horse', 'Zebra'] 

La variabile groups è qualcosa di simile [rest:[Armadillo, Dog, Zebra, Horse], Cat:[Cat], Cow:[Cow, Cow]].

Un altro, forse meno robusta, la soluzione potrebbe essere:

def sorted = list.sort(false) { 
    def priority = highPriority.indexOf(it) 
    if (priority == -1) priority = highPriority.size() 
    // Sort first by priority and then by the value itself 
    "$priority$it" 
} 

è meno robusto nel senso che ordina da stringhe come "2Armadillo", "0Cat", ecc, e non funzionerà se si dispone di 9 o più animali ad alta priorità (perché "10Alpaca" < "9Eel". Sarebbe bello se Groovy fornisse una specie di tipo di tupla simile, come Python's tuples, quindi invece di restituire "$priority$it" come chiave comparabile, si potrebbe restituire la tupla (priority, it).

Answer 5

Ecco un'altra alternativa che si sente più semplice per me:

// smaller values get sorted first 
def priority(animal) { 
    animal in ['Cat', 'Cow'] ? 0 : 1 
} 

def list = [ 'Armadillo', 'Cat', 'Dog', 'Cow', 'Zebra', 'Horse', 'Cow' ] 

def sorted = list.sort{ a, b -> priority(a) <=> priority(b) ?: a <=> b } 

assert sorted == ['Cat', 'Cow', 'Cow', 'Armadillo', 'Dog', 'Horse', 'Zebra'] 

Answer 6

Questa domanda è piuttosto vecchio, ma oggi ho scoperto che Groovy ha una, piuttosto non documentata, OrderBy comparatore che può essere utilizzato in questo caso:

def highPriority = ['Cow', 'Cat'] 
def list = ['Armadillo', 'Cat', 'Dog', 'Cow', 'Zebra', 'Horse', 'Cow'] 

def sorted = list.sort new OrderBy([{ -highPriority.indexOf(it) }, { it }]) 

assert sorted == ['Cat', 'Cow', 'Cow', 'Armadillo', 'Dog', 'Horse', 'Zebra'] 

il OrderBy comparatore confronta primo gli animali con il loro indice nell'elenco highPriority negati (quindi gli animali che non sono alta priorità (ad esempio index -1) vengono spostati sul retro della lista) e se gli indici sono uguali li confronta con la funzione di identità {it}, che, come animali sono stringhe, li ordina alfabeticamente.