non case sensitive searching

[Adam Akhtar]

If i want to see if a list contains a particular word how would i go
about doing so with letter case not being important. Normally two words
spelt the same are not equal if they differ in case.

i.e. Shell != shell
or ShEll != shell

At first i thought simply conveting both the list and the word to search
into uppercase thus making them the same but doing so would not be very
efficient if the list is very big.

Any ideas??

 

[Stefano Crocco]

Alle Monday 11 February 2008, Adam Akhtar ha scritto:

If i want to see if a list contains a particular word how would i go
about doing so with letter case not being important. Normally two words
spelt the same are not equal if they differ in case.

i.e. Shell != shell
or ShEll != shell

At first i thought simply conveting both the list and the word to search
into uppercase thus making them the same but doing so would not be very
efficient if the list is very big.

Any ideas??

Use String#casecmp. According to ri documentation, it works as String#<=> but
is not case sensitive. For example:

"abc" <=> "Abc"
=> 1

"abc".casecmp "Abc"
=> 0

Stefano

 

[Robert Klemme]

If i want to see if a list contains a particular word how would i go
about doing so with letter case not being important. Normally two words
spelt the same are not equal if they differ in case.

i.e. Shell != shell
or ShEll != shell

At first i thought simply conveting both the list and the word to search
into uppercase thus making them the same but doing so would not be very
efficient if the list is very big.

search_key = something.downcase
list.find {|s| s.downcase == search_key}

robert

 

[7stud --]

If i want to see if a list contains a particular word how would i go
about doing so with letter case not being important. Normally two words
spelt the same are not equal if they differ in case.

i.e. Shell != shell
or ShEll != shell

At first i thought simply conveting both the list and the word to search
into uppercase thus making them the same but doing so would not be very
efficient if the list is very big.

Any ideas??

data = ['ShEll', 'heLLO']

data.each do |word|
if /shell/i =~ word
puts 'found shell'
end

if /hello/i =~ word
puts 'found hello'
end
end

 

[William James]

If i want to see if a list contains a particular word how would i go
about doing so with letter case not being important. Normally two words
spelt the same are not equal if they differ in case.

i.e. Shell != shell
or ShEll != shell

At first i thought simply conveting both the list and the word to search
into uppercase thus making them the same but doing so would not be very
efficient if the list is very big.

%w(hello HELLO Hello hellO hell).grep( /hello/i )
==>["hello", "HELLO", "Hello", "hellO"]

 

[Adam Akhtar]

the reg exp. looks good but when i try to apply it to help me romove
duplicates from a list it doesnt seem to work

list = %w{adam Adam bobby Bobby wild wILd}
list.sort
list.each_index do |x|
list.delete_at(x) if (/list[x]/i =~ list[x+1]) #remove entries which
have same spelling but in diff. case
end
puts ""
puts list

in this list i consider adam and Adam duplicates because they have the
same spelling but only different case. Why doesnt my if clause pick up
on this?

 

[Alex Fenton]

the reg exp. looks good but when i try to apply it to help me romove
duplicates from a list it doesnt seem to work

list = %w{adam Adam bobby Bobby wild wILd}
list.sort
list.each_index do |x|
list.delete_at(x) if (/list[x]/i =~ list[x+1])

here you're literally searching for the text "list[x]", not the value of
that expression. You need to use interpolation to place the value of
that variable into the regular expression. Use #{expr}, like you would
in a string:

