Cách tìm và trả về một giá trị trùng lặp trong mảng

arr là mảng các chuỗi:

["hello", "world", "stack", "overflow", "hello", "again"]

Điều gì sẽ là một cách dễ dàng và thanh lịch để kiểm tra nếu arrcó trùng lặp, và nếu vậy, trả lại một trong số chúng (bất kể đó là gì)?

Ví dụ:

["A", "B", "C", "B", "A"]    # => "A" or "B"
["A", "B", "C"]              # => nil

a = ["A", "B", "C", "B", "A"]
a.detect{ |e| a.count(e) > 1 }

Tôi biết đây không phải là câu trả lời rất tao nhã, nhưng tôi thích nó. Đó là một mã lót đẹp. Và hoạt động hoàn toàn tốt trừ khi bạn cần xử lý tập dữ liệu khổng lồ.

Tìm kiếm giải pháp nhanh hơn? Bạn đi đây!

def find_one_using_hash_map(array)
  map = {}
  dup = nil
  array.each do |v|
    map[v] = (map[v] || 0 ) + 1

    if map[v] > 1
      dup = v
      break
    end
  end

  return dup
end

Đó là tuyến tính, O (n), nhưng bây giờ cần quản lý nhiều dòng mã, cần các trường hợp thử nghiệm, v.v.

Nếu bạn cần một giải pháp thậm chí nhanh hơn, có thể thử C thay thế.

Và đây là ý chính so sánh các giải pháp khác nhau: https://gist.github.com/naveed-ahmad/8f0b926ffccf5fbd206a1cc58ce9743e

Bạn có thể làm điều này theo một số cách, với tùy chọn đầu tiên là nhanh nhất:

ary = ["A", "B", "C", "B", "A"]

ary.group_by{ |e| e }.select { |k, v| v.size > 1 }.map(&:first)

ary.sort.chunk{ |e| e }.select { |e, chunk| chunk.size > 1 }.map(&:first)

Và tùy chọn O (N ^ 2) (nghĩa là kém hiệu quả hơn):

ary.select{ |e| ary.count(e) > 1 }.uniq

Đơn giản chỉ cần tìm trường hợp đầu tiên trong đó chỉ mục của đối tượng (đếm từ bên trái) không bằng chỉ mục của đối tượng (tính từ bên phải).

arr.detect {|e| arr.rindex(e) != arr.index(e) }

Nếu không có trùng lặp, giá trị trả về sẽ là con số không.

Tôi tin rằng đây là giải pháp nhanh nhất được đăng trong luồng cho đến nay, vì nó không phụ thuộc vào việc tạo thêm các đối tượng #indexvà #rindexđược triển khai trong C. Thời gian chạy big-O là N ^ 2 và do đó chậm hơn Của Sergio, nhưng thời gian trên tường có thể nhanh hơn nhiều do thực tế là các phần "chậm" chạy trong C.

detectchỉ tìm thấy một bản sao. find_allsẽ tìm thấy tất cả:

a = ["A", "B", "C", "B", "A"]
a.find_all { |e| a.count(e) > 1 }

Dưới đây là hai cách khác để tìm một bản sao.

Sử dụng một bộ

require 'set'

def find_a_dup_using_set(arr)
  s = Set.new
  arr.find { |e| !s.add?(e) }
end

find_a_dup_using_set arr
  #=> "hello" 

Sử dụng selectthay thế findđể trả về một mảng của tất cả các bản sao.

Sử dụng Array#difference

class Array
  def difference(other)
    h = other.each_with_object(Hash.new(0)) { |e,h| h[e] += 1 }
    reject { |e| h[e] > 0 && h[e] -= 1 }
  end
end

def find_a_dup_using_difference(arr)
  arr.difference(arr.uniq).first
end

find_a_dup_using_difference arr
  #=> "hello" 

Thả .firstđể trả về một mảng của tất cả các bản sao.

Cả hai phương thức trả về nilnếu không có trùng lặp.

Tôi đề xuất rằngArray#difference sẽ được thêm vào lõi Ruby. Thêm thông tin trong câu trả lời của tôi ở đây .

Điểm chuẩn

Hãy so sánh các phương pháp được đề xuất. Đầu tiên, chúng ta cần một mảng để thử nghiệm:

CAPS = ('AAA'..'ZZZ').to_a.first(10_000)
def test_array(nelements, ndups)
  arr = CAPS[0, nelements-ndups]
  arr = arr.concat(arr[0,ndups]).shuffle
end

và một phương pháp để chạy điểm chuẩn cho các mảng thử nghiệm khác nhau:

require 'fruity'

