दो Arrays में विभाजित बिग ऐरे

Question

मेरे पास ऑब्जेक्ट्स की एक बड़ी श्रृंखला है और इसे वैकल्पिक क्रम में ऑब्जेक्ट वाले दो सरणी में विभाजित करना चाहूंगा।

उदाहरण:

[0, 1, 2, 3, 4, 5, 6]

इन दो सरणियों हो जाता है (वे वैकल्पिक चाहिए)

[0, 2, 4, 6] और [1, 3, 5]

तरीके एक सरणी विभाजित करने के लिए की एक टन कर रहे हैं। लेकिन, अगर सरणी विशाल है तो सबसे कुशल (कम से कम महंगा) क्या है।

Answer 1

वहाँ विभिन्न रहे हैं इसे फिल्टर के साथ करने के फैंसी तरीके हैं, लेकिन अधिकतर शायद एक के बजाय दो पास की आवश्यकता होगी, ताकि आप केवल फॉर-लूप का उपयोग कर सकें।

अंतरिक्ष अप-फ्रंट का संरक्षण इस मामले में एक बड़ा अंतर डाल सकता है क्योंकि यदि स्रोत बड़ा है तो यह अनावश्यक पुन: आवंटन से बच जाएगा क्योंकि नए सरणी बढ़ती हैं, और आवश्यक स्थान की गणना सरणी पर निरंतर समय में होती है।

// could make this take a more generic random-access collection source 
// if needed, or just make it an array extension instead 
func splitAlternating<T>(source: [T]) -> ([T],[T]) { 
    var evens: [T] = [], odds: [T] = [] 

    evens.reserveCapacity(source.count/2 + 1) 
    odds.reserveCapacity(source.count/2) 

    for idx in indices(source) { 
     if idx % 2 == 0 { 
      evens.append(source[idx]) 
     } 
     else { 
      odds.append(source[idx]) 
     } 
    } 

    return (evens,odds) 
} 

let a = [0,1,2,3,4,5,6] 
splitAlternating(a) // ([0, 2, 4, 6], [1, 3, 5]) 

यदि प्रदर्शन सही मायने में महत्वपूर्ण है, आप source.withUnsafeBufferPointer इस्तेमाल कर सकते हैं, स्रोत तत्वों का उपयोग करने के सूचकांक सीमा जाँच से बचने के लिए।

सरणियों वास्तव में बहुत बड़ा, और आप को छोड़कर तत्वों की एक छोटी संख्या के नमूने के लिए परिणामी डेटा का उपयोग करने नहीं जा रहे हैं, आप के बजाय एक आलसी दृश्य का उपयोग (हालांकि एसटीडी आलसी फिल्टर प्रतिसाद नहीं लिब 'पर विचार कर सकते हैं, तो यहां बहुत अधिक उपयोग नहीं किया जाता है क्योंकि यह अनुक्रम को संग्रहित नहीं करता है - आपको संभवतः अपना खुद का लिखना होगा)।

Answer 2

लूप के लिए उपयोग करें। यदि सूचकांक मान तब भी एक सरणी में भेजता है और यदि सूचकांक मान अजीब है, तो उसे अजीब सरणी में भेजें।

Answer 3

आप पाश कदम में के लिए उपयोग कर सकते हैं इस प्रकार दो परिणामस्वरूप सरणियों को भरने के लिए:

extension Array { 
    var groupOfTwo:(firstArray:[T],secondArray:[T]) { 
     var firstArray:[T] = [] 
     var secondArray:[T] = [] 
     for index in stride(from: 0, to: count, by: 2) { 
      firstArray.append(self[index]) 
      if index + 1 < count { 
       secondArray.append(self[index+1]) 
      } 
     } 
     return (firstArray,secondArray) 
    } 
} 



[0, 1, 2, 3, 4, 5, 6].groupOfTwo.firstArray // [0, 2, 4, 6] 
[0, 1, 2, 3, 4, 5, 6].groupOfTwo.secondArray // [1, 3, 5] 

अद्यतन: Xcode 7.1.1 • स्विफ्ट 2,1

extension Array { 
    var groupOfTwo:(firstArray:[Element],secondArray:[Element]) { 
     var firstArray:[Element] = [] 
     var secondArray:[Element] = [] 
     for index in 0.stride(to: count, by: 2) { 
      firstArray.append(self[index]) 
      if index + 1 < count { 
       secondArray.append(self[index+1]) 
      } 
     } 
     return (firstArray,secondArray) 
    } 
} 

Answer 4

यहाँ मेरी राय में, है, सबसे आसान तरीका है

old_list = [0, 1, 2, 3, 4, 5, 6] 
new_list1 =[] 
new_list2 = [] 
while len(old_list)>0: 
    new_list1.append(old_list.pop(-1)) 
    if len(old_list) != 0: 
     new_list2.append(old_list.pop(-1)) 

new_list1.reverse() 
new_list2.reverse() 

Answer 5

एक अधिक संक्षिप्त, कार्यात्मक दृष्टिकोण reduce

let a = [0,1,2,3,4,5,6] 

let (evens, odds) = a.enumerate().reduce(([Int](),[Int]())) { (cur, next) in 
    let even = next.index % 2 == 0 
    return (cur.0 + (even ? [next.element] : []), 
      cur.1 + (even ? [] : [next.element])) 
} 

evens // [0,2,4,6] 
odds // [1,3,5]