web-dev-qa-db-fra.com

Array Merge (Union)

J'ai deux tableaux dont je dois fusionner, et l'utilisation de l'opérateur Union (|) est DOUCEMENT lente.

De plus, les tableaux sont remplis d'objets, pas de chaînes.

Un exemple des objets dans le tableau

#<Article 
 id: 1, 
 xml_document_id: 1, 
 source: "<article><domain>events.waikato.ac</domain><excerpt...", 
 created_at: "2010-02-11 01:32:46", 
 updated_at: "2010-02-11 01:41:28"
>

Où source est un petit morceau de XML.

MODIFIER

Pardon! Par "fusionner", je veux dire que je n'ai pas besoin d'insérer de doublons.

A => [1, 2, 3, 4, 5]
B => [3, 4, 5, 6, 7]
A.magic_merge(B) #=> [1, 2, 3, 4, 5, 6, 7]

Comprendre que les entiers sont en fait des objets Article et que l'opérateur Union semble prendre pour toujours

ruby-on-railsrubyarrays
35
Rabbott

Voici un script qui compare deux techniques de fusion: en utilisant l'opérateur pipe (a1 | a2), Et en utilisant concaténation et uniq ((a1 + a2).uniq). Deux repères supplémentaires donnent le temps de concaténation et d'uniq individuellement.

require 'benchmark'

a1 = []; a2 = []
[a1, a2].each do |a|
  1000000.times { a << Rand(999999) }
end

puts "Merge with pipe:"
puts Benchmark.measure { a1 | a2 }

puts "Merge with concat and uniq:"
puts Benchmark.measure { (a1 + a2).uniq }

puts "Concat only:"
puts Benchmark.measure { a1 + a2 }

puts "Uniq only:"
b = a1 + a2
puts Benchmark.measure { b.uniq }

Sur ma machine (Ubuntu Karmic, Ruby 1.8.7), j'obtiens une sortie comme celle-ci:

Merge with pipe:
  1.000000   0.030000   1.030000 (  1.020562)
Merge with concat and uniq:
  1.070000   0.000000   1.070000 (  1.071448)
Concat only:
  0.010000   0.000000   0.010000 (  0.005888)
Uniq only:
  0.980000   0.000000   0.980000 (  0.981700)

Ce qui montre que ces deux techniques sont très similaires en vitesse, et que uniq est la composante la plus importante de l'opération. Cela a un sens intuitivement, étant O(n) (au mieux), alors que la concaténation simple est O (1).

Donc, si vous voulez vraiment accélérer cela, vous devez voir comment l'opérateur <=> Est implémenté pour les objets de vos tableaux. Je crois que la plupart du temps est passé à comparer des objets pour garantir l'inégalité entre n'importe quelle paire dans le tableau final.

62
Alex Reisner

Avez-vous besoin que les éléments soient dans un ordre spécifique dans les tableaux? Sinon, vous pouvez vérifier si l'utilisation de Sets accélère.

Mise à jour

Ajout au code d'un autre répondeur:

require "set"
require "benchmark"

a1 = []; a2 = []
[a1, a2].each do |a|
  1000000.times { a << Rand(999999) }
end

s1, s2 = Set.new, Set.new

[s1, s2].each do |s|
  1000000.times { s << Rand(999999) }
end

puts "Merge with pipe:"
puts Benchmark.measure { a1 | a2 }

puts "Merge with concat and uniq:"
puts Benchmark.measure { (a1 + a2).uniq }

puts "Concat only:"
puts Benchmark.measure { a1 + a2 }

puts "Uniq only:"
b = a1 + a2
puts Benchmark.measure { b.uniq }

puts "Using sets"
puts Benchmark.measure {s1 + s2}

puts "Starting with arrays, but using sets"
puts Benchmark.measure {s3, s4 = [a1, a2].map{|a| Set.new(a)} ; (s3 + s4)}

donne (pour Ruby 1.8.7 (2008-08-11 patchlevel 72) [universal-darwin10.0])

Merge with pipe:
  1.320000   0.040000   1.360000 (  1.349563)
Merge with concat and uniq:
  1.480000   0.030000   1.510000 (  1.512295)
Concat only:
  0.010000   0.000000   0.010000 (  0.019812)
Uniq only:
  1.460000   0.020000   1.480000 (  1.486857)
Using sets
  0.310000   0.010000   0.320000 (  0.321982)
Starting with arrays, but using sets
  2.340000   0.050000   2.390000 (  2.384066)

Suggère que les ensembles peuvent être plus rapides ou non, selon votre situation (beaucoup de fusions ou pas beaucoup de fusions).

7
Andrew Grimm

En utilisant le Array#concat la méthode sera probablement beaucoup plus rapide, selon mes repères initiaux en utilisant Ruby 1.8.7:

require 'benchmark'

def reset_arrays!
  @array1 = []
  @array2 = []

  [@array1, @array2].each do |array|
    10000.times { array << ActiveSupport::SecureRandom.hex }
  end
end

reset_arrays! && puts(Benchmark.measure { @array1 | @array2 })
# => 0.030000   0.000000   0.030000 (  0.026677)

reset_arrays! && puts(Benchmark.measure { @array1.concat(@array2) })
# => 0.000000   0.000000   0.000000 (  0.000122)
1
Josh Delsman

Essayez ceci et voyez si c'est plus rapide

a = [1,2,3,3,2]
b = [1,2,3,4,3,2,5,7]
(a+b).uniq
1
nas