基於元素操作的迭代數組

Question

假設我有兩個數組。

a = ["A1", "A2", "B1"] 
b = ["C2", "B1", "C1"] 

我想是遍歷數組「A」第一過，

1. 從基陣「A」獲取的元素做一些操作。

   1.A如果該操作成功，則移動到數組「A」的下一個元素。

   1.B如果該操作不成功，然後開始迭代陣列「B」。

2. 獲得從數組「B」的元素與做一些操作。

   2.A如果該操作成功，則移動到數組「B」的下一個元素。

   2.B如果操作不成功，然後開始遍歷數組「A」的地方，我們留在1.A等等所有這一切都將繼續位置...

直到兩個數組中的所有元素都被遍歷。我應該用什麼方法編碼？如果需要更多細節，我會很樂意寫。

Answer 1

這是非常相似，合併過程中合併排序/合併兩個有序陣列。如果你還沒有看過，也請看看。只需維護一個標誌變量即可知道下一個要處理的數組。

---

iterA := 0 
iterB := 0 
flag := 0 

while (iterA < size(A) && iterB < size(B)): 

    if (flag == 0): 

     if(doOperation(A[iterA]) == success): 
      iterA := iterA + 1 
     else: 
      flag := 1 
      iterA := iterA + 1 

    if (flag == 1): 

     if(doOperation(B[iterB]) == success): 
      iterA := iterA + 1 
     else: 
      flag := 0 
      iterA := iterA + 1 

while (iterA < size(A)): 
    doOperation(A[iterA]) 
    iterA := iterA + 1 

while (iterB < size(B)): 
    doOperation(B[iterB]) 
    iterB := iterB + 1 

---

我假設，如果一個數組的所有元素都順利完成了手術，我們做的只有另一個陣列的其餘元件的操作。

Answer 2

這是一個非常簡單的想法。你想要的是：

until both lists A and B exhausted 
    while not (A exhausted or processing A has failed) 
     process next element of A 
    while not (B exhausted or processing B has failed) 
     process next element of B 

現在你可以翻譯最正常的任何迭代語言。在C中，

for (int ia = 0, ib = 0; ia < a_len || ib < b_len;) { 
    while (ia < a_len) if (process(a[ia++]) == FAIL) break; 
    while (ib < b_len) if (process(b[ib++]) == FAIL) break; 
} 

但是不同的語言提供了其他表達方式。一個很好的例子是co-routines。

coroutine processA 
    while A not empty and process(nextElement(A)) != FAIL, /* empty */ ; 
    if not empty(B) yield B 

coroutine processB 
    while B not empty and process(nextElement(B)) != FAIL, /* empty */ ; 
    if not empty(A) yield A 

精美的對稱，不是嗎？