def benchmark(nelements, ndups)
  arr = test_array nelements, ndups
  puts "\n#{ndups} duplicates\n"    
  compare(
    Naveed:    -> {arr.detect{|e| arr.count(e) > 1}},
    Sergio:    -> {(arr.inject(Hash.new(0)) {|h,e| h[e] += 1; h}.find {|k,v| v > 1} ||
                     [nil]).first },
    Ryan:      -> {(arr.group_by{|e| e}.find {|k,v| v.size > 1} ||
                     [nil]).first},
    Chris:     -> {arr.detect {|e| arr.rindex(e) != arr.index(e)} },
    Cary_set:  -> {find_a_dup_using_set(arr)},
    Cary_diff: -> {find_a_dup_using_difference(arr)}
  )
end

Tôi không bao gồm câu trả lời của @ JjP vì chỉ có một bản sao được trả lại và khi câu trả lời của anh ấy / cô ấy được sửa đổi để làm điều đó giống như câu trả lời trước đó của @ Naveed. Tôi cũng không bao gồm câu trả lời của @ Marin, trong khi được đăng trước câu trả lời của @ Naveed, đã trả lại tất cả các bản sao thay vì chỉ một (một điểm nhỏ nhưng không có điểm nào đánh giá cả hai, vì chúng giống hệt nhau khi trả về chỉ một bản sao).

Tôi cũng đã sửa đổi các câu trả lời khác trả về tất cả các bản sao để trả về chỉ một câu trả lời đầu tiên được tìm thấy, nhưng về cơ bản nó sẽ không ảnh hưởng đến hiệu suất, vì chúng đã tính toán tất cả các bản sao trước khi chọn một bản sao.

Kết quả cho mỗi điểm chuẩn được liệt kê từ nhanh nhất đến chậm nhất:

Đầu tiên giả sử mảng chứa 100 phần tử:

benchmark(100, 0)
0 duplicates
Running each test 64 times. Test will take about 2 seconds.
Cary_set is similar to Cary_diff
Cary_diff is similar to Ryan
Ryan is similar to Sergio
Sergio is faster than Chris by 4x ± 1.0
Chris is faster than Naveed by 2x ± 1.0

benchmark(100, 1)
1 duplicates
Running each test 128 times. Test will take about 2 seconds.
Cary_set is similar to Cary_diff
Cary_diff is faster than Ryan by 2x ± 1.0
Ryan is similar to Sergio
Sergio is faster than Chris by 2x ± 1.0
Chris is faster than Naveed by 2x ± 1.0

benchmark(100, 10)
10 duplicates
Running each test 1024 times. Test will take about 3 seconds.
Chris is faster than Naveed by 2x ± 1.0
Naveed is faster than Cary_diff by 2x ± 1.0 (results differ: AAC vs AAF)
Cary_diff is similar to Cary_set
Cary_set is faster than Sergio by 3x ± 1.0 (results differ: AAF vs AAC)
Sergio is similar to Ryan

Bây giờ hãy xem xét một mảng với 10.000 phần tử:

benchmark(10000, 0)
0 duplicates
Running each test once. Test will take about 4 minutes.
Ryan is similar to Sergio
Sergio is similar to Cary_set
Cary_set is similar to Cary_diff
Cary_diff is faster than Chris by 400x ± 100.0
Chris is faster than Naveed by 3x ± 0.1

benchmark(10000, 1)
1 duplicates
Running each test once. Test will take about 1 second.
Cary_set is similar to Cary_diff
Cary_diff is similar to Sergio
Sergio is similar to Ryan
Ryan is faster than Chris by 2x ± 1.0
Chris is faster than Naveed by 2x ± 1.0

benchmark(10000, 10)
10 duplicates
Running each test once. Test will take about 11 seconds.
Cary_set is similar to Cary_diff
Cary_diff is faster than Sergio by 3x ± 1.0 (results differ: AAE vs AAA)
Sergio is similar to Ryan
Ryan is faster than Chris by 20x ± 10.0
Chris is faster than Naveed by 3x ± 1.0

benchmark(10000, 100)
100 duplicates
Cary_set is similar to Cary_diff
Cary_diff is faster than Sergio by 11x ± 10.0 (results differ: ADG vs ACL)
Sergio is similar to Ryan
Ryan is similar to Chris
Chris is faster than Naveed by 3x ± 1.0

Lưu ý rằng find_a_dup_using_difference(arr)sẽ hiệu quả hơn nhiều nếuArray#difference được triển khai trong C, đó là trường hợp nếu nó được thêm vào lõi Ruby.

Phần kết luận

Nhiều câu trả lời là hợp lý nhưng sử dụng Set là sự lựa chọn tốt nhất rõ ràng . Nó là nhanh nhất trong các trường hợp trung bình, khớp nhanh nhất trong các trường hợp khó nhất và chỉ trong các trường hợp tầm thường tính toán - khi sự lựa chọn của bạn không thành vấn đề - dù sao nó cũng có thể bị đánh bại.

