Ruby compare si los elementos de la matriz son uno de estos caracteres

g = [["xx", "A"],­ ["xx", "B"]]­
g.any?{­|x,y| y.eq­l? ("A"|­|"B"||"C"­)}

Quiero evaluar si el segundo elemento en el subconjunto es uno de "A" o "B" o "C". En el caso anterior debería volver true. Y volver false, ejemplo, if g=[["xx","K"]["xx","B"].

preguntado el 28 de julio de 12 a las 08:07

Será mejor que formatee su código, meta.stackexchange.com/questions/22186/… -

4 Respuestas

Qué tal si:

g.all? { |x,y| y =~ /^(A|B|C)$/ }

Editar: después de la observación de @PriteshJ

Respondido 28 Jul 12, 10:07

también puede usar /^[ABC]$/ en lugar de /^(A|B|C)$/ - Pritesh jainista

Creo que el ("A" || "B" || "C") siempre te da "A".

  g.each{|x, y| puts "ABC".include? y}

Respondido 28 Jul 12, 09:07

Se me ocurre una combinación de las dos respuestas anteriores.

1.9.3p194 :177 > g =[["xx", "A"],["xx", "B"]]
 => [["xx", "A"], ["xx", "B"]] 
1.9.3p194 :178 > g.all?  {|i,v| "ABC".include?v}
 => true  #correctly return true
1.9.3p194 :179 > g =[["xx", "A"],["xx", "Ba"]]
 => [["xx", "A"], ["xx", "Ba"]] 
1.9.3p194 :180 > g.all?  {|i,v| "ABC".include?v}
 => false #correctly return false

EDITAR Después de los puntos de referencia Inspirado en la respuesta de @victor

array= ['A','B','C']
g.all? { |x,y| arr.include?y

y

h = {"A" => true, "B" => true, "C" => true}
g.all? { |x,y| h.has_key?(y)

son ganadores.

Inspirado por la respuesta de @victor de Benchmark

require 'benchmark'

many = 500000

g = [["x", "A"], ["xx", "B"]]
h = {"A" => true, "B" => true, "C" => true}
arr = ['A','B','C']

Benchmark.bm do |b|
  b.report("regexp1\t") {many.times { g.all? { |x,y| y =~ /^(A|B|C)$/} } }
  b.report("regexp2\t") { many.times { g.all? { |x,y| y =~ /^[ABC]$/ } } }
  b.report("hash\t") { many.times { g.all? { |x,y| h.has_key?(y) } } }
  b.report("str include\t") { many.times { g.all? { |x,y| "ABC".include?y } } }
  b.report("array include\t") { many.times { g.all? { |x,y| arr.include?y } } }
end

#Output 
       user     system      total        real
regexp1           0.640000   0.000000   0.640000 (  0.635750)
regexp2           0.580000   0.000000   0.580000 (  0.586788)
hash              0.370000   0.000000   0.370000 (  0.364140)
str include       0.430000   0.010000   0.440000 (  0.439753)
array include     0.380000   0.010000   0.390000 (  0.381149)

Saludos.

Respondido 31 Jul 12, 06:07

Gracias PriteshJ por todos los detalles. - Selvam

Parece que el buen hash antiguo es más rápido que la expresión regular:

require 'benchmark'

many = 500000

g = [["x", "A"], ["xx", "B"]]
h = {"A" => true, "B" => true, "C" => true}
Benchmark.bm do |b|
  b.report("regexp") { many.times { g.all? { |x,y| y =~ /^(A|B|C)$/ } } }
  b.report("hash") { many.times { g.all? { |x,y| h.has_key?(y) } } }
end

# regexp  1.690000   0.000000   1.690000 (  1.694377)
# hash  1.040000   0.000000   1.040000 (  1.040016)

Respondido 28 Jul 12, 13:07

muy bueno @Victor Moroz mira mi actualización y encontré algo más interesante :) - Pritesh jainista

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.