Chia mảng thành mảng phụ dựa trên giá trị

Question

Tôi đang tìm kiếm một mảng tương đương String#split trong Ruby Core và ngạc nhiên khi thấy rằng nó không tồn tại. Có một cách thanh lịch hơn sau đây để tách một mảng thành mảng phụ dựa trên một giá trị?

class Array 
    def split(split_on=nil) 
    inject([[]]) do |a,v| 
     a.tap{ 
     if block_given? ? yield(v) : v==split_on 
      a << [] 
     else 
      a.last << v 
     end 
     } 
    end.tap{ |a| a.pop if a.last.empty? } 
    end 
end 

p (1..9).to_a.split{ |i| i%3==0 }, 
    (1..10).to_a.split{ |i| i%3==0 } 
#=> [[1, 2], [4, 5], [7, 8]] 
#=> [[1, 2], [4, 5], [7, 8], [10]] 

Sửa: Đối với những người quan tâm, những "thực tế" Vấn đề mà gây ra yêu cầu này có thể được nhìn thấy trong this answer, nơi tôi đã sử dụng @ câu trả lời fd của dưới đây để thực hiện.

Answer 1

Tôi đã cố gắng chơi golf nó một chút, vẫn không phải là một phương pháp duy nhất mặc dù:

(1..9).chunk{|i|i%3==0}.reject{|sep,ans| sep}.map{|sep,ans| ans} 

Hoặc nhanh hơn:

(1..9).chunk{|i|i%3==0 || nil}.map{|sep,ans| sep&&ans}.compact 

Ngoài ra, Enumerable#chunk có vẻ là Ruby 1.9+, nhưng nó rất gần với những gì bạn muốn.

Ví dụ, sản lượng nguyên liệu sẽ là:

(1..9).chunk{ |i|i%3==0 }.to_a          
=> [[false, [1, 2]], [true, [3]], [false, [4, 5]], [true, [6]], [false, [7, 8]], [true, [9]]] 

(Các to_a là làm cho IRB in cái gì đó tốt đẹp, kể từ chunk mang đến cho bạn một Enumerator hơn là một mảng)

---

Chỉnh sửa: Lưu ý rằng các giải pháp thanh lịch ở trên chậm hơn 2-3 lần so với triển khai nhanh nhất:

module Enumerable 
    def split_by 
    result = [a=[]] 
    each{ |o| yield(o) ? (result << a=[]) : (a << o) } 
    result.pop if a.empty? 
    result 
    end 
end 

Answer 2

Enumerable Các phương pháp khác bạn có thể muốn xem xét là each_slice hoặc each_cons

Tôi không biết nói chung làm thế nào bạn muốn nó được, đây là một cách

>> (1..9).each_slice(3) {|a| p a.size>1?a[0..-2]:a} 
[1, 2] 
[4, 5] 
[7, 8] 
=> nil 
>> (1..10).each_slice(3) {|a| p a.size>1?a[0..-2]:a} 
[1, 2] 
[4, 5] 
[7, 8] 
[10] 

Answer 3

Dưới đây là các tiêu chuẩn tập hợp các câu trả lời (tôi sẽ không được chấp nhận câu trả lời này):

require 'benchmark' 
a = *(1..5000); N = 1000 
Benchmark.bmbm do |x| 
    %w[ split_with_inject split_with_inject_no_tap split_with_each 
     split_with_chunk split_with_chunk2 split_with_chunk3 ].each do |method| 
    x.report(method){ N.times{ a.send(method){ |i| i%3==0 || i%5==0 } } } 
    end 
end 
#=>        user  system  total  real 
#=> split_with_inject   1.857000 0.015000 1.872000 ( 1.879188) 
#=> split_with_inject_no_tap 1.357000 0.000000 1.357000 ( 1.353135) 
#=> split_with_each   1.123000 0.000000 1.123000 ( 1.123113) 
#=> split_with_chunk   3.962000 0.000000 3.962000 ( 3.984398) 
#=> split_with_chunk2   3.682000 0.000000 3.682000 ( 3.687369) 
#=> split_with_chunk3   2.278000 0.000000 2.278000 ( 2.281228) 

Việc triển khai đang được thử nghiệm (trên Ruby 1.9.2):

class Array 
    def split_with_inject 
    inject([[]]) do |a,v| 
     a.tap{ yield(v) ? (a << []) : (a.last << v) } 
    end.tap{ |a| a.pop if a.last.empty? } 
    end 

    def split_with_inject_no_tap 
    result = inject([[]]) do |a,v| 
     yield(v) ? (a << []) : (a.last << v) 
     a 
    end 
    result.pop if result.last.empty? 
    result 
    end 

    def split_with_each 
    result = [a=[]] 
    each{ |o| yield(o) ? (result << a=[]) : (a << o) } 
    result.pop if a.empty? 
    result 
    end 

    def split_with_chunk 
    chunk{ |o| !!yield(o) }.reject{ |b,a| b }.map{ |b,a| a } 
    end 

    def split_with_chunk2 
    chunk{ |o| !!yield(o) }.map{ |b,a| b ? nil : a }.compact 
    end 

    def split_with_chunk3 
    chunk{ |o| yield(o) || nil }.map{ |b,a| b && a }.compact 
    end 
end 

Answer 4

đây là một một (với một chuẩn mực so sánh nó với nhanh nhất split_with_each đây https://stackoverflow.com/a/4801483/410102):

require 'benchmark' 

class Array 
    def split_with_each 
    result = [a=[]] 
    each{ |o| yield(o) ? (result << a=[]) : (a << o) } 
    result.pop if a.empty? 
    result 
    end 

    def split_with_each_2 
    u, v = [], [] 
    each{ |x| (yield x) ? (u << x) : (v << x) } 
    [u, v] 
    end 
end 

a = *(1..5000); N = 1000 
Benchmark.bmbm do |x| 
    %w[ split_with_each split_with_each_2 ].each do |method| 
    x.report(method){ N.times{ a.send(method){ |i| i%3==0 || i%5==0 } } } 
    end 
end 

         user  system  total  real 
split_with_each  2.730000 0.000000 2.730000 ( 2.742135) 
split_with_each_2 2.270000 0.040000 2.310000 ( 2.309600) 

Answer 5

Somet imes partition là một cách tốt để làm những việc như thế:

(1..6).partition { |v| v.even? } 
#=> [[2, 4, 6], [1, 3, 5]]