Ruby에서 다른 배열에 배열을 어떻게 추가하고 다차원 결과로 끝나지 않습니까?

somearray = ["some", "thing"]

anotherarray = ["another", "thing"]

somearray.push(anotherarray.flatten!)

기대했다

["some","thing","another","thing"]

당신은 실행 가능한 아이디어를 가지고 있지만,이 #flatten!잘못된 위치에 - 당신은 설정하는 데 사용할 수 있도록 그것은 수신기를 평평 [1, 2, ['foo', 'bar']]에 [1,2,'foo','bar'].

의심 할 여지없이 일부 접근 방식을 잊어 버릴 수 있지만 연결할 수는 있습니다 .

a1.concat a2
a1 + a2              # creates a new array, as does a1 += a2

또는 추가 / 추가 :

a1.push(*a2)         # note the asterisk
a2.unshift(*a1)      # note the asterisk, and that a2 is the receiver

또는 스플 라이스 :

a1[a1.length, 0] = a2
a1[a1.length..0] = a2
a1.insert(a1.length, *a2)

또는 추가하고 평평 :

(a1 << a2).flatten!  # a call to #flatten instead would return a new array

당신은 +연산자를 사용할 수 있습니다 !

irb(main):001:0> a = [1,2]
=> [1, 2]
irb(main):002:0> b = [3,4]
=> [3, 4]
irb(main):003:0> a + b
=> [1, 2, 3, 4]

http://ruby-doc.org/core/classes/Array.html : 배열 클래스에 대한 모든 것을 읽을 수 있습니다

가장 깨끗한 방법은 Array # concat 메서드 를 사용하는 것입니다. 동일한 배열을 수행하지만 새 배열을 만드는 Array # +와 달리 새 배열을 만들지 않습니다.

