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

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

루비에 있는 요소들의 배열을 가지고 있습니다.

[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배열 내에서 전달된 값의 모든 인스턴스가 삭제됩니다.특정 요소의 첫 번째 인스턴스를 삭제하기 위해 다음과 같은 작업을 수행할 수 있습니다.

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

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

더 간단한 방법이 있을 수 있습니다.이것이 최선의 관행이라고 말하는 것은 아니지만, 그것은 인정되어야 할 것입니다.

배열의 여러 위치에서 값으로 3을 삭제하고 싶다고 가정할 때, 이 작업을 수행하는 Ruby 방법은 다음을 사용하는 것입니다.delete_if방법:

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

사용할 수도 있습니다.delete_if배열 배열에서 요소를 제거합니다.

나는 그것을 좋아합니다.-=[4]값이 4인 요소를 삭제하기 위해 다른 답변에 언급된 방법.

하지만 다음과 같은 방법이 있습니다.

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

"Basic Array Operations" 어딘가에서 언급된 후, 다음과 같이 언급되었습니다.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

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

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]

루비에서 삭제할 수 있는 모든 다른 옵션 컴파일

delete - 값별로 일치하는 요소를 삭제합니다.둘 이상의 값이 일치하면 모두 제거됩니다.발생 횟수나 단일 발생에 대한 확신이 없는 경우 이 방법을 사용합니다.

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]

reject - 지정된 블록이 false인 요소가 포함된 새 배열을 반환합니다.이것으로 주문이 유지됩니다.

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

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

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

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

이 삭제 체인화하여 을 계속할 수 또한이삭작체하여일삭항부결목제다배고사작니을체합용을 사용합니다.tap:

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

당신은 또한 그것을 원숭이가 패치할 수 있습니다.나는 루비가 왜 그런 생각을 하는지 절대 이해할 수 없습니다.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]

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

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

따라서 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.

언급URL : https://stackoverflow.com/questions/10034678/how-can-i-delete-one-element-from-an-array-by-value