Come si uniscono gli elementi ripetuti consecutivi in ​​un array?

Question

Ho bisogno di unire elementi ripetuti consecutivi in ​​una matrice, in modo tale che

[1, 2, 2, 3, 1] 

diventa

[1, 2, 3, 1] 

#uniq non funziona per questo scopo. Perché? Perché #uniq produrrà questo:

[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] 

Ciò restituisce un nuovo array come uniq fa e lavora a O(n) tempo. risposta

Answer 2

fa !uniq non funziona per quello che stai facendo?

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

Answer 3

di sepp2k è già accettata, ma qui ci sono alcune alternative:

# 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 

E anche se la prestazione è non tutto, qui ci sono alcuni benchmark:

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) 

benchmark eseguito su rimozione dei duplicati da orig = (0..1000).map{ rand(5) } 10.000 volte.

Answer 4

C'è un'astrazione nel nucleo che fa più o meno il lavoro, Enumerable#chunk:

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