Jak scalić kolejne powtarzające się elementy w tablicy?

Question

trzeba połączyć kolejno powtarzających się elementów w szeregu, tak że

[1, 2, 2, 3, 1] 

się

[1, 2, 3, 1] 

#uniq nie działa w tym celu. Czemu? Ponieważ #uniq będzie produkować to:

[1, 2, 3] 

Answer 1

def remove_consecutive_duplicates(xs) 
    [xs.first] + xs.each_cons(2).select do |x,y| 
    x != y 
    end.map(&:last) 
end 

remove_consecutive_duplicates([1, 2, 2, 3, 1]) 
#=> [1,2,3,1] 

ta zwraca nową tablicę jak uniq robi i pracuje w O(n) czasie. Odpowiedź

Answer 2

ma !uniq nie pracować, co robisz?

http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_array.html

Answer 3

sepp2k jest już przyjęta, ale oto kilka alternatyw:

# Because I love me some monkeypatching 
class Array 
    def remove_consecutive_duplicates_2 
    # Because no solution is complete without inject 
    inject([]){ |r,o| r << o unless r.last==o; r } 
    end 

    def remove_consecutive_duplicates_3 
    # O(2n) 
    map.with_index{ |o,i| o if i==0 || self[i-1]!=o }.compact 
    end 

    def remove_consecutive_duplicates_4 
    # Truly O(n) 
    result = [] 
    last = nil 
    each do |o| 
     result << o unless last==o 
     last = o 
    end 
    result 
    end 
end 

I chociaż wydajność jest nie wszystko, oto kilka Benchmarki:

Rehearsal -------------------------------------------- 
sepp2k     2.740000   0.010000   2.750000 ( 2.734665) 
Phrogz_2   1.410000   0.000000   1.410000 ( 1.420978) 
Phrogz_3   1.520000   0.020000   1.540000 ( 1.533197) 
Phrogz_4   1.000000   0.000000   1.000000 ( 0.997460) 
----------------------------------- total: 6.700000sec 

               user     system      total        real 
sepp2k     2.780000   0.000000   2.780000 ( 2.782354) 
Phrogz_2   1.450000   0.000000   1.450000 ( 1.440868) 
Phrogz_3   1.530000   0.020000   1.550000 ( 1.539190) 
Phrogz_4   1.020000   0.000000   1.020000 ( 1.025331) 

Benchmarki uruchomić na usuwanie duplikatów od orig = (0..1000).map{ rand(5) } 10 000 razy.

Answer 4

Jest abstrakcją w rdzeniu, że dość dużo robi pracę, Enumerable#chunk:

xs = [1, 2, 2, 3, 3, 3, 1] 
xs.chunk { |x| x }.map(&:first) 
#=> [1, 2, 3, 1]