Removing duplicates and substrings from an array

ruby-talk
1

I've got an array of strings, say like:

["Bob", "John", "Bobby", "John"]

I want to remove duplicates and elements that are substrings of other
elements. Therefore, the above array would become:

["John","Bobby"]

(order doesn't really matter to me, BTW)

Right now, this is what I'm doing:

def remove_duplicates_and_subsequences(some_array)
    result = []
    some_array.each_index do |i|
        (some_array.length-1).downto 0 do |j|
            some_array.delete_at(j) if i != j &&
some_array[i].index(some_array[j])
        end
    end
    return result
end

Is there a better way to do that? I feel like I should be using select or
reject, but can't think of a way to do it.

Thanks,
Sammy Larbi

2

Sam Larbi wrote:

I've got an array of strings, say like:

["Bob", "John", "Bobby", "John"]

I want to remove duplicates and elements that are substrings of other
elements. Therefore, the above array would become:

["John","Bobby"]

["Bob", "John", "Bobby", "John"].uniq!

(or uniq )

···

--
Posted via http://www.ruby-forum.com/\.

3

Sam Larbi wrote:

I've got an array of strings, say like:

["Bob", "John", "Bobby", "John"]

I want to remove duplicates and elements that are substrings of other
elements. Therefore, the above array would become:

["John","Bobby"]

(order doesn't really matter to me, BTW)

Right now, this is what I'm doing:

def remove_duplicates_and_subsequences(some_array)
    result =
    some_array.each_index do |i|
        (some_array.length-1).downto 0 do |j|
            some_array.delete_at(j) if i != j &&
some_array[i].index(some_array[j])
        end
    end
    return result
end

Is there a better way to do that? I feel like I should be using select
or
reject, but can't think of a way to do it.

Thanks,
Sammy Larbi

You tried to use the method uniq?
<code>
[1,2,3,4,1,3].uniq => [1,2,3,4]
</code>

···

--
Posted via http://www.ruby-forum.com/\.

4

You can use Array.uniq to remove duplicates. For removing words that
are contained in other words, I would sort the array, then for each
string in the array:

good_strings =
0.upto(good_strings.length - 2) do |i|
  good_strings << strings[i] unless strings[i + 1].include?(strings[i])
end

...or something like that.

···

On Nov 26, 2007 10:15 AM, Sam Larbi <slarbi@gmail.com> wrote:

I've got an array of strings, say like:

["Bob", "John", "Bobby", "John"]

I want to remove duplicates and elements that are substrings of other
elements. Therefore, the above array would become:

["John","Bobby"]

(order doesn't really matter to me, BTW)

Right now, this is what I'm doing:

def remove_duplicates_and_subsequences(some_array)
    result =
    some_array.each_index do |i|
        (some_array.length-1).downto 0 do |j|
            some_array.delete_at(j) if i != j &&
some_array[i].index(some_array[j])
        end
    end
    return result
end

Is there a better way to do that? I feel like I should be using select or
reject, but can't think of a way to do it.

Thanks,
Sammy Larbi

5

This should work:

arr = ["Bob", "John", "Bobby", "John"]
arr.uniq!
arr.reject {|a| arr.any? {|b| b != a and b =~ /#{a}/}}

Jeremy

···

On Nov 26, 9:15 am, Sam Larbi <sla...@gmail.com> wrote:

Note: parts of this message were removed by the gateway to make it a legal Usenet post.

I've got an array of strings, say like:

["Bob", "John", "Bobby", "John"]

I want to remove duplicates and elements that are substrings of other
elements. Therefore, the above array would become:

["John","Bobby"]

(order doesn't really matter to me, BTW)

Right now, this is what I'm doing:

def remove_duplicates_and_subsequences(some_array)
    result =
    some_array.each_index do |i|
        (some_array.length-1).downto 0 do |j|
            some_array.delete_at(j) if i != j &&
some_array[i].index(some_array[j])
        end
    end
    return result
end

Is there a better way to do that? I feel like I should be using select or
reject, but can't think of a way to do it.

Thanks,
Sammy Larbi

6

I think there could also be a .map solution but I cant figure it out
right now, .uniq just really seems the most simple and elegant for this
given problem at hand

···

--
Posted via http://www.ruby-forum.com/.

7

yermej wrote the following on 26.11.2007 18:15 :

···

On Nov 26, 9:15 am, Sam Larbi <sla...@gmail.com> wrote:
  

Note: parts of this message were removed by the gateway to make it a legal Usenet post.

I've got an array of strings, say like:

["Bob", "John", "Bobby", "John"]

I want to remove duplicates and elements that are substrings of other
elements. Therefore, the above array would become:

["John","Bobby"]

This should work:

arr = ["Bob", "John", "Bobby", "John"]
arr.uniq!
arr.reject {|a| arr.any? {|b| b != a and b =~ /#{a}/}}
  
You'll have surprises if there's a "." element...

arr = ["Bob", "John", "Bobby", "John"]
arr.uniq!
arr.reject {|a| arr.any? {|b| b != a and a.index(b) } }

seems safer and quicker to me.

Lionel

8

Lionel Bouton wrote the following on 26.11.2007 18:20 :

yermej wrote the following on 26.11.2007 18:15 :
  

Note: parts of this message were removed by the gateway to make it a legal Usenet post.

I've got an array of strings, say like:

["Bob", "John", "Bobby", "John"]

I want to remove duplicates and elements that are substrings of other
elements. Therefore, the above array would become:

["John","Bobby"]
      

This should work:

arr = ["Bob", "John", "Bobby", "John"]
arr.uniq!
arr.reject {|a| arr.any? {|b| b != a and b =~ /#{a}/}}
  
You'll have surprises if there's a "." element...

arr = ["Bob", "John", "Bobby", "John"]
arr.uniq!
arr.reject {|a| arr.any? {|b| b != a and a.index(b) } }
  
Oups: I misread the question.

It should be b.index(a) (I rejected the superstrings instead of the
substrings).

Lionel

···

On Nov 26, 9:15 am, Sam Larbi <sla...@gmail.com> wrote:

9

Lionel Bouton wrote:

arr.reject {|a| arr.any? {|b| b != a and a.index(b) } }

I'd make that index into include? because you don't really care about the
index here.

···

--
Jabber: sepp2k@jabber.org
ICQ: 205544826

10

Good point. Thank you.

Jeremy

···

On Nov 26, 11:20 am, Lionel Bouton <lionel-subscript...@bouton.name> wrote:

yermej wrote the following on 26.11.2007 18:15 :

> On Nov 26, 9:15 am, Sam Larbi <sla...@gmail.com> wrote:

>> Note: parts of this message were removed by the gateway to make it a legal Usenet post.

>> I've got an array of strings, say like:

>> ["Bob", "John", "Bobby", "John"]

>> I want to remove duplicates and elements that are substrings of other
>> elements. Therefore, the above array would become:

>> ["John","Bobby"]
> This should work:

> arr = ["Bob", "John", "Bobby", "John"]
> arr.uniq!
> arr.reject {|a| arr.any? {|b| b != a and b =~ /#{a}/}}

You'll have surprises if there's a "." element...

arr = ["Bob", "John", "Bobby", "John"]
arr.uniq!
arr.reject {|a| arr.any? {|b| b != a and a.index(b) } }

seems safer and quicker to me.

Lionel

11

Sebastian Hungerecker wrote the following on 26.11.2007 18:27 :

Lionel Bouton wrote:
  

arr.reject {|a| arr.any? {|b| b != a and a.index(b) } }
    
I'd make that index into include? because you don't really care about the
index here.
  
I agree, the code is then easier to read too.

Lionel

12

Everyone,

···

On Nov 26, 2007 11:51 AM, Lionel Bouton <lionel-subscription@bouton.name> wrote:

Sebastian Hungerecker wrote the following on 26.11.2007 18:27 :
> Lionel Bouton wrote:
>
>> arr.reject {|a| arr.any? {|b| b != a and a.index(b) } }
>>
>
> I'd make that index into include? because you don't really care about
the
> index here.
>

I agree, the code is then easier to read too.

That's precisely what I was looking for (or felt like I should be doing).
Thanks to all for their help!

Sam