«

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

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/.

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/.

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/.

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

This should work:

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

Jeremy

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

Lionel Bouton wrote the following on 26.11.2007 18:20 :
> 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) } }
>

Oups: I misread the question.

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

Lionel

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:
ICQ: 205544826

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

Good point. Thank you.

Jeremy

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