práctica java

Question

me encontré con este problema en javabat (http://www.javabat.com/prob/p183562):

Queremos hacer una fila de ladrillos que es pulgadas objetivo a largo. Tenemos un número de ladrillos pequeños (1 pulgada cada uno) y ladrillos grandes (5 pulgadas cada uno). Devuelve verdadero si es posible hacer el objetivo por eligiendo entre los ladrillos dados. Este es un poco más difícil de lo que parece y se puede hacer sin ningún bucle.

makeBricks (3, 1, 8) → verdaderos
makeBricks (3, 1, 9) → falsos
makeBricks (3, 2, 10) → verdadera

me ocurrió con esta solución :

public boolean makeBricks(int small, int big, int goal) { 
    if (goal > small + big * 5) 
     return false; 
    else if (goal % 5 == 0) 
     return goal/5 <= big; 
    else 
     return goal % 5 <= small; 
} 

Esto pasó la prueba. Pero encontré un contraejemplo yo mismo: makeBricks (10, 0, 10) -> true. Mi lógica devolverá falso. ¿Cómo debería arreglar mi lógica? ¿O hay una mejor manera de hacer esto?

Answer 1

Creo que sólo puede quitar su segunda prueba. Me gustaría probar esto:

public boolean makeBricks(int small, int big, int goal) { 
    if (goal > small + big * 5) 
     return false; 
    else 
     return goal % 5 <= small; 
} 

Answer 2

Su lógica es incorrecta. Esto debería hacerlo:

public boolean makeBricks(int small, int big, int goal) { 
    if (goal < 0 || big < 0 || small < 0) { 
    throw new IllegalArgumentException(); 
    } else if (goal > big * 5 + small) { 
    return false; 
    } else if (goal % 5 <= small) { 
    return true; 
    } else { 
    return false; 
    } 
} 

es suficiente. Esto se puede simplificar a:

public boolean makeBricks(int small, int big, int goal) { 
    if (goal < 0 || big < 0 || small < 0) { 
    throw new IllegalArgumentException(); 
    } else { 
    return goal <= big * 5 + small && goal % 5 <= small; 
    } 
} 

Por supuesto, la comprobación de validez de goles negativa, pequeño o grande no es estrictamente necesario, pero se recomienda. Sin esas comprobaciones, el resultado sólo puede ser obtenida por:

public boolean makeBricks(int small, int big, int goal) { 
    return goal <= big * 5 + small && goal % 5 <= small; 
} 

Answer 3

está volviendo falsa debido a que su segundo cheque sólo es en comparación a los hombres grandes, que en su contraejemplo que tiene cero.

así 2 < = 0 es falso.

aquí es una buena manera de hacerlo:

return (Math.min(goal/5,big)*5 + small) >= goal; 

De esta manera usted puede estar seguro de utilizar sólo como muchos ladrillos grandes como sea necesario, pero no más, que garantiza que la única manera de llegar a la meta es si tienes suficientes ladrillos pequeños

Answer 4

La segunda prueba es completamente innecesaria. El primero comprueba que tienes suficiente longitud total, y todo está bien.

Pero la segunda nuevo comprueba si tiene suficiente longitud total (objetivo de retorno/5 = < grande;) pero esto ignora la longitud añadida por pequeños ladrillos. El problema es que está comprobando si es un múltiplo de 5, y suponiendo automáticamente que solo usará ladrillos grandes si es así. En realidad, podrías usar cinco ladrillos pequeños en su lugar. (o, como en su ejemplo, 10 ladrillos pequeños). La última verificación es correcta, probando si tiene suficiente granularidad para obtener la longitud correcta, suponiendo que tiene suficiente longitud.

Answer 5

He intentado algunos otros escenarios: "makeBricks (8, 1, 13)" "makeBricks (1, 2, 6)" donde o no tienes suficientes o demasiados ladrillos grandes, pero necesitas algunos. Para tener en cuenta ambas posibilidades Se necesitaría algo así como:

public boolean makeBricks(int small, int big, int goal) { 
    /* Not enough bricks to make the goal so don't bother */ 
    if (goal > small + big * 5) 
    return false; 

    /* How many big bricks can we use */ 
    int bigBricksToUse = Math.min(big, (goal/5)); 

    /* If we use that many bigs, do we have enough small */ 
    return goal - (bigBricksToUse * 5) <= small; 
} 

Answer 6

Aquí hay otro problema en la práctica pensé en eso es bastante similar a este problema, simplemente pensé que había puesto él y ver si funciona para la gente:

le otorgan una reputación SO int empezando por y una reputación de objetivo int SO que es más alta que la reputación inicial. Solo responde preguntas para que gane reputación solo por 10 o 15. También puede votar por abajo para que también pueda perder su reputación en 1. ¿Cuál es la cantidad mínima de reputación que debe perder para alcanzar el objetivo reputación?

ejemplo: se empieza con 715 y desea llegar a la respuesta es 888. 2.

para aumentar el desafío cambiar los enteros a los largos y de no utilizar un bucle.

Answer 7

Aquí está mi respuesta original; no funcionó para las otras pruebas, pero en ese momento no pude entender cómo no lo hizo (todavía no puedo), y la respuesta correcta me molesta, porque a pesar de que comprueba que es una mierda, en realidad funciona porque una determinada declaración es malditamente falsa. Rant diatriba diatriba, bien de cualquier manera aquí:

 
public boolean makeBricks(int small, int big, int goal) {
 

if(goal<=((big*5)+small) && goal%(big*5)<=small){ 
    return true; 
    } 
    return false; 
} 

respuesta correcta, aunque puede chupar:

 
public boolean makeBricks(int small, int big, int goal) {
 

if(goal<=((big*5)+small) && goal%5<=small){ 
    return true; 
    } 
    return false; 
} 

si lo pequeño es> = el resto, debe ser verdadera, y siempre lo será, y si no es así, no puede ser cierto. ¿Por qué mi camino no funciona, y de esta manera trabajar en su imperfección? Sí, el enunciado anterior (objetivo < = ((grande * 5) + pequeño)) corta todas las instancias en las que no funciona, pero hice esa declaración general para cancelar que todo lo que no sea igual a la suma total de pulgadas sea falso. no con ese propósito, lo derivé del viejo problema matemático en cada tema matemático que he tenido hasta ahora, que se descompone en la forma más simple para esto: w = (ax + bx) donde w = entero a = un número (en este caso 5) valora una operación mayor que el número representado por b (en este caso 1) y x es el LCF entre los dos valores que se encuentran (en este caso 1 de nuevo) más adecuadamente por este problema algebraico geométrico un ángulo es 36 grados más de dos veces su ángulo suplementario (x = 2 (180-x) +36; x = 396-2x; 3x = 396; x = 132). Normalmente, se da una pista en cuanto a la cantidad de un grupo, no solo las variables. Y qué pasa con el mío, ¿dónde está la instancia en la que no funciona?

Answer 8

Esta es mi respuesta.

private static boolean makeBricks (int small, int big, int goal) { 

    return ((big * 5 + small) >= goal) && (goal % big <= small); 
} 

Answer 9

private boolean makeBricks (int small, int big, int goal) { 
    return !(big*5 + small < goal || small < goal%5); 
} 

sólo utiliza los operadores booleanos para comprobar la ausencia de los dos casos de fallo !(fail || fail). Lo obvio, no hay suficientes ladrillos para hacer que el objetivo big*5 + small < goal. El menos obvio, no es suficiente con pequeños bloques cuando el objetivo no es un múltiplo par de 5 small < goal%5.

Answer 10

Ladrillos clase pública {

public boolean checkMethod(int small, int big, int goal) { 
    if (goal <= small + big * 5 && goal >= big * 5) { 
     return true; 
    } else 
     return false; 
} 

public static void main(String args[]) { 
    Bricks brick = new Bricks(); 
    System.out.println(brick.checkMethod(10, 0, 10)); 
} 

}

Answer 11

private boolean makeBricks(int small, int big, int goal) 
{ 
    if (goal < 0 || big < 0 || small < 0) 
    { 
     throw new IllegalArgumentException(); 
    } 
    else return goal - (5 * big + small) <= 0; 
} 

eso es todo. Así es como se hace.

Answer 12

Aquí está la solución perfecta:

public static boolean makeBricks(int small, int big, int goal) { 

    int totalInches = small + big*5; 
    if(totalInches < goal){ 
     return false; 
    } 

    int bigInches= big*5; 
    int smallRequired = goal %5; 

    if(smallRequired > small && bigInches != goal){ 
     return false; 
    }else if(smallRequired <=small){ 
     if(bigInches >= goal || smallRequired + bigInches == goal || small +bigInches ==goal 
       || small+ bigInches == goal){ 
      return true; 
     }if(bigInches + small > goal){ 
      if(small > goal-bigInches){ 
       return true; 
      } 
     } 

    } 
    return false; 
} 

Answer 13

Es probable que ninguna solución perfecta, pero quizás un poco más comprensible que las anteriores:

public boolean makeBricks(int small, int big, int goal) { 
    //not testing for invalid input - no invalid input from codingbat.com (in this case) 

    int obviousDemandSmall = goal%5; 
    if (obviousDemandSmall>small) return false; 

    boolean needSmallToMakeUpForBig = (goal/5>big) ? true : false; 
    if (!needSmallToMakeUpForBig) return true; 

    int superfluousSmallFromFirstGlance = small-obviousDemandSmall; 
    int extraSmallCanMakeThisManyBig = superfluousSmallFromFirstGlance/5; 
    int missingBig = goal/5-big; 
    if (extraSmallCanMakeThisManyBig>=missingBig) return true; 

    return false; 
} 

Answer 14

if (goal < 0 || big < 0 || small < 0) { 
      throw new IllegalArgumentException(); 
     } else { 
      int reqBig = goal/5; 
      int reqSamll = goal % 5; 

      if (reqBig <= big && reqSamll <= small) 
       return true; 
      else if (reqBig > big) { 
       int remainingLen = goal - (big * 5); 
       if (remainingLen <= small) 
        return true; 
       else 
        return false; 
      } else 
       return false; 
     } 

Answer 15

También usted puede intentar esto:

public boolean makeBricks(int small, int big, int goal) { 
return goal - big * 5 <= small 
     && goal % 5 <= small; 
}