Как создать метод для возврата 1 или 0 без использования условий?

Ответ 1

Если вам даны только 0 и 1, это может быть проще:

return 1 - value;

Ответ 2

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

Это может использоваться для переключения между любыми значениями и 0, EG 3:

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

И просто чтобы покрыть return 0 в конце образца в вопросе:

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

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

Ответ 3

Здесь мы можем использовать оператор xor. Xor является "эксклюзивным или" и возвращает 0, когда есть два или ноль 1, и возвращает 1, если он ровно один. Он делает это на каждом бите целого числа.

Итак, например, двоичный файл 1001 ^ 1000 = 0001 в качестве первого бита имеет два 1, поэтому 0, следующие два не имеют 1, поэтому нуль, а последний бит имеет только один 1, выводящий 1.

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

Ответ 4

Мой оригинальный ответ

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

и измененный, предложенный @The Photon

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

Другой подход основан на поведении целочисленного деления в C# и избегает использования обработки исключений.

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

Все три метода возвратят те же результаты:

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

Ответ 5

Вы можете использовать побитовый оператор следующим образом:

value ^ 1

^ - побитовый оператор XOR, который "копирует бит, если он установлен в один операнд, но не оба". Представление 1 и 0 в битах выглядит следующим образом:

1 = 0000 0001

0 = 0000 0000

Итак, когда value = 1, вы закончите:

1 ^ 1 = (0000 0001) ^ (0000 0001) = 0000 0000 = 0, поскольку, поскольку они имеют одни и те же биты, ни один из битов не копируется.

Теперь, если value = 0, вы закончите:

0 ^ 1 = (0000 0000) ^ (0000 0001) = 0000 0001 = 1, потому что последний бит равен 1 в одном из операндов, но 0 в другом.

Ответ 6

Предполагая, что ваш язык имеет что-то эквивалентное get the absolute value of this number, тогда что-то вроде:

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

будет работать.

Ответ 7

Альтернативно, функция try/catch, которая делит 0/значение.
- Функция работает без использования математической библиотеки;
- Функция работает со всеми значениями Integer,

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

Выбор значения осуществляется путем запуска ошибки компиляции:
Ноль, деленный на ноль, обычно вызывает ошибки компиляции. Затем возвращает 1; Zero делит любое значение, отличное от Zero возвращает 0;

Ответ 8

Я думаю, вопрос заключается в вычислении количества бит-1.

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

Таким образом, вывод должен быть следующим:

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

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

Ответ 9

Обман струн!

Java:

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

С#:

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

Это полагается на indexOf/IndexOf, возвращающий -1, если совпадение не найдено.

Ответ 10

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

Ответ 11

рассматриваемые входы только [1, 0] также можно сделать метод для возврата 0 к мощности ввода

В java

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

Та же логика может применяться для любого другого языка

Ответ 12

если нет других входов, разрешено

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

Ответ 13

Использование побитового xor - это, вероятно, самый эффективный с точки зрения вычисления способ

return value ^ 1

Ответ 14

Учитывая диапазон значений i, это [0, 1]:

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

Это довольно бессмысленно...

Ответ 15

Пожалуйста, просмотрите мое решение C# (.NET Fiddle):

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

Примеры:

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;

Он работает для значений all int (кроме int.MinValue).

Использовались только логические и арифметические операции без классов Math, Convert и т.д.

Пояснение:

• Выполнить XOR для ввода номера x и отрицательного номера ввода -1 * x. Описанный оператор XOR для C# - (-x ^ x)
• Оператор XOR возвращает число со знаковым битом, если x не равно нулю (конечно, XOR с нулевыми номерами возвращает 0)
• Знаковый бит - это левый бит числа. Битовый бит - 32-й бит для номера int.
• Выполнить right-shift оператор и поместить знак знака на первое место для int number: (-x ^ x) >> 31
• (-x ^ x) >> 31 возвращает -1 для любого ненулевого значения int (для нулевого числа он возвращает 0)
• Добавить 1 и вернуть результат

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