Vai: Aggiungi se univoco

Question

Esiste un modo per controllare fette/mappe per la presenza di un valore?

Vorrei aggiungere un valore a una fetta solo se lo fa non esistono nella fetta.

Questo funziona, ma sembra prolisso. C'è un modo migliore per farlo?

orgSlice := []int{1, 2, 3} 
newSlice := []int{} 
newInt := 2 

newSlice = append(newSlice, newInt) 
for _, v := range orgSlice { 
    if v != newInt { 
     newSlice = append(newSlice, v) 
    } 
} 

newSlice == [2 1 3] 

Answer 1

Il tuo approccio richiederebbe un tempo lineare per ogni inserimento. Un modo migliore sarebbe utilizzare uno map[int]struct{}. In alternativa, è possibile utilizzare anche uno map[int]bool o qualcosa di simile, ma lo struct{} vuoto presenta il vantaggio che non occupa spazio aggiuntivo. Pertanto, map[int]struct{} è una scelta popolare per un insieme di numeri interi.

Esempio:

set := make(map[int]struct{}) 
set[1] = struct{}{} 
set[2] = struct{}{} 
set[1] = struct{}{} 
// ... 

for key := range(set) { 
    fmt.Println(key) 
} 
// each value will be printed only once, in no particular order 


// you can use the ,ok idiom to check for existing keys 
if _, ok := set[1]; ok { 
    fmt.Println("element found") 
} else { 
    fmt.Println("element not found") 
} 

Answer 2

più efficiente è probabile che sia scorrere il fetta e aggiungendo se non lo trovate.

func AppendIfMissing(slice []int, i int) []int { 
    for _, ele := range slice { 
     if ele == i { 
      return slice 
     } 
    } 
    return append(slice, i) 
} 

È semplice ed evidente e sarà veloce per le piccole liste.

Inoltre, sarà sempre più veloce della tua attuale soluzione basata su mappa. La soluzione basata su mappe esegue iterazioni su tutta la sezione, a prescindere da cosa; questa soluzione ritorna immediatamente quando scopre che il nuovo valore è già presente. Entrambe le soluzioni confrontano gli elementi mentre eseguono l'iterazione. (Ogni affermazione di assegnazione di mappe esegue almeno un confronto con una chiave di mappa internamente.) Una mappa sarebbe utile solo se si riuscisse a mantenerla su molti inserimenti. Se lo ricostruisci su ogni inserimento, allora tutti i vantaggi sono persi.

Se è veramente necessario gestire in modo efficiente elenchi di grandi dimensioni, è consigliabile mantenere gli elenchi in ordine. (Sospetto che l'ordine non ti importi perché la tua prima soluzione è stata aggiunta all'inizio della lista e la tua ultima soluzione viene aggiunta alla fine.) Se mantieni sempre gli elenchi ordinati, puoi utilizzare la funzione sort.Search per fare inserimenti binari efficienti.