Excluding first element by value from array

Question

I want to get something like this:

a                       =  [0,1,0,0,1,0,1,0]
a.except(1)           # => [0,0,0,1,0,1,0]
a                     # => [0,1,0,0,1,0,1,0]
a.except(1).except(1) # => [0,0,0,0,1,0]

As you see, the first element of a that equals the argument of except is removed from a.

I can do:

tmp_a = a.dup
tmp_a.delete_at(a.index(1))
tmp_a

but in my opinion, it looks like smell. Is there more elegant one-line solution? (In other words - how to define method "except" for Array?)

UPD

I solved this problem so

class Array
  def except(elem)
    dup.tap{|a| a.delete_at(a.index(elem))}
  end
end

what do you think?

Write a method that encapsulates the element find and slicing. No reason to dupe the array, just take the elements on either side of the value. — Dave Newton, Jul 06 '15 at 12:23
Meta-comment: down-boring an answer because of a misunderstanding seems extreme to me-just comment to clarify and users will police their own content. — Dave Newton, Jul 06 '15 at 12:26
I didn't downvote, however, one of the possible reasons for downvoting mentioned in the tooltip for the downvote button is "This question is unclear", so, if a user feels that the question is unclear, downvoting is perfectly fine. And even if that one user happens to be mistaken, well, there are 4.1 million others which can upvote. — Jörg W Mittag, Jul 06 '15 at 12:38
Could the people who put this question on hold please elaborate what's unclear about it? The Question is pretty much spot-on... — mhutter, Jul 06 '15 at 13:57
Gena, a couple of points about your method `Array#except`: 1) `index`'s argument should be `elem`; 2) `self.` is optional. That is, you write: `dup.tap { |a| a.delete_at(a.index(elem)) }`. — Cary Swoveland, Jul 06 '15 at 20:01
Gena, I liked your use of `tap`, so modified my code for `Array#difference` (at link given in my answer) to use `tap` in place of `cpy = dup`, then `cpy` as the last line. I like the sound of the method, so much so that sometimes I write `obj.tap{}.tap{}.tap { |x| ... }`. — Cary Swoveland, Jul 07 '15 at 07:17

score 2 · Accepted Answer · answered Jul 06 '15 at 13:40

2

What's so "hacky" about your solution?

This is also what first came to my mind (started hacking away before reading the entire question :P)

class Array
  def except(elem)
    tmp = self.dup
    tmp.delete_at(self.index(elem))
    tmp
  end
end

Or you can use the power of delete_if (including count I stole from @mudasobwa 's answer:

class Array
  def except(elem, count = 1)
    tmp = self.dup
    memo = 0
    tmp.delete_if { |e| elem == e && (memo += 1) <= count }
  end
end

Or you can slice your array to bits:

class Array
  def except(elem)
    index = self.index(elem)
    self.slice(0, index) + self.slice(index + 1, self.length)
  end
end

answered Jul 06 '15 at 13:40

mhutter

2,800
22
30

1

Upvoted for `slice` (which I would rewrite as `self[0...index] + self[index+1..-1]`). – Aleksei Matiushkin Jul 06 '15 at 13:44
1

you can replace your `slice` calls with: `reject.with_index { |_, i| i == index }` – Stefan Jul 06 '15 at 13:49
This would be the same as the `delete_if` solution. – mhutter Jul 06 '15 at 13:55
@Manuel Thanks, it seems good. Look my own solution under UPD in question – Gena Shumilkin Jul 06 '15 at 19:36
Ah, very interesting! Didn't know about `tap`! However, I actually prefer your first version because it's much more readable. Technically it's the same solution. – mhutter Jul 07 '15 at 21:07

Aleksei Matiushkin · Answer 2 · 2015-07-06T13:31:48.970

1

class Array
  def except what, count = 1
    memo = 0
    map do |e| 
      what == e && (memo += 1) <= count ? nil : e
    end.compact
  end
end

The above will remove count occurences of what:

a.except(1, 2) 
#⇒ [0,0,0,0,1,0]

edited Jul 06 '15 at 13:31

answered Jul 06 '15 at 13:20

Aleksei Matiushkin

119,336
10
100
160

1

Cool solution, but look out if your array looks like this: `[0, nil, 0, 0, nil, 0, nil, 0]`. But then, who has `nil`s in his arrays anyways... – mhutter Jul 06 '15 at 13:49

score 1 · Answer 3 · edited May 23 '17 at 11:58

1

You could write:

a.difference [1]
  #=> [0,0,0,1,0,1,0] 

a #=> [0,1,0,0,1,0,1,0]

where Array#difference is defined in my answer here.

edited May 23 '17 at 11:58

Community

1
1

answered Jul 07 '15 at 00:51

Cary Swoveland

106,649
6
63
100

It is the same as that of my solution under UPD in question, cool, thanks – Gena Shumilkin Jul 07 '15 at 04:51
When the argument of `difference` is an array containing a single element, yes. – Cary Swoveland Jul 07 '15 at 04:59

Excluding first element by value from array

3 Answers3

Linked