누구나이 작업을보다 효율적으로 수행 할 수 있습니다.

Question

나는 이것이 간단하다는 것을 알고있다. 그러나 그것은 저를 괴롭히는 것입니다. 이 작업을 수행하는 더 좋은 방법이 있습니까? 배열은 일반적으로이 코드의 목적이 내가 응축하려고하는 것의 기능 만 중요하지 않습니다.

 for(int p=0; p<28;p++){ 
        if(p == 0){ 
         Pile1[0] = deck[p]; 
        } 
        if(p == 1 || p == 7){ 
         if(p == 1){ 
          Pile2[0] = deck[p]; 
         } 
         if(p == 7){ 
          Pile2[1] = deck[p]; 
         } 
        } 
        if(p == 2 || p == 8 || p == 13){ 
         if(p == 2){ 
          Pile3[0] = deck[p]; 
         } 
         if(p == 8){ 
          Pile3[1] = deck[p]; 
         } 
         if(p == 13){ 
          Pile3[2] = deck[p]; 
         } 
        } 
        if(p == 3 || p == 9 || p == 14 || p == 18){ 
         if(p == 3){ 
          Pile4[0] = deck[p]; 
         } 
         if(p == 9){ 
          Pile4[1] = deck[p]; 
         } 
         if(p == 14){ 
          Pile4[2] = deck[p]; 
         } 
         if(p == 18){ 
          Pile4[3] = deck[p]; 
         } 

        } 
        if(p == 4 || p == 10 || p == 15 || p == 19 || p == 22){ 
         if(p == 4){ 
          Pile5[0] = deck[p]; 
         } 
         if(p == 10){ 
          Pile5[1] = deck[p]; 
         } 
         if(p == 15){ 
          Pile5[2] = deck[p]; 
         } 
         if(p == 19){ 
          Pile5[3] = deck[p]; 
         } 
         if(p == 22){ 
          Pile5[4] = deck[p]; 
         }      
        } 
        if(p == 5 || p == 11 || p == 16 || p == 20 || p == 23 || p == 25){ 
         if(p == 5){ 
          Pile6[0] = deck[p]; 
         } 
         if(p == 11){ 
          Pile6[1] = deck[p]; 
         } 
         if(p == 16){ 
          Pile6[2] = deck[p]; 
         } 
         if(p == 20){ 
          Pile6[3] = deck[p]; 
         } 
         if(p == 23){ 
          Pile6[4] = deck[p]; 
         } 
         if(p == 25){ 
          Pile6[5] = deck[p]; 
         } 
        } 
        if(p == 6 || p == 12 || p == 17 || p == 21 || p == 24 || p == 26 || p == 27){ 
         if(p == 6){ 
          Pile7[0] = deck[p]; 
         } 
         if(p == 12){ 
          Pile7[1] = deck[p]; 
         } 
         if(p == 17){ 
          Pile7[2] = deck[p]; 
         } 
         if(p == 21){ 
          Pile7[3] = deck[p]; 
         } 
         if(p == 24){ 
          Pile7[4] = deck[p]; 
         } 
         if(p == 26){ 
          Pile7[5] = deck[p]; 
         } 
         if(p == 27){ 
          Pile7[6] = deck[p]; 
         } 
        } 
       } 

Answer 1

무엇보다도 루프를 제거 할 수 있습니다. 다음 코드는 동일합니다.

Pile1[0] = deck[0]; 

    Pile2[0] = deck[1]; 
    Pile2[1] = deck[7]; 

    Pile3[0] = deck[2]; 
    Pile3[1] = deck[8]; 
    Pile3[2] = deck[13]; 

    Pile4[0] = deck[3]; 
    Pile4[1] = deck[9]; 
    Pile4[2] = deck[14]; 
    Pile4[3] = deck[18]; 

    Pile5[0] = deck[4]; 
    Pile5[1] = deck[10]; 
    Pile5[2] = deck[15]; 
    Pile5[3] = deck[19]; 
    Pile5[4] = deck[22]; 

    Pile6[0] = deck[5]; 
    Pile6[1] = deck[11]; 
    Pile6[2] = deck[16]; 
    Pile6[3] = deck[20]; 
    Pile6[4] = deck[23]; 
    Pile6[5] = deck[25]; 

    Pile7[0] = deck[6]; 
    Pile7[1] = deck[12]; 
    Pile7[2] = deck[17]; 
    Pile7[3] = deck[21]; 
    Pile7[4] = deck[24]; 
    Pile7[5] = deck[26]; 
    Pile7[6] = deck[27]; 

다음으로 Pile1 ... Pile7을 사용하는 대신 2D 배열을 사용하는 것이 좋습니다. 수학과 패턴을 알아 내세요.

int Pile[7][7]; 
for (int p=1; p<=6; p++) { 
    for (int i=0, j=p-1; i<p; i++, j+=(7-i)) { 
    Pile[p][i] = deck[j]; 
    } 
} 

대신 PileX 사용된다 Pile[X] 동일한 결과를 생성한다.