Convertir un tableau en un index de hachage en Ruby

Si vous avez besoin de la valeur de hachage est l'adhésion, pensez à utiliser un Set:

Ensemble

Ensemble met en œuvre une collection non ordonnée de valeurs sans
les doublons. C'est un hybride de la Matrice intuitive inter-fonctionnement
les installations de Hachage et de la recherche rapide.

Ensemble est facile à utiliser avec Énumérable objets (mise en œuvre de
each). La plupart de l'initialiseur, les méthodes et les opérateurs binaires accepter
générique Énumérable objets en plus de jeux et de tableaux. Un
Énumérable objet peut être converti à Ensemble à l'aide de la
to_set méthode.

Ensemble utilise le Hachage comme le stockage, vous devez noter les points suivants:

• L'égalité des éléments est déterminée selon Object#eql? et Object#hash.
• Ensemble suppose que l'identité de chaque élément ne change pas alors que c'est stockée. La modification d'un élément d'un jeu au rendu de l'ensemble d'une
  non fiable de l'état.
• Lorsqu'une chaîne est stockée, une copie congelé de la chaîne est stockée au lieu de cela, à moins que la chaîne d'origine est déjà gelé.

Comparaison

Les opérateurs de comparaison <, >, <= et >= sont mis en œuvre comme
raccourci pour l' {proper_,}{sous-ensemble?,sur-ensemble?} des méthodes. Cependant, l'
<=> opérateur est intentionnellement laissé de côté parce que pas chaque paire de
jeux est comparable. ({x,y} vs {x,z} par exemple)

Exemple

require 'set'
s1 = Set.new [1, 2]                   # -> #<Set: {1, 2}>
s2 = [1, 2].to_set                    # -> #<Set: {1, 2}>
s1 == s2                              # -> true
s1.add("foo")                         # -> #<Set: {1, 2, "foo"}>
s1.merge([2, 6])                      # -> #<Set: {1, 2, "foo", 6}>
s1.subset? s2                         # -> false
s2.subset? s1                         # -> true

[...]

Public Les Méthodes De La Classe

nouveau(enum = nil)

Crée un nouvel ensemble contenant les éléments de l'énumération
objet.

Si un bloc est donné, les éléments de l'enum sont prétraitées par l'
bloc donné.

Vous pouvez faire cette astuce bien pratique:

Hash[*[1, 2, 3, 4].map {|k| [k, nil]}.flatten]
=> {1=>nil, 2=>nil, 3=>nil, 4=>nil}

Je suis assez certain qu'il n'y a pas un one-shot moyen astucieux pour construire ce hash. Mon inclination serait d'être explicite et de l'état, ce que je fais:

hash = {}
array.each{|x| hash[x] = nil}

Il n'a pas l'air particulièrement élégant, mais il est clair, et fait le travail.

FWIW, votre proposition initiale (sous Ruby 1.8.6 au moins) ne semble pas fonctionner. Je reçois un "ArgumentError: nombre impair d'arguments en faveur de Hachage" erreur. De hachage.[] s'attend à un littéral, même-lengthed liste de valeurs:

Hash[a, 1, b, 2] # => {a => 1, b => 2}

j'ai donc essayé de changer votre code:

hash = Hash[*array.map {|x| [x, nil]}.flatten]

mais la performance est à dire:

#!/usr/bin/ruby -w
require 'benchmark'

array = (1..100_000).to_a

Benchmark.bm(15) do |x|
  x.report("assignment loop") {hash = {}; array.each{|e| hash[e] = nil}}
  x.report("hash constructor") {hash = Hash[*array.map {|e| [e, nil]}.flatten]}
end

donne

                     user     system      total        real
assignment loop  0.440000   0.200000   0.640000 (  0.657287)
hash constructor  4.440000   0.250000   4.690000 (  4.758663)

À moins que je me manque quelque chose ici, une simple affectation de la boucle semble la plus claire et la plus efficace pour construire ce hachage.

Ta façon de créer de la valeur de hachage semble bon. J'ai eu un muck autour de la cisr et c'est une autre façon

>> [1,2,3,4].inject(Hash.new) { |h,i| {i => nil}.merge(h) }
=> {1=>nil, 2=>nil, 3=>nil, 4=>nil}

Peut-être que je suis mal comprendre le but ici; Si vous avez voulu savoir si X est dans le tableau, pourquoi ne pas le tableau.inclure?("X") ?

Si vous n'êtes pas gêné de ce que les valeurs de hachage sont

irb(main):031:0> a=(1..1_000_000).to_a ; a.length
=> 1000000
irb(main):032:0> h=Hash[a.zip a] ; h.keys.length
=> 1000000

Prend une seconde sur mon bureau.

Voici une belle façon de cache recherches avec un Hachage:

a = (1..1000000).to_a
h = Hash.new{|hash,key| hash[key] = true if a.include? key}

À peu près ce qu'il fait est de créer un constructeur par défaut pour les nouvelles valeurs de hachage, puis les magasins "true" dans le cache si c'est dans le tableau (néant au contraire). Cela permet un chargement différé dans le cache, juste au cas où vous n'utilisez pas tous les éléments.