java - para - manual programacion android español pdf

¿Cómo crear un método para devolver 1 o 0 sin usar condiciones?

Question

Se me hizo una pregunta en una entrevista para devolver 1 si se proporcionó 0 y devolvió 0 si se proporcionó 1 sin usar las condiciones, es decir, si es ternario, etc.

Solo para darles una idea y código debajo de if''s:

public int testMethod(int value){
    if(value==0) return 1;
    if(value==1) return 0;
    return 0;
}

Java Fiddle

ACTUALIZACIÓN: Aunque la respuesta de @ Usagi puede parecer la mejor opción con respecto al código que escribí ... pero reconsiderando la pregunta, volví a analizar las respuestas ... y la respuesta de @ Sergio parece la más simple y la que mejor se ajusta ...

Answer 1

Alternativamente, una función try / catch que divide 0 / valor.
- La función funciona sin usar ninguna biblioteca matemática;
- La función funciona con TODOS los valores enteros;

public int MethodTest(int value)
{
     try
     {
         return (0/value);
     } 
     catch(Exception ex)
     {
         return 1;
     }
}

La elección del valor se realiza activando un error de compilación:
Un cero dividido por cero generalmente desencadena errores de compilación. Luego devuelve 1;
Un cero dividió cualquier valor diferente de cero devuelve 0;

Answer 2

Asumiendo que su idioma tiene algo equivalente para get the absolute value of this number entonces algo como:

public int testMethod(int value) {
  return Math.abs(value - 1);
}

trabajaría.

Answer 3

Creo que la pregunta es sobre calcular el conteo de bits-1.

public int testMethod(int value){
   //             v---  count = value == 0 ? 32 : [0,32)
   return Integer.bitCount(~value) / 32;
}

Así que la salida debe ser la siguiente:

//      v--- return 1
assert  testMethod(0) == 1; 

//      v--- return 0
assert  testMethod(nonZero) == 0; 

Answer 4

Dado el rango de valor i es [0, 1]:

public int test(int i) {
    return !i;
}

Esto es bastante inútil ...

Answer 5

El uso de bitwise xor es probablemente la forma más computacionalmente eficiente de hacerlo

return value ^ 1

Answer 6

Math.floor (1 / (1 + Math.abs (x)))

Answer 7

Mi respuesta original

public int TestMethod(int value)
{
     return Convert.ToInt32(!Convert.ToBoolean(value));
}

y la modificada según lo sugerido por @The Photon.

public int TestMethod(int value)
{
     return Convert.ToInt32(value == 0);
}

Un enfoque diferente se basa en el comportamiento de la división de enteros en C# y evita el uso del manejo de excepciones.

public int TestMethod(int value)
{
    return 1 / ((10 * value) + 1);
}

Los tres métodos devolverán los mismos resultados:

In | Out
-2 | 0 
-1 | 0
 0 | 1
 1 | 0
 2 | 0 

Answer 8

Podemos usar el operador xor aquí. Xor es "exclusivo o" y devuelve un 0 cuando hay dos o cero 1 y devuelve 1 si hay exactamente un 1. Hace esto en cada bit del entero.

Entonces, por ejemplo, el binario 1001 ^ 1000 = 0001 ya que el primer bit tiene dos 1, así que 0, los dos siguientes no tienen 1, así que cero, y el bit final solo tiene un 1, lo que da un 1.

public int testMethod(int value){
    return value ^ 1;
}

Answer 9

Por favor revise mi solución C# ( .NET Fiddle ):

private static int Calculate(int x)
{
    return ((-x ^ x) >> 31) + 1;
}

Ejemplos:

Input: 0;           Output: 1;
Input: 1;           Output: 0;
Input: 64;          Output: 0;
Input: 65;          Output: 0;
Input: -100;        Output: 0;
Input: -101;        Output: 0;
Input: 102;         Output: 0;
Input: 888887;      Output: 0;
Input: 2147483647;  Output: 0;
Input: -2147483648; Output: 1;

Funciona para todos los valores int (excepto int.MinValue ).

Solo se utilizaron operaciones lógicas y aritméticas sin clases de Math , Convert , etc.

Explicación:

• Ejecute el operador XOR para el número de entrada x y el número de entrada negativo -1 * x . El operador XOR descrito para C# es (-x ^ x)
• El operador XOR devuelve el número con el bit de signo si x no es un número cero (por supuesto, XOR con números cero devuelve 0)
• El bit de signo es un bit izquierdo del número. El bit de signo es el bit 32 ''y para el número int .
• Ejecute right-shift operador de right-shift y coloque el bit de signo en el primer lugar para el número int : (-x ^ x) >> 31
• (-x ^ x) >> 31 devuelve -1 para cualquier valor int distinto de cero (para el número cero devuelve 0)
• Añadir 1 y devolver el resultado

<iframe width="100%" height="475" src="https://dotnetfiddle.net/Widget/x4HCYj" frameborder="0"></iframe>

Answer 10

Puedes usar un operador de bitwise así:

value ^ 1

^ es el operador XOR a nivel de bits que "copia el bit si se establece en un operando pero no en ambos". La representación de 1 y 0 en bits es la siguiente:

1 = 0000 0001

0 = 0000 0000

Entonces cuando valor = 1 terminas haciendo:

1 ^ 1 = (0000 0001) ^ (0000 0001) = 0000 0000 = 0 porque, como comparten los mismos bits, ninguno de los bits se copia.

Ahora si valor = 0 terminas haciendo:

0 ^ 1 = (0000 0000) ^ (0000 0001) = 0000 0001 = 1 porque el último bit es 1 en uno de los operandos pero 0 en el otro.

Answer 11

Si no hay otras entradas están permitidas.

    static int Test(int @value)
    {
        return (@value + 1) % 2;
    }

Answer 12

Si te dan solo 0 y 1, esto podría ser más simple:

return 1 - value;

Answer 13

Trucos de cuerdas!

Java:

public int testMethod(int value) {
    return String.valueOf(value).substring(0, 1).indexOf(''0'') + 1;
}

DO#:

public int testMethod(int value) {
    return value.ToString().Substring(0, 1).IndexOf(''0'') + 1;
}

Esto se basa en indexOf / IndexOf que devuelve -1 si no se encontró ninguna coincidencia.

Answer 14

considerando que las entradas son solo [1, 0] también es posible crear un método para devolver el 0 a la potencia de entrada

En java

public int test(int value){
    return Math.pow(0,value);
}

La misma lógica puede aplicarse a cualquier otro idioma.

Answer 15

public int testMethod(int value) {
  return 1 - (value % 2); // or 1 - (value & 1)
}

Esto podría usarse para cambiar entre cualquier valor y 0, EG 3:

public int testMethod3(int value) {
  return 3 - (value % 4);
}

Y solo para cubrir el return 0 al final de la muestra en la pregunta:

private static final int[] VALUES = { 1, 0 };

public int testMethod(int value) {
    try {
        return VALUES[value];
    } catch (ArrayIndexOutOfBoundsException ex) {
        return 0;
    }
}