Usuń zduplikowane elementy z tablicy w Ruby

325

Mam tablicę Ruby, która zawiera zduplikowane elementy.

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

Jak mogę usunąć wszystkie zduplikowane elementy z tej tablicy, zachowując wszystkie unikalne elementy bez użycia pętli for i iteracji?

Mithun Sasidharan
źródło

Odpowiedzi:

722
array = array.uniq

uniq usuwa wszystkie zduplikowane elementy i zachowuje wszystkie unikalne elementy w tablicy.

To jedna z wielu piękności języka Ruby.

Mithun Sasidharan
źródło
50
nie, uniq! metoda zwróci zero, jeśli tablica była jeszcze unikalna Ex: a = [1,2,3,4] a.uniq -> [1,2,3,4], ale a.uniq! -> zero
duykhoa
15
tak naprawdę nie postrzegałbym tego jako piękna języka ruby ​​... to po prostu piękno standardowej biblioteki ruby? nie zrozumcie mnie źle, w języku jest wiele pięknych rzeczy.
Justin L.,
7
napisz to samo w Objective-C, JavaScript i PHP. Powiedz nam, że Ruby nie jest pięknym językiem!
Adam Waite
3
Działa to również w przypadku złożonych typów: [{how: "are"}, {u:"doing"}, {how: "are"}].uniq => [{:how=>"are"}, {:u=>"doing"}]
Blaskovicz
5
o tym, co mówi @duykhoa, uniq! metoda zwraca zero, ale zwykle nie zależy ci na zwrocie, .uniq!ponieważ działa na samym obiekcie
carpinchosaurio
82

Możesz zwrócić skrzyżowanie.

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

Spowoduje to również usunięcie duplikatów.

jaredsmith
źródło
12
Funkcjonalnie ta odpowiedź jest poprawna, ale myślę, że jest to znacznie mniej czytelne niż tylko użycie uniq.
Fiona T
21
Właśnie umieszczałem go tutaj, aby ktokolwiek odwiedził tę stronę, zobaczył również inne sposoby, aby to zrobić, nie próbowałem powiedzieć, że jest lepszy w jakikolwiek sposób.
jaredsmith
3
Powodem tego jest to, że podczas korzystania z operacji ustawiania, wynikowa tablica jest traktowana jako zbiór, który jest strukturą danych, która zwykle nie ma powtarzalnych wartości. Użycie a | a(union) zrobiłoby tę samą sztuczkę.
Cezar
47

Możesz usunąć zduplikowane elementy za pomocą metody uniq:

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

Warto również wiedzieć, że uniqzajmuje blok, więc jeśli masz tablicę kluczy:

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

i chcesz wiedzieć, jakie są unikalne pliki, możesz to sprawdzić za pomocą:

a.uniq { |f| f[/\d+$/] }.map { |p| p.split(':').last }
Marek Příhoda
źródło
5
Trochę mnie to zagubiło. Blok jest używany, jeśli potrzebujesz własnej funkcji porównawczej - w twoim przykładzie wysłanie uniqdo tej tablicy bez bloku zwróciłoby tę samą wartość, co w przypadku twojego bloku.
hdgarrood
18

To kolejna alternatywa dla kogo to obchodzi.

Możesz także użyć to_setmetody tablicy, która konwertuje tablicę na zbiór, a elementy zestawu są z definicji unikalne.

[1,2,3,4,5,5,5,6].to_set => [1,2,3,4,5,6]
Finks
źródło
4
Jeśli zależy ci na pamięci, to_setprzydzieli 4 obiekty, a uniqprzydzieli jeden.
Jan Klimo
18

Jeśli ktoś szukał sposobu na usunięcie wszystkich wystąpień powtarzających się wartości, zobacz „W jaki sposób mogę skutecznie wyodrębnić powtarzające się elementy w tablicy 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]
Lri
źródło
3
Lub może po prostu zrobić a = [1, 2, 2, 3] a.find_all { |x| a.count(x) == 1 } # [1, 3]
Tim Wright
Połączone pytanie nie jest takie samo; Pyta, jak znaleźć zduplikowane wartości i zwrócić je. OP chce usunąć duplikaty.
Tin Man
0

Aby zapewnić wgląd:

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

Co po uruchomieniu powoduje:

# >> 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}>)

Uwaga: te zwróciły złe wyniki:

  • lri(SHORT_ARRAY) # => [3]
  • finks(SHORT_ARRAY) # => #<Set: {1, 2, 3}>
  • santosh_mohanty(SHORT_ARRAY) # => [1, 2, 3, 1]
Blaszany Człowiek
źródło
-4

Spróbuj użyć operatora XOR, bez korzystania z wbudowanych funkcji:

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

Dzięki wbudowanym funkcjom:

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

a.uniq
Santosh Mohanty
źródło
2
Nie przegłosowałem i nie wiem prawie nic o Ruby, ale czy nie jest .sort!też wbudowaną funkcją?
Carolus