loop Factor fuori

Question

sto allenando come trovare e rimuovere codice morto. Ho il seguente codice:

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

mio parere su questo codice: prima l'istruzione if può essere rimosso, perché non influisce l'esecuzione del resto del codice. Oltre c1% 16 è la stessa di c1% 8.

Come faccio a gestire i cicli?

Answer 1

I comincerebbe dal codice interno del ciclo: Ad esempio all'interno del interna se avete

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

la prima e la terza linea annullano a vicenda .. e lo stesso con il secondo e quarto. L'eliminazione di questi si ottiene l'interno se in questo modo:

if ( c2 < c3 )
{
}

che può essere eliminato (eliminando anche la necessità di c2, c3 VAR) rendendo così l'aspetto affermazione racchiude in questo modo:

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

Se andiamo un passo avanti e invertire la racchiude if / else otteniamo qualcosa di simile:

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

e l'altro vuoto può essere rimosso. Ora se un altro passo si ottiene:

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

Un si rimuove il caso del tutto dal momento che è già selezionata nel mentre sopra. Ora, se si scrive il codice completo che si ottiene:

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

è possibile rimuovere il primo tempo e l'iniziale add / stampare del tutto perché il primo ciclo Do avrà la stessa semantica.

Alla fine si dovrebbe ottenere qualcosa di simile:

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

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

E se non c'è bisogno di realtà stampare i valori intermedi è possibile ottenere il valore di c1 finale tramite semplice matematica in 1-2 fasi: -).

Answer 2

c% 16 non è la stessa di c% 8. Se c sono pari a 24, ex rendimenti 8 e quest'ultimo 0. Se c erano 32 entrambi sarebbero 0, ma se c fosse 40, ex ritorna nuovamente 8 e quest'ultimo 0.

Linee 4/5/6 non sono ottimali. Che cosa sta realmente accadendo è che se c1% 16! = 0, do il do / while, ma il modo in cui è scritto è cloogy. E 'scritto, 'non fare nulla se c1% 16 == 0, altro fare il loop', utilizzando gli ignudi; dopo il caso. Vorrei renderlo più leggibile facendo qualcosa di simile:

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