रूबी

Question

में बराबर भागों में एक सरणी को विभाजित करना मुझे बराबर आकार की दूसरी सरणी के भीतर सरणी के एक समूह में एक सरणी को विभाजित करने का एक तरीका चाहिए। किसी के पास ऐसा करने का कोई तरीका है?

उदाहरण के लिए

a = [0, 1, 2, 3, 4, 5, 6, 7] 
a.method_i_need(3) 
a.inspect 
    => [[0,1,2], [3,4,5], [6,7]] 

Answer 1

आप Enumerable#each_slice

a = [0, 1, 2, 3, 4, 5, 6, 7] 
a.each_slice(3) # => #<Enumerator: [0, 1, 2, 3, 4, 5, 6, 7]:each_slice(3)> 
a.each_slice(3).to_a # => [[0, 1, 2], [3, 4, 5], [6, 7]] 

Answer 2

लिए देख रहे हैं की कोशिश करो

a.in_groups_of(3,false) 

यह अपनी नौकरी

Answer 3

शायद मैं questi ग़लत व्याख्या कर रहा हूँ क्या करेंगे चूंकि दूसरा उत्तर पहले से ही स्वीकार कर लिया गया है, लेकिन ऐसा लगता है कि आप सरणी को 3 बराबर समूहों में विभाजित करना चाहते थे, चाहे प्रत्येक समूह के आकार के बावजूद, इसे पिछले उत्तरों के रूप में 3 के एन समूहों में विभाजित करने के बजाय।

a = [0,1,2,3,4,5,6] 
a.in_groups(2) # => [[0,1,2,3],[4,5,6,nil]] 
a.in_groups(3, false) # => [[0,1,2],[3,4], [5,6]] 

मुझे नहीं लगता कि एक गहरे लाल रंग का बराबर होती है, हालांकि, आप लगभग एक ही परिणाम इस जोड़कर प्राप्त कर सकते हैं करते हैं: अगर है कि आप के लिए, रेल (ActiveSupport) क्या देख रहे हैं यह भी एक विधि in_groups कहा जाता है सरल विधि:

class Array; def in_groups(num_groups) 
    return [] if num_groups == 0 
    slice_size = (self.size/Float(num_groups)).ceil 
    groups = self.each_slice(slice_size).to_a 
end; end 

a.in_groups(3) # => [[0,1,2], [3,4,5], [6]] 

फर्क सिर्फ इतना है (जैसा कि आप देख सकते हैं) कि यह सब समूहों में "खाली जगह" प्रसार नहीं होगा; प्रत्येक समूह लेकिन अंतिम आकार के बराबर है, और अंतिम समूह हमेशा शेष "खाली स्थान" शेष रखता है।

अद्यतन: रूप @rimsky astutely ने कहा, उपरोक्त विधि हमेशा समूहों की सही संख्या (कभी कभी यह अंत में कई "खाली समूह" पैदा करेगा, और उन्हें बाहर छोड़) में परिणाम नहीं होगा। यहां एक अद्यतन संस्करण है, ActiveSupport's definition से नीचे दिया गया है जो समूहों की अनुरोधित संख्या को भरने के लिए अतिरिक्त फैलता है।

def in_groups(number) 
    group_size = size/number 
    leftovers = size % number 

    groups = [] 
    start = 0 
    number.times do |index| 
    length = group_size + (leftovers > 0 && leftovers > index ? 1 : 0) 
    groups << slice(start, length) 
    start += length 
    end 

    groups 
end 

Answer 4

जैसा कि एमएलटीसी ने लिखा था, in_groups(n, false) नौकरी करना चाहिए।

मैं सही संतुलन my_array.in_group(my_array.size.quo(max_size).ceil, false) प्राप्त करने के लिए बस एक छोटी सी चाल जोड़ना चाहता था।

यहाँ है कि चाल को वर्णन करने के एक उदाहरण है:

a = (0..8).to_a 
a.in_groups(4, false) => [[0, 1, 2], [3, 4], [5, 6], [7, 8]] 
a.in_groups(a.size.quo(4).ceil, false) => [[0, 1, 2], [3, 4, 5], [6, 7, 8]] 

Answer 5

इस अतिरिक्त टुकड़े बाहर स्मियर करने के लिए कुछ बेहतर चतुराई की जरूरत है, लेकिन यह एक उचित शुरुआत है।

def i_need(bits, r) 
    c = r.count 
    (1..bits - 1).map { |i| r.shift((c + i) * 1.0/bits) } + [r] 
end 

> i_need(2, [1, 3, 5, 7, 2, 4, 6, 8]) 
=> [[1, 3, 5, 7], [2, 4, 6, 8]] 
> i_need(3, [1, 3, 5, 7, 2, 4, 6, 8]) 
=> [[1, 3, 5], [7, 2, 4], [6, 8]] 
> i_need(5, [1, 3, 5, 7, 2, 4, 6, 8]) 
=> [[1, 3], [5, 7], [2, 4], [6], [8]]