값으로 배열에서 하나의 요소를 삭제하는 방법

Ruby에 요소 배열이 있습니다.

[2,4,6,3,8]

3예를 들어 값이있는 요소를 제거해야합니다

어떻게합니까?

나는 그것을 이해했다고 생각합니다.

a = [3, 2, 4, 6, 3, 8]
a.delete(3)
#=> 3
a
#=> [2, 4, 6, 8]

의견 에서 Travis 에서 빌린 경우 더 나은 답변입니다.

나는 개인적으로 같은 [1, 2, 7, 4, 5] - [7]에서 어떤 결과 => [1, 2, 4, 5]에서irb

3이 그의 예제 배열에서 세 번째 요소라는 것을 알면서 그의 대답을 수정했습니다. 이것은 3이 배열에서 2 위에 있다는 것을 모르는 사람들에게 혼란을 초래할 수 있습니다.

다른 옵션 :

a = [2,4,6,3,8]

a -= [3]

결과

=> [2, 4, 6, 8] 

누군가가 이것을 언급했는지 확실하지 않지만 Array.delete () 및-= value 는 Array 내에서 전달 된 값의 모든 인스턴스를 삭제합니다. 특정 요소의 첫 번째 인스턴스를 삭제하려면 다음과 같이 할 수 있습니다

arr = [1,3,2,44,5]
arr.delete_at(arr.index(44))

#=> [1,3,2,5]

더 간단한 방법이있을 수 있습니다. 나는 이것이 최선의 방법이라고 말하는 것이 아니라 인식해야 할 것입니다.

배열의 여러 위치에서 값으로 3을 삭제하려고한다고 가정하면이 작업을 수행하는 루비 방법은 delete_if 메소드를 사용하는 것입니다.

[2,4,6,3,8,3].delete_if {|x| x == 3 } 

'배열 배열'시나리오에서 요소를 제거 할 때 delete_if를 사용할 수도 있습니다.

이것이 귀하의 쿼리를 해결하기를 바랍니다.

나는 ~을 좋아한다 -=[4] 다른 답변에서 언급 된 방식이 값이 4 인 요소를 삭제하는 .

그러나이 방법이 있습니다 :

irb(main):419:0> [2,4,6,3,8,6].delete_if{|i|i==6}
=> [2, 4, 3, 8]
irb(main):420:0>

함수를 언급 한 후 " 기본 배열 연산 " 어딘가에 언급되었습니다 map.

간단하게 실행할 수 있습니다.

[2,4,6,3,8].delete(3)

A는 .delete_at(3) 3여기에 위치되고.

벤치 마크는 다음과 같습니다.

require 'fruity'


class Array          
  def rodrigo_except(*values)
    self - values
  end    

  def niels_except value
    value = value.kind_of?(Array) ? value : [value]
    self - value
  end
end

ARY = [2,4,6,3,8]

compare do
  soziev  { a = ARY.dup; a.delete(3);               a }
  steve   { a = ARY.dup; a -= [3];                  a }
  barlop  { a = ARY.dup; a.delete_if{ |i| i == 3 }; a }
  rodrigo { a = ARY.dup; a.rodrigo_except(3);         }
  niels   { a = ARY.dup; a.niels_except(3);           }
end

# >> Running each test 4096 times. Test will take about 2 seconds.
# >> soziev is similar to barlop
# >> barlop is faster than steve by 2x ± 1.0
# >> steve is faster than rodrigo by 4x ± 1.0
# >> rodrigo is similar to niels

그리고 다시 많은 중복을 포함하는 더 큰 배열이 있습니다.

class Array          
  def rodrigo_except(*values)
    self - values
  end    

  def niels_except value
    value = value.kind_of?(Array) ? value : [value]
    self - value
  end
end

ARY = [2,4,6,3,8] * 1000

compare do
  soziev  { a = ARY.dup; a.delete(3);               a }
  steve   { a = ARY.dup; a -= [3];                  a }
  barlop  { a = ARY.dup; a.delete_if{ |i| i == 3 }; a }
  rodrigo { a = ARY.dup; a.rodrigo_except(3);         }
  niels   { a = ARY.dup; a.niels_except(3);           }
end

# >> Running each test 16 times. Test will take about 1 second.
# >> steve is faster than soziev by 30.000000000000004% ± 10.0%
# >> soziev is faster than barlop by 50.0% ± 10.0%
# >> barlop is faster than rodrigo by 3x ± 0.1
# >> rodrigo is similar to niels

