반복되는 배열 요소에서 제거

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

배열의 각 요소에 대해 카운트를 축적하는 해시를 사용하여 펄 프로그래머에 의해 사용되는 솔루션 : 그가에 선 사이의 세미콜론의 현명한 사용에 의해, 모든 중요한 경우

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] 

그것은 나를 조금 이해하기가 어렵에 그래서, 정말 개선하지, 그리고 map{...}.compact와 select{...}.keys을 대체합니다.

Answer 5

이렇게 뭔가가 필요했기 때문에 몇 가지 다른 접근법이 테스트되었습니다. 첫 번째 정수의 배열, 문자열의 다음 배열로, 10 만 반복에 대한

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 결과 :이 모든 원본 배열에서 중복 된 항목의 배열을 반환합니다. 성능이 발견 중복의 numer에에 따라 달라질 수 있지만,이 테스트는 중복 고정 수 (~ 반 배열 항목이 중복입니다)에 있습니다

이러한 접근 방식 그래서, Enumerable.dedup 알고리즘이 보인다

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. 

가장 : 원래 배열 DUP

• 는
• 가 UNIQ 어레이 요소마다 고유 요소
• 얻는다 불변하므로 다음 DUP 어레이를 선두 닐을
• 결과 압축하기

(array - array.uniq)가 올바르게 작동하면! (모든 것을 제거하지 않습니다.)