Comment créer une méthode pour retourner 1 ou sans utiliser de conditions?
On m’a posé une question lors d’une interview pour indiquer 1 si fourni 0 et 0 si disponible 1 sans utiliser les conditions suivantes: si, ternaire, etc.
Juste pour vous donner l’idée ci-dessous sans code si:
public int testMethod(int value){
if(value==0) return 1;
if(value==1) return 0;
return 0;
}
UPDATE: Bien que la réponse de @ Usagi puisse sembler la plus appropriée en ce qui concerne le code que j'ai écrit… mais en réexaminant la question, j'ai ré-analysé les réponses… et la réponse de @ Sergio semble la plus simple et la meilleure en forme ..
Si on ne vous donne que 0 et 1, cela pourrait être plus simple:
return 1 - value;
public int testMethod(int value) {
return 1 - (value % 2); // or 1 - (value & 1)
}
Cela pourrait utiliser pour basculer entre n'importe quelle valeur et 0, EG 3:
public int testMethod3(int value) {
return 3 - (value % 4);
}
Et juste pour couvrir le return 0 à la fin de l'échantillon dans la question:
private static final int[] VALUES = { 1, 0 };
public int testMethod(int value) {
try {
return VALUES[value];
} catch (ArrayIndexOutOfBoundsException ex) {
return 0;
}
}
Nous pouvons utiliser l'opérateur xor ici. Xor est "exclusif ou" et renvoie 0 s'il y a deux ou zéro, et renvoie 1 s'il y a exactement un 1. Il le fait sur chaque bit de l'entier.
Ainsi, par exemple, le binaire 1001 ^ 1000 = 0001 car le premier bit a deux 1, donc 0, les deux suivants n'ont pas de 1, donc zéro, et le dernier bit n'a qu'un 1, émettant un 1.
public int testMethod(int value){
return value ^ 1;
}
Ma réponse originale
public int TestMethod(int value)
{
return Convert.ToInt32(!Convert.ToBoolean(value));
}
et celui modifié comme suggéré par @The Photon
public int TestMethod(int value)
{
return Convert.ToInt32(value == 0);
}
Une approche différente est basée sur le comportement de la division entière dans C# et évite l'utilisation de la gestion des exceptions.
public int TestMethod(int value)
{
return 1 / ((10 * value) + 1);
}
Les trois méthodes renverront les mêmes résultats:
In | Out
-2 | 0
-1 | 0
0 | 1
1 | 0
2 | 0
Vous pouvez utiliser un opérateur au niveau des bits comme ceci:
value ^ 1
^ est l'opérateur binaire XOR qui "copie le bit s'il est défini dans un opérande mais pas les deux". La représentation de 1 et 0 en bits est la suivante:
1 = 0000 0001
0 = 0000 0000
Donc quand value = 1 vous finissez par faire:
1 ^ 1 = (0000 0001) ^ (0000 0001) = 0000 0000 = 0 car, étant donné qu'ils partagent les mêmes bits, aucun des bits n'est copié.
Maintenant si valeur = 0 vous finissez par faire:
0 ^ 1 = (0000 0000) ^ (0000 0001) = 0000 0001 = 1 car le dernier bit est 1 dans l'un des opérandes mais 0 dans l'autre.
Alternativement, une fonction try/catch qui divise 0/value.
- Function fonctionne sans utiliser aucune bibliothèque mathématique;
- Function fonctionne avec TOUTES les valeurs entières;
public int MethodTest(int value)
{
try
{
return (0/value);
}
catch(Exception ex)
{
return 1;
}
}
Le choix de la valeur se fait en déclenchant une erreur de compilation:
Un zéro divisé par zéro déclenche généralement des erreurs de compilation. Puis retourne 1;
Un zéro divisé en une valeur différente de zéro renvoie 0;
En supposant que votre langue a quelque chose d’équivalent à get the absolute value of this number, quelque chose comme:
public int testMethod(int value) {
return Math.abs(value - 1);
}
travaillerait.
Veuillez examiner ma solution C# ( .NET Fiddle ):
private static int Calculate(int x)
{
return ((-x ^ x) >> 31) + 1;
}
Exemples:
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;
Cela fonctionne pour les valeurs allint (sauf int.MinValue).
Seules les opérations logiques et arithmétiques sans les classes Math, Convert, etc. ont été utilisées.
Explication:
- Exécutez l'opérateur XOR pour le numéro d'entrée
xet le numéro d'entrée négatif-1 * x. L'opérateur XOR décrit pourC#est(-x ^ x) - L'opérateur XOR renvoie le numéro avec le bit de signe si
xest un nombre non nul (bien entendu, XOR avec des chiffres zéro renvoie 0) - Le bit de signe est un bit de gauche du nombre. Le bit de signe est le 32ème bit du nombre
int. - Exécutez l'opérateur décalage à droite et placez le bit de signe à la première place pour le numéro
int:(-x ^ x) >> 31 (-x ^ x) >> 31renvoie -1 pour toute valeurintdifférente de zéro (pour zéro nombre, elle renvoie 0)- Ajouter 1 et retourner le résultat
<iframe width="100%" height="475" src="https://dotnetfiddle.net/Widget/x4HCYj" frameborder="0"></iframe>Je pense que la question concerne le calcul du nombre de bits 1.
public int testMethod(int value){
// v--- count = value == 0 ? 32 : [0,32)
return Integer.bitCount(~value) / 32;
}
Donc, le résultat devrait être comme ci-dessous:
// v--- return 1
assert testMethod(0) == 1;
// v--- return 0
assert testMethod(nonZero) == 0;
Utiliser bitwise xor est probablement le moyen le plus efficace de le faire.
return value ^ 1
considérant que les entrées ne sont que [1, 0] il est également possible de faire une méthode pour retourner le 0 à la puissance de l'entrée
En java
public int test(int value){
return Math.pow(0,value);
}
Même logique peut être appliquée pour toute autre langue
Math.floor (1/(1 + Math.abs (x)))
Étant donné que la plage de valeur i est [0, 1]:
public int test(int i) {
return !i;
}
C'est assez inutile ...
s'il n'y a pas d'autres entrées autorisées
static int Test(int @value)
{
return (@value + 1) % 2;
}
Tromperie de cordes!
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;
}
Cela repose sur indexOf/IndexOf renvoyant -1 si aucune correspondance n'a été trouvée.