Một trường hợp rất đặc biệt mà bạn có thể chọn giải pháp của Chris sẽ là nếu bạn muốn sử dụng phương pháp này để tách riêng hàng ngàn mảng nhỏ và mong muốn tìm thấy một bản sao thường có ít hơn 10 mục. Điều này sẽ nhanh hơn một chút vì nó tránh được chi phí bổ sung nhỏ khi tạo Set.

Than ôi hầu hết các câu trả lời là O(n^2).

Đây là một O(n)giải pháp,

a = %w{the quick brown fox jumps over the lazy dog}
h = Hash.new(0)
a.find { |each| (h[each] += 1) == 2 } # => 'the"

Sự phức tạp của điều này là gì?

• Chạy vào O(n)và nghỉ ở trận đầu tiên
• Sử dụng O(n)bộ nhớ, nhưng chỉ số lượng tối thiểu

Bây giờ, tùy thuộc vào mức độ thường xuyên trùng lặp trong mảng của bạn, những thời gian chạy này thực sự có thể trở nên tốt hơn nữa. Ví dụ: nếu mảng kích thước O(n)đã được lấy mẫu từ một nhóm k << ncác yếu tố khác nhau thì chỉ có độ phức tạp cho cả thời gian chạy và không gian O(k), tuy nhiên nhiều khả năng là áp phích gốc đang xác thực đầu vào và muốn đảm bảo không có trùng lặp. Trong trường hợp đó, cả độ phức tạp của thời gian chạy và bộ nhớ O(n)vì chúng tôi hy vọng các phần tử không có sự lặp lại cho phần lớn các đầu vào.

Các đối tượng Ruby Array có một phương thức tuyệt vời select,.

select {|item| block } → new_ary
select → an_enumerator

Các hình thức đầu tiên là những gì bạn quan tâm ở đây. Nó cho phép bạn chọn các đối tượng vượt qua một bài kiểm tra.

Các đối tượng Ruby Array có một phương thức khác , count.

count → int
count(obj) → int
count { |item| block } → int

Trong trường hợp này, bạn quan tâm đến các bản sao (các đối tượng xuất hiện nhiều lần trong mảng). Các thử nghiệm thích hợp là a.count(obj) > 1.

Nếu a = ["A", "B", "C", "B", "A"], sau đó

a.select{|item| a.count(item) > 1}.uniq
=> ["A", "B"]

Bạn nói rằng bạn chỉ muốn một đối tượng. Vì vậy, chọn một.

find_all () trả về một arraychứa tất cả các yếu tố của enummà blockkhông phải là false.

Để có được duplicatecác yếu tố

>> arr = ["A", "B", "C", "B", "A"]
>> arr.find_all { |x| arr.count(x) > 1 }

=> ["A", "B", "B", "A"]

Hoặc uniqcác yếu tố trùng lặp

>> arr.find_all { |x| arr.count(x) > 1 }.uniq
=> ["A", "B"] 

Một cái gì đó như thế này sẽ làm việc

arr = ["A", "B", "C", "B", "A"]
arr.inject(Hash.new(0)) { |h,e| h[e] += 1; h }.
    select { |k,v| v > 1 }.
    collect { |x| x.first }

Nghĩa là, đặt tất cả các giá trị vào hàm băm trong đó khóa là thành phần của mảng và giá trị là số lần xuất hiện. Sau đó chọn tất cả các yếu tố xảy ra nhiều hơn một lần. Dễ dàng.

Tôi biết chủ đề này là về Ruby cụ thể, nhưng tôi đã đến đây để tìm cách làm điều này trong bối cảnh của Ruby on Rails với ActiveRecord và nghĩ rằng tôi cũng sẽ chia sẻ giải pháp của mình.

class ActiveRecordClass < ActiveRecord::Base
  #has two columns, a primary key (id) and an email_address (string)
end

ActiveRecordClass.group(:email_address).having("count(*) > 1").count.keys

Ở trên trả về một mảng của tất cả các địa chỉ email được sao chép trong bảng cơ sở dữ liệu của ví dụ này (trong Rails sẽ là "active_record_groupes").

a = ["A", "B", "C", "B", "A"]
a.each_with_object(Hash.new(0)) {|i,hash| hash[i] += 1}.select{|_, count| count > 1}.keys

Đây là một O(n)thủ tục.

Ngoài ra, bạn có thể làm một trong những dòng sau. Cũng O (n) nhưng chỉ một lần lặp

a.each_with_object(Hash.new(0).merge dup: []){|x,h| h[:dup] << x if (h[x] += 1) == 2}[:dup]

a.inject(Hash.new(0).merge dup: []){|h,x| h[:dup] << x if (h[x] += 1) == 2;h}[:dup]

