길이를 짧게, 재귀 적으로 만들 수있는 방법이 있습니까? Java

Question

다음 코드를 더 짧게 만들 수있는 방법이 있는지 물어보고 싶습니다. 재귀를 수행하는 방법이 있어야한다고 생각하지만 재귀가 가장 강한 측면이 아니므로 확실하지 않습니다./ 나중에 각 계산 된 상태에서 일어날 일이 있지만 괴물 일뿐입니다./

public void VertexState() { // Try to find the next vertex state to test 
    int end = 0; 
    int counter = 0; 
    int place; 
    int up = 1; 
    int zaehler = 1; 

    try { 
     for (int u = 0; u < 4; u++) { 
      for (int t = 0; t < 4; t++) { 
       for (int s = 0; s < 4; s++) { 
        for (int r = 0; r < 4; r++) { 
         for (int q = 0; q < 4; q++) { 
          for (int p = 0; p < 4; p++) { 
           for (int o = 0; o < 4; o++) { 
            for (int n = 0; n < 4; n++) { 
             for (int m = 0; m < 4; m++) { 
              for (int l = 0; l < 4; l++) { 
               for (int k = 0; k < 4; k++) { 
                for (int j = 0; j < 4; j++) { 
                 for (int i = 0; i < 4; i++) { 
                  for (int h = 0; h < 4; h++) { 
                   for (int g = 0; g < 4; g++) { 

                    for (int f = 0; f < 4; f++) { 
                     for (int e = 0; e < 4; e++) { 
                      for (int d = 0; d < 4; d++) { 
                       for (int c = 0; c < 4; c++) { 
                        for (int b = 0; b < 4; b++) { 
                         for (int a = 0; a < 4; a++) { 
                          work[0][findPlace()].countUp(); 
                          work[findPlace()][0].countUp(); 


                         } 
                         work[0][findNextPlace(1)].countUp(); 
                         work[findNextPlace(1)][0].countUp(); 

                        } 
                        work[0][findNextPlace(2)].countUp(); 
                        work[findNextPlace(2)][0].countUp(); 

                       } 
                       work[0][findNextPlace(3)].countUp(); 
                       work[findNextPlace(3)][0].countUp(); 

                      } 
                      work[0][findNextPlace(4)].countUp(); 
                      work[findNextPlace(4)][0].countUp(); 
                     } 
                     work[0][findNextPlace(5)].countUp(); 
                     work[findNextPlace(5)][0].countUp(); 
                    } 
                    work[0][findNextPlace(6)].countUp(); 
                    work[findNextPlace(6)][0].countUp(); 
                   } 
                   work[0][findNextPlace(7)].countUp(); 
                   work[findNextPlace(7)][0].countUp(); 
                  } 
                  work[0][findNextPlace(8)].countUp(); 
                  work[findNextPlace(8)][0].countUp(); 
                 } 
                 work[0][findNextPlace(9)].countUp(); 
                 work[findNextPlace(9)][0].countUp(); 
                } 
                work[0][findNextPlace(10)].countUp(); 
                work[findNextPlace(10)][0].countUp(); 
               } 
               work[0][findNextPlace(11)].countUp(); 
               work[findNextPlace(11)][0].countUp(); 
              } 
              work[0][findNextPlace(12)].countUp(); 
              work[findNextPlace(12)][0].countUp(); 
             } 
             work[0][findNextPlace(13)].countUp(); 
             work[findNextPlace(13)][0].countUp(); 
            } 
            work[0][findNextPlace(14)].countUp(); 
            work[findNextPlace(14)][0].countUp(); 
           } 
           work[0][findNextPlace(15)].countUp(); 
           work[findNextPlace(15)][0].countUp(); 

           work[0][findNextPlace(16)].countUp(); 
           work[findNextPlace(16)][0].countUp(); 
          } 
          work[0][findNextPlace(17)].countUp(); 
          work[findNextPlace(17)][0].countUp(); 
         } 
         work[0][findNextPlace(18)].countUp(); 
         work[findNextPlace(18)][0].countUp(); 
        } 
        work[0][findNextPlace(19)].countUp(); 
        work[findNextPlace(19)][0].countUp(); 
       } 
       work[0][findNextPlace(20)].countUp(); 
       work[findNextPlace(20)][0].countUp(); 
      } 
      work[0][findNextPlace(21)].countUp(); 
      work[findNextPlace(21)][0].countUp(); 


     } 
    } catch (NullPointerException e) { 
     System.out.println("over and out"); 
    } 

} 


public int findPlace() { 
    int place = work.length; 
    for (place = work.length - 1; place >= 0; place--) { 
     if (work[0][place] != null) { 
      return place; 
     } 
    } 

    return 0; 
} 

난 정말 당신이 나를 도울 수 :) 난 당신이 필요한 이유를 물어 않을거야

Answer 1

패턴을 봅니다.

• 당신은 그런
• something 다음 work[0][findNextPlace(21)].countUp(); 및 work[findNextPlace(21)][0].countUp();

something 그냥 패턴이지만 findNextPlace에 전달 다른 번호로 호출 할 3

에 0에서 반복.

0을 findNextPlace으로 전달할 때까지이 작업을 수행합니다.

의 당신의 코드를 다시 보자 : 다음

void something(int parameter) { 
    if(parameter < 0) { 
     for(int i = 0; i < 4; i++) { 
      work[0][findPlace(parameter)].countUp(); 
      work[findPlace(parameter)][0].countUp(); 
     } 
    } else { 
     for(int i = 0; i < 4; i++) { 
      something(parameter - 1); 
      work[0][findNextPlace(parameter)].countUp(); 
      work[findNextPlace(parameter)][0].countUp(); 
     } 
    } 
} 

을 그냥 something(21)로 for 피라미드를 전체 교체;

Answer 2

대단히 감사합니다 희망하지만이 재귀 형태가 될 것이라고 생각 :

void recursiveImpl(int iterator) 
    { 
     iterator++; 
     if (iterator == 1) 
     { 
      for (int a = 0; a < 4; a++) 
      { 
       recursiveImpl(iterator); 

       work[0][findPlace()].countUp(); 
       work[findPlace()][0].countUp();     
      } 
     } 
     else 
     { 
      for (int a = 0; a < 4; a++) 
      { 
       if (iterator < 22) 
       { 
        recursiveImpl(iterator); 
       } 
       work[0][findNextPlace(iterator)].countUp(); 
       work[findNextPlace(iterator)][0].countUp(); 
      } 
     } 
    }