Wie lösche ich negative Duplikate aus einem Array?

Question

Wie kann ich effektiv löschen negative Duplikate von positiven ganzen Zahlen aus einem Array von positiven und negativen ganzen Zahlen wie folgt: [1, 5, 10, 5, -5, -1, 9] als Ergebnis möchte ich haben : [1, 5, 10, 5, 9] (-1 und -5 entfernt, wie sie negative Duplikate von 1 und 5)

Answer 1

Dies ist die einfachste Methode, die ich finden konnte:

• positive Zahlen
• wählen ihre Gegenspieler
• berechnen sie aus dem ursprünglichen Array entfernen

---

array = [1, 5, 10, 5, -5, -1, 9] 

p array - array.select{ |i| i > 0 }.map{ |i| -i } 
# [1, 5, 10, 5, 9] 

Es verwendet Array#-, die ziemlich schnell sein sollte.

Answer 2

In Ruby könnte man die uniq Methode: https://ruby-doc.org/core-2.2.0/Array.html#method-i-uniq.

Andernfalls sollten Sie eine Antwort wie this one überprüfen, die beschreibt, wie Sie eine Struktur erstellen, die durch ein Array iteriert.

Answer 3

Sie diese einfach ablehnen mit Array # tun können:

>> a = [1, 5, 10, 5, -5, -1, 9] 
>> a.reject { |e| e < 0 && a.include?(e.abs) } 
=> [1, 5, 10, 5, 9] 

mit einem anderen Beispiel Um zu klären, wird dies keine negativen Werte entfernen, die keine entsprechenden positiven Wert im Array:

>> b = [1, 5, 10, 5, -5, -1, 9, -15] 
>> b.reject { |e| e < 0 && b.include?(e.abs) } 
=> [1, 5, 10, 5, 9, -15] 

Sie können eine Methode, wie so definieren:

def reject_negative_duplicates(array) 
    array.reject { |e| e < 0 && array.include?(e.abs) } 
end 

>> reject_negative_duplicates(a) 
=> [1, 5, 10, 5, 9] 
>> reject_negative_duplicates(b) 
=> [1, 5, 10, 5, 9, -15] 

oder erweitern (Affe Patch) Array :

class Array 
    def reject_negative_duplicates 
    self.reject { |e| e < 0 && self.include?(e.abs) } 
    end 
end 

>> a.reject_negative_duplicates 
=> [1, 5, 10, 5, 9] 
>> b.reject_negative_duplicates 
=> [1, 5, 10, 5, 9, -15] 

Answer 4

Sie können dies mit nur zwei Durchgängen durch das Array in O(n) tun, indem sie die positiven Zahlen dann aus den Array negativen Werten, deren abs gehasht wurde die Ablehnung Hashing:

interessant

def reject_neg_dups(arr) 
    positives = Hash[arr.map {|x| (x>0) ? [x,1] : nil }.compact] 
    arr.reject { |x| (x < 0) && positives[-x] } 
end 

reject_neg_dups([-1, 1, 2, -2]) # => [1, 2] 
reject_neg_dups([-1, 1, -2]) # => [1, -2] since 2 does not appear 

Beachten Sie, dass the Array- solutions sind wesentlich schneller als andere aufgeführt bisher:

require 'benchmark' 

def reject_neg_dups_hash(arr) 
    positives = Hash[arr.map {|x| (x>0) ? [x,1] : nil }.compact] 
    arr.reject { |x| (x < 0) && positives[-x] } 
end 

def reject_neg_dups_include(arr) 
    arr.reject { |x| (x < 0) && arr.include?(x.abs) } 
end 

def reject_neg_dups_arrayminus(arr) 
    arr - arr.select { |i| i > 0 }.map { |i| -i } 
end 

def reject_neg_dups_arrayminusewo(arr) 
    arr - arr.each_with_object([]) { |n,b| b << -n if n > 0 } 
end 

arr = Array.new(1000) { rand(-100..100) } 
N = 1000 
Benchmark.bm(15) do |x| 
    x.report('Array-') { N.times { reject_neg_dups_arrayminus(arr.dup) } } 
    x.report('Array-ewo') { N.times { reject_neg_dups_arrayminusewo(arr.dup) } } 
    x.report('hash')  { N.times { reject_neg_dups_hash(arr.dup) } } 
    x.report('include?') { N.times { reject_neg_dups_include(arr.dup) } } 
end 

Beispiel Ausgang:

     user  system  total  real 
Array-   0.180000 0.000000 0.180000 ( 0.187512) 
Array-ewo   0.200000 0.000000 0.200000 ( 0.194663) 
hash    0.250000 0.010000 0.260000 ( 0.253355) 
include?   3.660000 0.000000 3.660000 ( 3.666313) 

Answer 5

arr = [1, 5, 10, 0, 5, -5, -1, 9, -4] 

arr - arr.each_with_object([]) { |n,b| b << -n if n > 0 } 
    #=> [1, 5, 10, 0, 5, 9, -4]