Dưới đây là ý kiến ​​của tôi về một tập hợp dữ liệu lớn - chẳng hạn như bảng dBase kế thừa để tìm các phần trùng lặp

# Assuming ps is an array of 20000 part numbers & we want to find duplicates
# actually had to it recently.
# having a result hash with part number and number of times part is 
# duplicated is much more convenient in the real world application
# Takes about 6  seconds to run on my data set
# - not too bad for an export script handling 20000 parts

h = {};

# or for readability

h = {} # result hash
ps.select{ |e| 
  ct = ps.count(e) 
  h[e] = ct if ct > 1
}; nil # so that the huge result of select doesn't print in the console

r = [1, 2, 3, 5, 1, 2, 3, 1, 2, 1]

r.group_by(&:itself).map { |k, v| v.size > 1 ? [k] + [v.size] : nil }.compact.sort_by(&:last).map(&:first)

each_with_object là bạn của bạn!

input = [:bla,:blubb,:bleh,:bla,:bleh,:bla,:blubb,:brrr]

# to get the counts of the elements in the array:
> input.each_with_object({}){|x,h| h[x] ||= 0; h[x] += 1}
=> {:bla=>3, :blubb=>2, :bleh=>2, :brrr=>1}

# to get only the counts of the non-unique elements in the array:
> input.each_with_object({}){|x,h| h[x] ||= 0; h[x] += 1}.reject{|k,v| v < 2}
=> {:bla=>3, :blubb=>2, :bleh=>2}

Mã này sẽ trả về danh sách các giá trị trùng lặp. Khóa băm được sử dụng như một cách hiệu quả để kiểm tra giá trị nào đã được nhìn thấy. Dựa trên việc giá trị đã được nhìn thấy hay chưa, mảng ban đầu aryđược phân chia thành 2 mảng: thứ nhất chứa các giá trị duy nhất và thứ hai chứa các bản sao.

ary = ["hello", "world", "stack", "overflow", "hello", "again"]

hash={}
arr.partition { |v| hash.has_key?(v) ? false : hash[v]=0 }.last.uniq

=> ["hello"]

Bạn có thể rút ngắn hơn nữa - mặc dù với chi phí cú pháp phức tạp hơn một chút - theo mẫu này:

hash={}
arr.partition { |v| !hash.has_key?(v) && hash[v]=0 }.last.uniq

a = ["A", "B", "C", "B", "A"]
b = a.select {|e| a.count(e) > 1}.uniq
c = a - b
d = b + c

Các kết quả

 d
=> ["A", "B", "C"]

Nếu bạn đang so sánh hai mảng khác nhau (thay vì một mảng so với chính nó), một cách rất nhanh là sử dụng toán tử giao nhau &được cung cấp bởi lớp Array của Ruby .

# Given
a = ['a', 'b', 'c', 'd']
b = ['e', 'f', 'c', 'd']

# Then this...
a & b # => ['c', 'd']

Tôi cần tìm hiểu xem có bao nhiêu bản sao và chúng là gì nên tôi đã viết một chức năng xây dựng từ những gì Naveed đã đăng trước đó:

def print_duplicates(array)
  puts "Array count: #{array.count}"
  map = {}
  total_dups = 0
  array.each do |v|
    map[v] = (map[v] || 0 ) + 1
  end

  map.each do |k, v|
    if v != 1
      puts "#{k} appears #{v} times"
      total_dups += 1
    end
  end
  puts "Total items that are duplicated: #{total_dups}"
end

1. Hãy tạo phương thức sao chép lấy mảng các phần tử làm đầu vào
2. Trong phần thân phương thức, hãy tạo 2 đối tượng mảng mới, một đối tượng được nhìn thấy và một đối tượng khác được nhân đôi
3. cuối cùng cho phép lặp qua từng đối tượng trong mảng đã cho và với mỗi lần lặp cho phép tìm đối tượng đó tồn tại trong mảng nhìn thấy.
4. nếu đối tượng tồn tại trong saw_array, thì nó được coi là đối tượng trùng lặp và đẩy đối tượng đó vào trùng lặp_array
5. nếu đối tượng không tồn tại trong cái nhìn, thì nó được coi là đối tượng duy nhất và đẩy đối tượng đó vào saw_array

hãy chứng minh trong việc thực thi mã

def duplication given_array
  seen_objects = []
  duplication_objects = []

  given_array.each do |element|
    duplication_objects << element if seen_objects.include?(element)
    seen_objects << element
  end

  duplication_objects
end

Bây giờ gọi phương thức sao chép và kết quả trả về đầu ra -

dup_elements = duplication [1,2,3,4,4,5,6,6]
puts dup_elements.inspect

[1,2,3].uniq!.nil? => true [1,2,3,3].uniq!.nil? => false

Lưu ý ở trên là phá hoại