Как реорганизовать этот код java

Question

У меня есть метод java под названием solution, есть два больших цикла, как вы можете видеть, два цикла для цикла очень похожи, поэтому я думаю, что можно реорганизовать код, используя метод, такой как public int getElementSize(ArrayList<Integer> factor1, ArrayList<Integer> factor2), который выполняет работу цикла for, поэтому я могу просто вызвать этот метод дважды с разными параметрами, вместо этого повторяя цикл for. Но поскольку у этих двух циклов есть разные порядки цикла: один от головы до хвоста, другой от хвоста к голове, кроме того, все остальные части цикла одинаковы, любые идеи по реорганизации этого кода?

class Solution { 
    public int solution(int[] A) { 
     ArrayList<Integer> factor1 = new ArrayList<Integer>(); 
     ArrayList<Integer> factor2 = new ArrayList<Integer>(); 

     int factor = 1; 
     int N = A.length; 
     while(factor * factor <= N){ 
      if(N % factor == 0){ 
       factor1.add(factor); 
       factor2.add(N/factor); 
      } 
      factor++; 
     } 

     for(int i = 1; i < factor2.size(); i++){ 
      int blockSize = factor2.get(i); 
      int elementSize = factor1.get(i); 
      int peaks = 0; 
      for(int j = 0; j < blockSize; j++){ 
       boolean hasPeak = false; 
       for(int k = elementSize * j; k < elementSize * (j + 1); k++){ 
        if(k > 0 && k < N - 1){ 
         if(A[k] > A[k - 1] && A[k] > A[k + 1]) 
          hasPeak = true; 
        }  
       } 
       if(!hasPeak) 
        break; 
       else 
        peaks++; 
      } 
      if(peaks == blockSize) 
       return blockSize; 
     } 

     for(int i = factor1.size() - 1; i >= 0; i--){ 
      int blockSize = factor1.get(i); 
      int elementSize = factor2.get(i); 
      int peaks = 0; 
      for(int j = 0; j < blockSize; j++){ 
       boolean hasPeak = false; 
       for(int k = elementSize * j; k < elementSize * (j + 1); k++){ 
        if(k > 0 && k < N - 1){ 
         if(A[k] > A[k - 1] && A[k] > A[k + 1]) 
          hasPeak = true; 
        }  
       } 
       if(!hasPeak) 
        break; 
       else 
        peaks++; 
      } 
      if(peaks == blockSize) 
       return blockSize;  
     } 

     return 0; 
    } 
} 

Answer 1

Вы можете реорганизовать код внутри для петель к новому методу внутри переместить две большие для петель к новому методу, таким образом, порядок двух петель по-прежнему не зависит, в основном это выглядит как показано ниже, правильность должна быть проверена, это просто одна идея не повторять:

class Solution { 
    public int solution(int[] A) { 
     ArrayList<Integer> factor1 = new ArrayList<Integer>(); 
     ArrayList<Integer> factor2 = new ArrayList<Integer>();  
     int factor = 1; 
     int N = A.length; 
     while(factor * factor <= N){ 
      if(N % factor == 0){ 
       factor1.add(factor); 
       factor2.add(N/factor); 
      } 
      factor++; 
     } 

     for(int i = 1; i < factor2.size(); i++){ 
      int blockSize = factor2.get(i); 
      int elementSize = factor1.get(i); 
      int peaks = getElementSize(A, blockSize, elementSize); //call the method 
      if(peaks == blockSize) 
       return blockSize; 
     } 

     for(int i = factor1.size() - 1; i >= 0; i--){ 
      int blockSize = factor1.get(i); 
      int elementSize = factor2.get(i); 
      int peaks = getElementSize(A, blockSize, elementSize); //call the method 
      if(peaks == blockSize) 
       return blockSize;  
     } 

     return 0; 
    } 

    //this method include the code which was repeated inside the loops 
    public int getElementSize(int[] A, int blockSize, int elementSize){ 
     int peaks = 0; 
     int N = A.length; 
     for(int j = 0; j < blockSize; j++){ 
      boolean hasPeak = false; 
      for(int k = elementSize * j; k < elementSize * (j + 1); k++){ 
       if(k > 0 && k < N - 1){ 
        if(A[k] > A[k - 1] && A[k] > A[k + 1]) 
         hasPeak = true; 
       }  
      } 
      if(!hasPeak) 
       break; 
      else 
       peaks++; 
     } 

     return peaks; 
    } 
} 

Answer 2

Как насчет этого?

Условный оператор,? и: по аналогии с, (они называются тройные операторы и разрешить во время компиляции, если-то еще блоки)

if(condition) { 
this(); 
} else { 
that(); 
} 

В выше, вы можете одной линии, что, как, (условие этого(): что())

class Solution { 
public int solution(int[] A) { 
    ArrayList<Integer> factor1 = new ArrayList<Integer>(); 
    ArrayList<Integer> factor2 = new ArrayList<Integer>(); 

    int factor = 1; 
    int N = A.length; 
    while(factor * factor <= N){ 
     if(N % factor == 0){ 
      factor1.add(factor); 
      factor2.add(N/factor); 
     } 
     factor++; 
    } 
    // let i = 0 to be factor2, i = 1 is factor 1 
    for(int i = 0; i < 2; i++) { 
    for(int x = (i == 0 ? 1 : factor1.size() - 1); (i == 0 ? x < factor2.size() : x >= 0); (i == 0 ? x++ : x--)){ 
     int blockSize = (i == 0 ? factor2.get(x) : factor1.get(x)); 
     int elementSize = (i == 0 ? factor1.get(x) : factor2.get(x)); 
     int peaks = 0; 
     for(int j = 0; j < blockSize; j++){ 
      boolean hasPeak = false; 
      for(int k = elementSize * j; k < elementSize * (j + 1); k++){ 
       if(k > 0 && k < N - 1){ 
        if(A[k] > A[k - 1] && A[k] > A[k + 1]) 
         hasPeak = true; 
       }  
      } 
      if(!hasPeak) 
       break; 
      else 
       peaks++; 
     } 
     if(peaks == blockSize) 
      return blockSize; 
      } 
     } 

    return 0; 
    } 
}