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

мне задали вопрос в интервью, чтобы вернуть 1, Если предоставлено 0 и вернуть 0, если предоставлено 1 без использования условий i.e if, ternary etc

просто, чтобы дать вам и идею ниже кода без if:

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

Java Fiddle

обновление: Хотя ответ @Usagi может показаться наилучшим в отношении кода, который я написал .. но, переосмыслив вопрос, я вновь проанализировал ответы .. и ответ @Sergio кажется самым простым и наиболее подходящий. .

15 ответов


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

return 1 - value;


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

это может использоваться для переключения между любым значением и 0, например 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;
    }
}

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

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

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

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

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

и модифицированный, как предложено @Фотон

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 

вы можете использовать побитовый оператор, например:

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 в другой.


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

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

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


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

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

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


Я думаю, что вопрос заключается в вычислении количества бит-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; 

пожалуйста, просмотрите мой 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;

он работает все int (кроме int.MinValue).

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

объяснение:

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

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

математика.пол(1 / (1 + математика.abs (x)))


строка обман!

Java:

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

C#:

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

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


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

в java

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

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


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

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

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

return value ^ 1


заданный диапазон значений i равен [0, 1]:

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

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