Xóa các phần tử trùng lặp khỏi mảng trong Ruby

Tôi có một mảng Ruby chứa các phần tử trùng lặp.

array = [1,2,2,1,4,4,5,6,7,8,5,6]

Làm cách nào tôi có thể xóa tất cả các phần tử trùng lặp khỏi mảng này trong khi vẫn giữ lại tất cả các phần tử duy nhất mà không cần sử dụng vòng lặp for và vòng lặp?

array = array.uniq

uniq loại bỏ tất cả các phần tử trùng lặp và giữ lại tất cả các phần tử duy nhất trong mảng.

Đây là một trong nhiều người đẹp của ngôn ngữ Ruby.

Bạn có thể trả lại giao lộ.

a = [1,1,2,3]
a & a

Điều này cũng sẽ xóa các bản sao.

Bạn có thể xóa các phần tử trùng lặp bằng phương thức uniq:

array.uniq  # => [1, 2, 4, 5, 6, 7, 8]

Điều cũng có thể hữu ích để biết là uniqmất một khối, vì vậy nếu bạn có một mảng các phím:

["bucket1:file1", "bucket2:file1", "bucket3:file2", "bucket4:file2"]

và bạn muốn biết các tệp duy nhất là gì, bạn có thể tìm ra nó với:

a.uniq { |f| f[/\d+$/] }.map { |p| p.split(':').last }

Chỉ là một sự thay thế khác nếu có ai quan tâm.

Bạn cũng có thể sử dụng to_setphương thức của một mảng chuyển đổi Mảng thành Tập hợp và theo định nghĩa, các phần tử tập hợp là duy nhất.

[1,2,3,4,5,5,5,6].to_set => [1,2,3,4,5,6]

Nếu ai đó đang tìm cách loại bỏ tất cả các phiên bản của các giá trị lặp lại, hãy xem " Làm cách nào tôi có thể trích xuất hiệu quả các phần tử lặp lại trong một mảng Ruby? ".

a = [1, 2, 2, 3]
counts = Hash.new(0)
a.each { |v| counts[v] += 1 }
p counts.select { |v, count| count == 1 }.keys # [1, 3]

Chỉ để cung cấp một số cái nhìn sâu sắc:

require 'fruity'
require 'set'

array = [1,2,2,1,4,4,5,6,7,8,5,6] * 1_000

def mithun_sasidharan(ary)
  ary.uniq
end

def jaredsmith(ary)
  ary & ary
end

def lri(ary)
  counts = Hash.new(0)
  ary.each { |v| counts[v] += 1 }
  counts.select { |v, count| count == 1 }.keys 
end

def finks(ary)
  ary.to_set
end

def santosh_mohanty(ary)
    result = ary.reject.with_index do |ele,index|
      res = (ary[index+1] ^ ele)
      res == 0
    end
end

SHORT_ARRAY = [1,1,2,2,3,1]
mithun_sasidharan(SHORT_ARRAY) # => [1, 2, 3]
jaredsmith(SHORT_ARRAY) # => [1, 2, 3]
lri(SHORT_ARRAY) # => [3]
finks(SHORT_ARRAY) # => #<Set: {1, 2, 3}>
santosh_mohanty(SHORT_ARRAY) # => [1, 2, 3, 1]

puts 'Ruby v%s' % RUBY_VERSION

compare do
  _mithun_sasidharan { mithun_sasidharan(array) }
  _jaredsmith { jaredsmith(array) }
  _lri { lri(array) }
  _finks { finks(array) }
  _santosh_mohanty { santosh_mohanty(array) }
end

Mà, khi chạy, kết quả là:

# >> Ruby v2.7.1
# >> Running each test 16 times. Test will take about 2 seconds.
# >> _mithun_sasidharan is faster than _jaredsmith by 2x ± 0.1
# >> _jaredsmith is faster than _santosh_mohanty by 4x ± 0.1 (results differ: [1, 2, 4, 5, 6, 7, 8] vs [1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, ...
# >> _santosh_mohanty is similar to _lri (results differ: [1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, 7, 8, 5, 6, 1, 2, 1, 4, 5, 6, ...
# >> _lri is similar to _finks (results differ: [] vs #<Set: {1, 2, 4, 5, 6, 7, 8}>)

Lưu ý: những kết quả trả về xấu này:

• lri(SHORT_ARRAY) # => [3]
• finks(SHORT_ARRAY) # => #<Set: {1, 2, 3}>
• santosh_mohanty(SHORT_ARRAY) # => [1, 2, 3, 1]

Hãy thử sử dụng toán tử XOR mà không sử dụng các hàm tích hợp:

a = [3,2,3,2,3,5,6,7].sort!

result = a.reject.with_index do |ele,index|
  res = (a[index+1] ^ ele)
  res == 0
end

print result

Với các chức năng tích hợp:

a = [3,2,3,2,3,5,6,7]

a.uniq