從陣列元素中移除重複的元素

Question

從數組元素中移除重複的最佳方法是什麼？ 例如，從陣列

a = [4, 3, 3, 1, 6, 6] 

需要得到

a = [4, 1] 

我的方法的工作原理與元素的大量太慢。

arr = [4, 3, 3, 1, 6, 6] 
puts arr.join(" ") 
nouniq = [] 
l = arr.length 
uniq = nil 
for i in 0..(l-1) 
    for j in 0..(l-1) 
    if (arr[j] == arr[i]) and (i != j) 
     nouniq << arr[j] 
    end 
    end 
end 
arr = (arr - nouniq).compact 

puts arr.join(" ") 

Answer 1

a = [4, 3, 3, 1, 6, 6] 
a.select{|b| a.count(b) == 1} 
#=> [4, 1] 

更復雜，但更快的解決方案（O(n)相信:)）

a = [4, 3, 3, 1, 6, 6] 
ar = [] 
add = proc{|to, form| to << from[1] if form.uniq.size == from.size } 
a.sort!.each_cons(3){|b| add.call(ar, b)} 
ar << a[0] if a[0] != a[1]; ar << a[-1] if a[-1] != a[-2] 

Answer 2

arr = [4, 3, 3, 1, 6, 6] 

arr. 
    group_by {|e| e }. 
    map {|e, es| [e, es.length] }. 
    reject {|e, count| count > 1 }. 
    map(&:first) 
# [4, 1] 

Answer 3

在不引入需要對原始陣列的單獨的副本，並使用注入：

[4, 3, 3, 1, 6, 6].inject({}) {|s,v| s[v] ? s.merge({v=>s[v]+1}) : s.merge({v=>1})}.select {|k,v| k if v==1}.keys 
=> [4, 1] 

Answer 4

這是我的旋轉在使用哈希累加計數數組中的每個元素由Perl程序員使用的解決方案：

ary = [4, 3, 3, 1, 6, 6] 

ary.inject({}) { |h,a| 
    h[a] ||= 0 
    h[a] += 1 
    h 
}.select{ |k,v| v == 1 }.keys # => [4, 1] 

這可能是在同一行，如果這是在所有重要的是，在字裏行間明智地使用分號map。

有一點不同的方式是：

ary.inject({}) { |h,a| h[a] ||= 0; h[a] += 1; h }.map{ |k,v| k if (v==1) }.compact # => [4, 1] 

它取代了select{...}.keys與map{...}.compact所以它不是一個真正的改善，而且，對我來說是有點難以明白。

Answer 5

我需要這樣的東西，所以測試了幾種不同的方法。這些都返回的原始數組中複製的項目的數組：

module Enumerable 
def dups 
    inject({}) {|h,v| h[v]=h[v].to_i+1; h}.reject{|k,v| v==1}.keys 
end 
def only_duplicates 
    duplicates = [] 
    self.each {|each| duplicates << each if self.count(each) > 1} 
    duplicates.uniq 
end 
def dups_ej 
    inject(Hash.new(0)) {|h,v| h[v] += 1; h}.reject{|k,v| v==1}.keys 
end 
def dedup 
    duplicates = self.dup 
    self.uniq.each { |v| duplicates[self.index(v)] = nil } 
    duplicates.compact.uniq 
end 
end 

Benchark結果10萬次迭代，先用一個整數數組，然後一個字符串數組。性能會因重複的發現NUMER有所不同，但這些測試是用固定數量的重複（〜一半數組項是重複的）：

test_benchmark_integer 
            user  system  total  real 
Enumerable.dups     2.560000 0.040000 2.600000 ( 2.596083) 
Enumerable.only_duplicates  6.840000 0.020000 6.860000 ( 6.879830) 
Enumerable.dups_ej    2.300000 0.030000 2.330000 ( 2.329113) 
Enumerable.dedup    1.700000 0.020000 1.720000 ( 1.724220) 
test_benchmark_strings 
            user  system  total  real 
Enumerable.dups     4.650000 0.030000 4.680000 ( 4.722301) 
Enumerable.only_duplicates  47.060000 0.150000 47.210000 (47.478509) 
Enumerable.dups_ej    4.060000 0.030000 4.090000 ( 4.123402) 
Enumerable.dedup    3.290000 0.040000 3.330000 ( 3.334401) 
.. 
Finished in 73.190988 seconds. 

所以這些方法，似乎Enumerable.dedup算法最好：

• DUP原始數組所以它是不可變的
• 獲取uniq的數組元素
• 爲每個唯一的元素：無第一次出現的DUP陣列中
• 緊湊的結果

如果只有（array - array.uniq）工作正常！ （它不 - 它消除了一切）