Wie erstelle ich eine Methode für die Rückgabe von 1 oder ohne Verwendung von Bedingungen?

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

Dies könnte zum Umschalten zwischen einem beliebigen Wert und 0, EG 3, verwendet werden:

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

Um nur den return 0 am Ende des Beispiels in der Frage zu behandeln:

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

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

Wir können hier den Operator xor verwenden. Xor ist "exklusiv oder" und gibt eine 0 zurück, wenn es zwei oder null Eins gibt, und 1, wenn es genau eine 1 gibt. Dies tut dies für jedes Bit der Ganzzahl.

So hat zum Beispiel das Binärzeichen 1001 ^ 1000 = 0001 als erstes Bit zwei Einsen, also 0, die nächsten zwei haben keine Einsen, also Null, und das letzte Bit hat nur eine 1 und gibt eine 1 aus.

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

Meine ursprüngliche Antwort

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

und die modifizierte, wie von @The Photon vorgeschlagen

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

Ein anderer Ansatz basiert auf dem Verhalten der Ganzzahldivision in C# und der Vermeidung der Ausnahmebehandlung. 

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

Alle drei Methoden liefern die gleichen Ergebnisse:

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

Sie können einen bitweisen Operator wie folgt verwenden:

value ^ 1

^ ist der bitweise XOR - Operator, der "das Bit kopiert, wenn es in einem Operanden, aber nicht in beiden gesetzt ist". Die Darstellung von 1 und 0 in Bits ist wie folgt:

1 = 0000 0001

0 = 0000 0000

Wenn value = 1 ist, müssen Sie Folgendes tun:

1 ^ 1 = (0000 0001) ^ (0000 0001) = 0000 0000 = 0, da, da sie die gleichen Bits verwenden, keines der Bits kopiert wird.

Wenn der Wert = 0 ist, müssen Sie Folgendes tun:

0 ^ 1 = (0000 0000) ^ (0000 0001) = 0000 0001 = 1, da das letzte Bit in einem der Operanden 1 ist, im anderen jedoch 0. 

Alternativ kann eine try/catch-Funktion verwendet werden, bei der 0/Wert ist.
- Funktion funktioniert ohne Verwendung einer Math-Bibliothek.
- Funktion arbeitet mit ALL Integer-Werten;

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

Die Auswahl des Wertes erfolgt durch Auslösen eines Kompilierungsfehlers:
Eine durch Null dividierte Null löst normalerweise Kompilierfehler aus. Dann wird 1 zurückgegeben.
A Ein beliebiger von Null abweichender Wert gibt 0 zurück.

Angenommen, Ihre Sprache hat etwas Äquivalent zu get the absolute value of this number, dann etwas wie

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

würde funktionieren.

Bitte überprüfen Sie meine C#-Lösung ( .NET Fiddle ):

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

Beispiele:

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;

Es funktioniert für alleint-Werte (außer int.MinValue).

Es wurden nur logische und arithmetische Operationen ohne Klassen wie Math, Convert usw. verwendet.

Erläuterung:

• Führen Sie XOR operator für die Eingangsnummer x und die negative Eingangsnummer -1 * x aus. Der beschriebene Operator XOR für C# ist (-x ^ x). 
• Der Operator XOR gibt eine Zahl mit Vorzeichenbit zurück, wenn x eine Zahl ungleich Null ist (natürlich gibt XOR mit Nullzahlen 0 zurück
• Das Vorzeichenbit ist ein linkes Bit der Zahl. Das Vorzeichenbit ist das 32. Bit für die Variable int.
• Führe right-shift operator aus und platziere das Vorzeichenbit an erster Stelle für int number: (-x ^ x) >> 31
• (-x ^ x) >> 31 gibt -1 für jeden Wert ungleich Null zurück int (für die Zahl Null gibt es 0 zurück)
• Addiere 1 und gib das Ergebnis zurück

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

Ich denke, es geht um die Berechnung der Bit-1-Zahl.

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

Die Ausgabe sollte also wie folgt aussehen:

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

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

Die Verwendung von bitweisem Xor ist wahrscheinlich der effizienteste Weg, dies zu tun

return value ^ 1

da Eingaben nur [1, 0] sind, ist es auch möglich, eine Methode zur Rückgabe der 0 an die Eingangsleistung zu erstellen

In Java

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

Dieselbe Logik kann für jede andere Sprache angewendet werden

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

In Anbetracht des Wertebereichs von i ist [0,1]

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

Das ist ziemlich sinnlos ...

wenn keine anderen Eingaben vorhanden sind 

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

String Trickerei!

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

Dies setzt voraus, dass indexOf/IndexOf -1 liefert, wenn keine Übereinstimmung gefunden wurde.