boucles sur des facteurs

Question

Je pratique comment trouver et supprimer le code mort. Je le code suivant:

              int c1 = Integer.parseInt(args[0]) ;
           int c2 = Integer.parseInt(args[1]) ;
           int c3 = Integer.parseInt(args[2]) ;

/*  1 */           c1 += 7 ; 
/*  2 */           System.out.println( c1 ) ; 

/*  3 */       while (c1 % 8 != 0)
/*  4 */              if ( c1 % 16 == 0 ) ; 
/*  5 */              else
/*  6 */         do 
/*  7 */                 {
/*  8 */                    c1 += 7 ; 
/*  9 */                    System.out.println( c1 ) ; 
/* 10 */                    if ( c2 < c3 )
/* 11 */                       { c1 = c1+c1 ; 
/* 12 */                         c3 ++ ; 
/* 13 */                         c1 /= 2 ; 
/* 14 */                         c3 -= 1 ; 
/* 15 */                       }
/* 16 */                 }
/* 17 */                 while ( c1 % 8 != 0 ) ;

/* 18 */           c1 += 7 ; 
/* 19 */           System.out.println( c1 ) ; 
        }     

Mon oppinion sur ce code: d'abord le cas peut être retiré déclaration, car elle n'a pas d'effet de l'exécution du reste du code. Outre c1% 16 est le même que c1% 8.

Comment gérer les boucles?

Answer 1

Je commence à partir du code interne de la boucle: Par exemple à l'intérieur du intérieur si vous avez

c1 = c1+c1 ; 
c3 ++ ; 
c1 /= 2 ; 
c3 -= 1 ; 

la première et la troisième ligne annulent .. et de même avec le deuxième et quatrième. Suppression de ceux que vous obtenez l'intérieur si comme ceci:

if ( c2 < c3 )
{
}

qui peut être éliminé (suppression également la nécessité de c2, c3 vars) rendant ainsi l'apparence de déclaration enfermant comme ceci:

do 
{
  c1 += 7 ; 
  System.out.println( c1 ) ; 
}
while ( c1 % 8 != 0 );

Si nous faisons un pas et inverser la englobante if / else nous obtenons quelque chose comme ceci:

if ( c1 % 16 != 0 )
    do 
    {
      c1 += 7 ; 
      System.out.println( c1 ) ; 
    }
    while ( c1 % 8 != 0 );
else 
 ;

et l'autre vide peuvent être enlevés. Maintenant, si vous une autre étape que vous obtenez:

while (c1 % 8 != 0)
  if ( c1 % 16 != 0 )
    do 
    {
      c1 += 7 ; 
      System.out.println( c1 ) ; 
    }
    while ( c1 % 8 != 0 );

Une si vous supprimez le complètement car il est déjà cochée dans le tout ci-dessus. Maintenant, si vous écrivez le code complet que vous obtenez:

c1 += 7 ; 
System.out.println( c1 ) ; 

while (c1 % 8 != 0)
  do 
  {
    c1 += 7 ; 
    System.out.println( c1 ) ; 
  }
  while ( c1 % 8 != 0 );

c1 += 7 ; 
System.out.println( c1 ) ; 

vous pouvez supprimer le premier temps et l'ajout initial / impression tout à fait parce que la première boucle do aura la même sémantique.

En fin de compte, vous devriez obtenir quelque chose comme ceci:

    do {
        c1 += 7;
        System.out.println(c1);
    }
    while (c1 % 8 != 0);

    c1 += 7;
    System.out.println(c1);

Et si vous n'avez pas besoin de réellement imprimer les valeurs intermédiaires, vous pouvez obtenir la valeur c1 finale par les mathématiques simples en 1-2 étapes: -.)

Answer 2

c% 16 ne sont pas les mêmes que c% 8. Si c était égal à 24, les anciens rendements 8 et celui-ci 0. Si c était 32, ils seraient tous deux 0, mais si c était 40, l'ancien revient à nouveau 8 et celui-ci 0.

Les lignes 4/5/6 ne sont pas optimales. Qu'est-ce qui se passe réellement est si c1% 16! = 0, faire la boucle do / while, mais la façon dont il est écrit est cloogy. Il est écrit, « ne rien faire si c1% 16 == 0, sinon faire la boucle », en utilisant le nu; après si. Je le rendre plus lisible en faisant quelque chose comme:

bool shouldDoLoop = c1 % 16 != 0;
if (shouldDoLoop) {
   // do/while here
}