list.delete_at(x) if ( /#{list[x]}/i =~ list[x+1])

If your strings might contain punctuation characters, you should also
look into Regexp.escape to ensure these are dealt with safely.

alex

 

[Adam Akhtar]

excellent thanks very much alex for that.

 

[Robert Klemme]

the reg exp. looks good but when i try to apply it to help me romove
duplicates from a list it doesnt seem to work

list = %w{adam Adam bobby Bobby wild wILd}
list.sort

The line above is ineffective because you do not sort the original list.

list.each_index do |x|
list.delete_at(x) if (/list[x]/i =~ list[x+1]) #remove entries which
have same spelling but in diff. case
end
puts ""
puts list

I would use another algorithm because of efficiency:

#!/bin/env ruby

require 'set'

# ensure random order
list = %w{adam Adam bobby Bobby wild wILd}.sort_by { rand }
dups = Set.new

p list
list.delete_if {|w| not dups.add? w.downcase }
p list

Kind regards

robert

 

[William James]

the reg exp. looks good but when i try to apply it to help me romove
duplicates from a list it doesnt seem to work

list = %w{adam Adam bobby Bobby wild wILd}
list.sort

The line above is ineffective because you do not sort the original list.

list.each_index do |x|
list.delete_at(x) if (/list[x]/i =~ list[x+1]) #remove entries which
have same spelling but in diff. case
end
puts ""
puts list

I would use another algorithm because of efficiency:

#!/bin/env ruby

require 'set'

# ensure random order
list = %w{adam Adam bobby Bobby wild wILd}.sort_by { rand }
dups = Set.new

p list
list.delete_if {|w| not dups.add? w.downcase }
p list

We don't need sets for this.

list = %w{adam Adam bobby Bobby wild wILd}.sort_by { rand }
==>["wild", "bobby", "Bobby", "wILd", "Adam", "adam"]
list.map{|x| x.upcase}.uniq
==>["WILD", "BOBBY", "ADAM"]

First "inject"; now, a set fetish?

 

[7stud --]

the reg exp. looks good

You should never consider a regex good looking. regexes should be
avoided whenever possible in favor of String methods. Better solutions
have been posted.

I would use another algorithm because of efficiency:

list.delete_if

Repeatedly deleting elements from the middle of an array is certainly
not efficient. Also, suppose the results are:

[Adam Bobby wILd]

Looking at the results, you would have no way of knowing whether there
were duplicates spelled: adam, bobby, and wild. Therefore, the case of
the results appears to be irrelevant. If the case of the results is
irrelevant, then just providing the set is enough:


require 'set'

# ensure random order
list = %w{adam Adam bobby Bobby wild wILd}.sort_by { rand }

results = Set.new
list.each do |elmt|
results << elmt.downcase
end

p results

--output:--
#<Set: {"bobby", "wild", "adam"}>

 

[Robert Klemme]

the reg exp. looks good but when i try to apply it to help me romove
duplicates from a list it doesnt seem to work

list = %w{adam Adam bobby Bobby wild wILd}
list.sort

The line above is ineffective because you do not sort the original list.

list.each_index do |x|
list.delete_at(x) if (/list[x]/i =~ list[x+1]) #remove entries which
have same spelling but in diff. case
end
puts ""
puts list

I would use another algorithm because of efficiency:

#!/bin/env ruby

require 'set'

# ensure random order
list = %w{adam Adam bobby Bobby wild wILd}.sort_by { rand }
dups = Set.new

p list
list.delete_if {|w| not dups.add? w.downcase }
p list

We don't need sets for this.

list = %w{adam Adam bobby Bobby wild wILd}.sort_by { rand }
==>["wild", "bobby", "Bobby", "wILd", "Adam", "adam"]
list.map{|x| x.upcase}.uniq
==>["WILD", "BOBBY", "ADAM"]

As far as I can see the requirement was to remove duplicates and not
to output a uniform cased list.

Cheers

robert

 

[Robert Klemme]

You should never consider a regex good looking. regexes should be
avoided whenever possible in favor of String methods. Better solutions
have been posted.

I would not subscribe to that rule. Often regular expressions are
faster than pure String based approaches - it depends on the issue at
hand.

I would use another algorithm because of efficiency:

list.delete_if

Repeatedly deleting elements from the middle of an array is certainly
not efficient. Also, suppose the results are:

[Adam Bobby wILd]

Looking at the results, you would have no way of knowing whether there
were duplicates spelled: adam, bobby, and wild. Therefore, the case of
the results appears to be irrelevant. If the case of the results is
irrelevant, then just providing the set is enough:

Alternatively one could use a Hash to preserve all spellings:

irb(main):001:0> list = %w{adam Adam bobby Bobby wild wILd}.sort_by { rand }
=> ["wild", "wILd", "Adam", "adam", "Bobby", "bobby"]
irb(main):002:0> res = Hash.new {|h,k| h[k]=[]}
=> {}
irb(main):003:0> list.each {|w| res[w.downcase] << w}
=> ["wild", "wILd", "Adam", "adam", "Bobby", "bobby"]
irb(main):004:0> res
=> {"bobby"=>["Bobby", "bobby"], "wild"=>["wild", "wILd"],
"adam"=>["Adam", "adam"]}
irb(main):005:0>

It all depends...

Cheers

robert

 

[William James]

2008/2/12, William James <[email protected]>:

2008/2/12, Adam Akhtar <[email protected]>:
the reg exp. looks good but when i try to apply it to help me romove
duplicates from a list it doesnt seem to work
list = %w{adam Adam bobby Bobby wild wILd}
list.sort
The line above is ineffective because you do not sort the original list.
list.each_index do |x|
list.delete_at(x) if (/list[x]/i =~ list[x+1]) #remove entries which
have same spelling but in diff. case
end
puts ""
puts list
I would use another algorithm because of efficiency:
#!/bin/env ruby
require 'set'
# ensure random order
list = %w{adam Adam bobby Bobby wild wILd}.sort_by { rand }
dups = Set.new
p list
list.delete_if {|w| not dups.add? w.downcase }
p list

We don't need sets for this.

list = %w{adam Adam bobby Bobby wild wILd}.sort_by { rand }
==>["wild", "bobby", "Bobby", "wILd", "Adam", "adam"]
list.map{|x| x.upcase}.uniq
==>["WILD", "BOBBY", "ADAM"]

As far as I can see the requirement was to remove duplicates and not
to output a uniform cased list.

1. My solution removed duplicates.
2. To output a uniform-cased list does no harm since
case is irrelevant.

Using plain Ruby is shorter, easier, and clearer.
There's no rational reason to require sets.

Learn to use Ruby. It's a very powerful language;
so powerful, in fact, that I seldom have to use
external libraries.

 

[James Gray]

Learn to use Ruby. It's a very powerful language;
so powerful, in fact, that I seldom have to use
external libraries.

Or manners, it would seem.

James Edward Gray II