/ / कैसे एक परिसीमा का उपयोग असमान आकार की subarrays में रूबी सरणी विभाजित करने के लिए - arrays, रूबी

कैसे एक सीमांकक का उपयोग असमान आकार के उपसरणी में एक रूबी सरणी विभाजित करने के लिए-सरणियों, रूबी

मेरे पास निम्न सरणी है:

arr = [0, 1, 1, 2, 3, 1, 0, 0, 1]

मूल्यों के क्रम को बदले बिना, मुझे वश में करने की आवश्यकता है arr की हर घटना पर छोटे सरणियों में 0, जैसे कि परिणाम होगा:

arr = [ [0, 1, 1, 2, 3, 1], [0], [0, 1] ]

अगर arr एक तार थे, मैं उपयोग कर सकता था .split("0") और फिर प्रत्येक उपपट्टी में सीमांकक को प्रीपेन्ड करें। के बराबर सबसे कुशल क्या होगा .split() सादे रुबी में सरणियों के लिए?

उत्तर:

उत्तर № 1 के लिए 4

Enumerable#slice_before यह सटीक काम करता है:

arr = [0, 1, 1, 2, 3, 1, 0, 0, 1]
p arr.slice_before(0).to_a
# => [[0, 1, 1, 2, 3, 1], [0], [0, 1]]

इसे repl.it पर देखें: https://repl.it/FBhg


जवाब के लिए 0 № 2

जबसे ActiveSupport रूबी में एक सरणी # विभाजन विधि को परिभाषित करता है, हम इसे एक प्रारंभिक बिंदु के रूप में उपयोग कर सकते हैं:

class Array
def split(value = nil)
arr = dup
result = []
if block_given?
while (idx = arr.index { |i| yield i })
result << arr.shift(idx)
arr.shift
end
else
while (idx = arr.index(value))
result << arr.shift(idx)
arr.shift
end
end
result << arr
end
end

# then, using the above to achieve your goal:
arr = [0, 1, 1, 2, 3, 1, 0, 0, 1]
arr.split(0).map { |sub| sub.unshift(0) }
# => [[0], [0, 1, 1, 2, 3, 1], [0], [0, 1]]

ध्यान दें कि एल्गोरिथ्म (स्प्लिट और प्रीपेंड) की आपकी मौखिक वाक्यांशिंग यहां क्या हो रही है, लेकिन आपका अपेक्षित आउटपुट अलग है (क्योंकि रास्ते में एक अतिरिक्त शून्य है split काम करता है) ।

क्या आप करना यह चाहते हैं प्रत्येक शून्य से पहले विभाजित? इसके लिए आप उपयोग कर सकते हैं slice_before.

क्या आप करना यह चाहते हैं विभाजित करें, लेकिन खाली सरणियाँ छोड़ें? यह एक त्वरित के साथ किया जा सकता है compact तैयार करने से पहले, लेकिन आप खो देंगे [0] subarray।

क्या आप करना यह चाहते हैं विभाजित करें लेकिन खाली होने पर पहले तत्व को छोड़ दें?

क्या आप करना यह चाहते हैं पर विभाजित /0+/?