문서에서 바로 ( http://www.ruby-doc.org/core-1.9.3/Array.html#method-i-concat ) :

concat (other_ary)

other_ary의 요소를 self에 추가합니다.

그래서

[1,2].concat([3,4])  #=> [1,2,3,4]  

Array # concat 은 다차원 배열을 인수로 전달하면 평탄화하지 않습니다. 별도로 처리해야합니다.

arr= [3,[4,5]]
arr= arr.flatten   #=> [3,4,5]
[1,2].concat(arr)  #=> [1,2,3,4,5]

마지막으로, corelib gem ( https://github.com/corlewsolutions/corelib )을 사용하면 Ruby 핵심 클래스에 유용한 도우미를 추가 할 수 있습니다. 특히 concat을 실행하기 전에 다차원 배열을 자동으로 병합 하는 Array # add_all 메소드가 있습니다.

Ruby 버전> = 2.0에서 작동하지만 이전 버전에서는 작동하지 않는 쉬운 방법 :

irb(main):001:0> a=[1,2]
=> [1, 2]
irb(main):003:0> b=[3,4]
=> [3, 4]
irb(main):002:0> c=[5,6]
=> [5, 6]
irb(main):004:0> [*a,*b,*c]
=> [1, 2, 3, 4, 5, 6]

이것을 시도하십시오, 그것은 중복을 제거하는 배열을 결합합니다

array1 = ["foo", "bar"]
array2 = ["foo1", "bar1"]

array3 = array1|array2

http://www.ruby-doc.org/core/classes/Array.html

추가 문서는 "Set Union"을 참조하십시오.

두 가지 방법이 있습니다.이 경우 첫 번째 방법은 새 배열을 할당합니다 (somearray = somearray + anotherarray로 변환 됨)

somearray = ["some", "thing"]

anotherarray = ["another", "thing"]

somearray += anotherarray # => ["some", "thing", "another", "thing"]

somearray = ["some", "thing"]
somearray.concat anotherarray # => ["some", "thing", "another", "thing"]

a = ["some", "thing"]
b = ["another", "thing"]

추가하기 b로 a하고에 결과를 저장 a:

a.push(*b)

또는

a += b

두 경우 모두 다음과 a같습니다.

["some", "thing", "another", "thing"]

전자의 경우 b기존 a배열에 요소 가 추가되고 후자의 경우 두 배열이 함께 연결되어 결과가에 저장됩니다 a.

(array1 + array2).uniq

이런 식으로 array1 요소를 먼저 얻습니다. 중복은 없습니다.

@Pilcrow의 답변을 자세히 설명하면 거대한 배열에 적합한 유일한 대답은 concat( +) 빠르고 빠르며 루프 내부에서 작동 할 때 가비지 수집 할 새 객체를 할당하지 않기 때문입니다.

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

require 'benchmark'

huge_ary_1 = Array.new(1_000_000) { rand(5_000_000..30_000_00) }

huge_ary_2 = Array.new(1_000_000) { rand(35_000_000..55_000_00) }

Benchmark.bm do |bm|
  p '-------------------CONCAT ----------------'
  bm.report { huge_ary_1.concat(huge_ary_2) }

  p '------------------- PUSH ----------------'
  bm.report { huge_ary_1.push(*huge_ary_2)  }
end

결과 :

       user     system      total        real
"-------------------CONCAT ----------------"
  0.000000   0.000000   0.000000 (  0.009388)
"------------------- PUSH ----------------"
  example/array_concat_vs_push.rb:13:in `block (2 levels) in <main>': stack level too deep (SystemStackError)

사용 볼 수 있듯이 push발생 오류 : stack level too deep (SystemStackError)배열이 충분히 큰 경우.

본질적으로 문제는 "루비에서 배열을 연결하는 방법"입니다. 당연히 대답은 거의 모든 대답에서 언급 concat했거나 사용 +하는 것입니다.

이 질문에 대한 자연스러운 확장은 "루비에서 2D 배열의 행 단위 연결을 수행하는 방법"입니다. "ruby concatenate matrices"를봤을 때,이 SO 질문이 최고의 결과 였으므로 후손을 위해 그 질문에 대한 답을 남겨 두겠다고 생각했습니다.

일부 응용 프로그램에서는 두 개의 2D 배열을 행 단위로 "연결"할 수 있습니다. 같은 것

[[a, b], | [[x],    [[a, b, x],
 [c, d]] |  [y]] =>  [c, d, y]]

이것은 행렬을 "증강"하는 것과 같습니다. 예를 들어,이 기법을 사용하여 단일 인접 행렬을 만들어 여러 개의 작은 행렬에서 그래프를 나타냅니다. 이 기술이 없다면 오류가 발생하기 쉽고 생각하기 힘들었던 방식으로 구성 요소를 반복해야했습니다. each_with_index예 를 들어을해야했을 수도 있습니다 . 대신 다음과 같이 지퍼를 결합 하고 평평하게 했습니다.

# given two multi-dimensional arrays that you want to concatenate row-wise
m1 = [[:a, :b], [:c, :d]]
m2 = [[:x], [:y]]

m1m2 = m1.zip(m2).map(&:flatten)
# => [[:a, :b, :x], [:c, :d, :y]]

또 다른 방법입니다.

[somearray, anotherarray].flatten
=> ["some", "thing", "another", "thing"]

["some", "thing"] + ["another" + "thing"]

새 데이터가 배열 또는 스칼라 일 수 있고 새 데이터가 배열 인 경우 중첩되지 않도록하려면 splat 연산자가 훌륭합니다! 스칼라에 대한 스칼라와 배열에 대한 압축 해제 된 인수 목록을 리턴합니다.

1.9.3-p551 :020 > a = [1, 2]
 => [1, 2] 
1.9.3-p551 :021 > b = [3, 4]
 => [3, 4] 
1.9.3-p551 :022 > c = 5
 => 5 
1.9.3-p551 :023 > a.object_id
 => 6617020 
1.9.3-p551 :024 > a.push *b
 => [1, 2, 3, 4] 
1.9.3-p551 :025 > a.object_id
 => 6617020 
1.9.3-p551 :026 > a.push *c
 => [1, 2, 3, 4, 5] 
1.9.3-p551 :027 > a.object_id
 => 6617020 

아무도 언급하지 않았는데 reduce, 배열 배열이있을 때 잘 작동합니다.

lists = [["a", "b"], ["c", "d"]]
flatlist = lists.reduce(:+)  # ["a", "b", "c", "d"]

a = ['a', 'b']
b = ['c', 'd']
arr = [a, b].flatten

이것은 멍청이를 제거하지는 않지만

a|b

딥을 제거합니다.

다음과 같이 배열을 밀어 넣거나 추가하고 평평하게 배치하는 것이 더 쉽다는 것을 알았습니다.

somearray = ["some", "thing"]
anotherarray = ["another", "thing"]
somearray.push anotherarray # => ["some", "thing", ["another", "thing"]]
#or
somearray << anotherarray # => ["some", "thing", ["another", "thing"]]
somearray.flatten!  # => ["some", "thing", "another", "thing"]
somearray # => ["some", "thing", "another", "thing"]

somearray = [ "some", "thing"]

anotherarray = [ "다른", "것" "

somearray + anotherarray