सुनिश्चित नहीं हैं कि कोड को डुप्लिकेट यहाँ

Question

मैं कोड के इस बिट है, जो अच्छा काम करता है और क्या मैं यह करना चाहता हूँ वास्तव में करता है से बचने के लिए:

  if condition1 { 
       array1 += [array1[i-n]] 
      } else { 
       array1 += [Int (arc4random_uniform(7))] 
       if array1[i] >= array1[i-n] { 
        array1[i] += 1 
       } 
      } //same logic, different condition and array 
      if condition2 { 
       array2 += [array2[i-n]] 
      } else { 
       array2 += [Int (arc4random_uniform(7))] 
       if array2[i] >= array2[i-n] { 
        array2[i] += 1 
       } 
      } 

लेकिन मैं दो बार सटीक एक ही बात कर रहा हूँ, बस एक अलग स्थिति और विभिन्न सरणी के साथ। मैं तर्क को डुप्लिकेट करने से कैसे बच सकता हूं? मैं दो tuples की एक सरणी के रूप में यह ऊपर पैकेजिंग की कोशिश की:

[ (condition1, array1) , (condition2, array2) ] 

और मुझे लगता है कि पाश के लिए एक में डाल दिया:

for tuple in [ (condition1, array1) , (condition2, array2) ] { 
    var (condition, array) = tuple 
    if condition { 
     array += [array[i-n]] 
    } else { 
     array += [Int (arc4random_uniform(7))] 
     if array[i] >= array[i-n] { 
      array[i] += 1 
     } 
    } 
} 

और कहा कि संकलित, लेकिन ऐसा लगता है जैसे कि सरणी की नकल की गई थी, में "सरणी" को बदलने वाले दूसरे शब्द "array1" या "array2" को प्रभावित नहीं करते थे। मैंने tuple.0 और tuple.1 नोटेशन का उपयोग करके उसमें अन्य भिन्नताओं की कोशिश की थी, लेकिन इसे संकलित करने के लिए नहीं मिला। तो फिर मैंने मूल स्विफ्ट सरणी के बजाय एनएसएआरआरएएस का उपयोग करने की कोशिश की ... लेकिन मैं यह नहीं समझ सका कि सही तरीके से कैसे किया जाए, और किसी भी मामले में सोचा कि ऐसा करने का एक आसान तरीका होना चाहिए।

क्या मेरे मूल कोड को पुन: स्थापित करने का एक संक्षिप्त तरीका है ताकि तर्क को डुप्लिकेट न किया जा सके?

Answer 1

func alteredArray(var array:[Int], condition: Bool) -> [Int] { 
    if condition { 
     array += [array[i-n]] 
    } else { 
     array += [Int (arc4random_uniform(7))] 
     if array[i] >= array[i-n] { 
      array[i] += 1 
     } 
    } 
    return array 
} 

array1 = alteredArray(array1, condition1) 
array2 = alteredArray(array2, condition2) 

या, यदि आप संक्षिप्त महसूस कर रहे हैं, समारोह का नाम बदलने, array एक inout पैरामीटर बनाने के लिए, return हटाने, और के रूप में यह कहते हैं:

alterArray(&array1, condition1) 
alterArray(&array2, condition1) 

Answer 2

यह करी!

func func1(var a: [Int]) -> [Int] { 
    a += [a[i-n]] 
    return a 
} 

func func2(var a: [Int]) -> [Int] { 
    a+= [Int (arc4random_uniform(7))] 
    if a[i] >= a[i-n] { 
     a[i] += 1 
    } 
    return a 
} 

func function(condition: Bool) -> [Int] -> [Int] { 
    switch condition { 
    case true: 
     return func1 
    case false: 
     return func2 
    } 
} 

array1 = function(condition1)(array1) 
array2 = function(condition2)(array2) 

(और एक ही inout सामान वह भी, उल्लेख किया andyvn22 यहां आवेदन कर सकते हैं।) माइग्रेशन पहले के साथ मिश्रण के लिए