그리고 더 많은 중복으로 더 큰 :

class Array          
  def rodrigo_except(*values)
    self - values
  end    

  def niels_except value
    value = value.kind_of?(Array) ? value : [value]
    self - value
  end
end

ARY = [2,4,6,3,8] * 100_000

compare do
  soziev  { a = ARY.dup; a.delete(3);               a }
  steve   { a = ARY.dup; a -= [3];                  a }
  barlop  { a = ARY.dup; a.delete_if{ |i| i == 3 }; a }
  rodrigo { a = ARY.dup; a.rodrigo_except(3);         }
  niels   { a = ARY.dup; a.niels_except(3);           }
end

# >> Running each test once. Test will take about 6 seconds.
# >> steve is similar to soziev
# >> soziev is faster than barlop by 2x ± 0.1
# >> barlop is faster than niels by 3x ± 1.0
# >> niels is similar to rodrigo

Niels의 솔루션을 개선했습니다.

class Array          
  def except(*values)
    self - values
  end    
end

이제 사용할 수 있습니다

[1, 2, 3, 4].except(3, 4) # return [1, 2]
[1, 2, 3, 4].except(4)    # return [1, 2, 3]

당신은 또한 원숭이 패치 할 수 있습니다. Ruby가 왜 except메소드를 가지고 있는지 이해 Hash하지 못했습니다 Array.

class Array
  def except value
    value = value.kind_of(Array) ? value : [value]
    self - value
  end
end

이제 할 수있는 일 :

[1,3,7,"436",354,nil].except(354) #=> [1,3,7,"436",nil]

또는:

[1,3,7,"436",354,nil].except([354, 1]) #=> [3,7,"436",nil]

따라서 3이 여러 번 발생하고 3을 처음 만 삭제하려는 경우 다음과 같이 간단히 할 수 있습니다.

arr = [2, 4, 6, 3, 8, 10, 3, 12]

arr.delete_at arr.index 3

#This will modify arr as [2, 4, 6, 8, 10, 3, 12] where first occurrence of 3 is deleted. Returns the element deleted. In this case => 3.

첫 번째 발생의 비파괴 제거 :

a = [2, 4, 6, 3, 8]
n = a.index 3
a.take(n)+a.drop(n+1)

이 삭제 작업을 체인 가능하게 만들려면 일부 항목을 삭제하고 결과 배열에서 체인 작업을 계속하려면 tap다음을 사용하십시오 .

[2, 4, 6, 3, 8].tap { |ary| ary.delete(3) }.count #=> 4

루비에서 삭제에 대한 모든 다른 옵션을 컴파일

삭제 - 삭제가 값을 기준으로 요소를 일치. 둘 이상의 값이 일치하면 모두 제거됩니다. 발생 횟수에 신경 쓰지 않거나 단일 발생에 대해 확실하지 않은 경우이 방법을 사용하십시오.

a = [2, 6, 3, 5, 3, 7]
a.delete(3)  # returns 3
puts a       # return [2, 6, 5, 7]

delete_at- 주어진 색인에서 요소를 삭제합니다. 색인을 알고있는 경우이 방법을 사용하십시오.

# continuing from the above example
a.delete_at(2) # returns 5
puts a         # returns [2, 6, 7]

delete_if- 블록이 참인 모든 요소를 ​​삭제합니다. 배열이 수정됩니다. 블록이 호출되면 즉시 배열이 변경됩니다.

b = [1, 2, 5, 4, 9, 10, 11]
b.delete_if {|n| n >= 10}.  # returns [1, 2, 5, 4, 9]

거부 -주어진 블록이 거짓 인 요소를 가진 새로운 배열을 반환합니다. 이것으로 순서가 유지됩니다.

c = [1, 2, 5, 4, 9, 10, 11]
c.reject {|n| n >= 10}.  # returns [1, 2, 5, 4, 9]

받지 않다! -delete_if 와 동일 . 블록이 호출 될 때 배열이 즉시 변경되지 않을 수 있습니다.

배열에서 여러 값을 삭제하려면 가장 좋은 옵션은 다음과 같습니다.

a = [2, 3, 7, 4, 6, 21, 13]
b = [7, 21]
a = a - b    # a - [2, 3, 4, 6, 13]