bucles factor de fuera

Question

Estoy practicando cómo encontrar y eliminar el código muerto. Tengo el siguiente código:

              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 ) ; 
        }     

Mi OPINIÓN sobre este código: primero la sentencia if se puede quitar, ya que no afecta a la ejecución del resto del código. Además c1% 16 es el mismo que c1% 8.

¿Cómo se gestionan los bucles?

Answer 1

Yo comenzaría a partir del código interno del bucle: Por ejemplo en el interior si tiene

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

la primera y tercera línea se anulan entre sí .. y lo mismo con la segunda y cuarta. La eliminación de los que obtiene el interior si de esta manera:

if ( c2 < c3 )
{
}

que puede ser eliminado (también elimina la necesidad de c2, c3 VARs) con lo que el aspecto declaración adjuntando la siguiente manera:

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

Si vamos un paso adelante y revertir la envolvente if / else obtenemos algo como esto:

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

y el otro vacío se pueden quitar. Ahora bien, si un paso más hasta que se obtiene:

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

Una de quitar el caso por completo, puesto que ya está marcada en el tiempo anterior. Ahora bien, si se escribe el código completo que se obtiene:

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 ) ; 

puede quitar el primer tiempo y el complemento inicial / imprimir en conjunto porque el primer ciclo do tendrá la misma semántica.

Al final, usted debe obtener algo como esto:

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

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

Y si usted no tiene que imprime realmente los valores intermedios se puede obtener el valor de c1 final a través de las matemáticas simples en 1-2 pasos: -).

Answer 2

c% 16 no es el mismo que c% 8. Si c fuera igual a 24, los ex retornos 8 y el último 0. Si c eran 32 ambos estarían 0, pero si c fueron 40, la antigua de nuevo devuelve 8 y el segundo 0.

Las líneas 4/5/6 no son óptimas. Lo que realmente está sucediendo es que si c1% 16! = 0, hacer el do / while, pero la forma en que está escrito es cloogy. Está escrito, 'no hacer nada si c1% 16 == 0, de lo contrario hacer el bucle', usando al desnudo; Si después de la. Me gustaría que sea más legible haciendo algo como:

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