Retourner l’autre argument de 2 arguments possibles sans utiliser de conditions

Par exemple, si une fonction est garantie pour recevoir 5 ou 7 comme argument, je souhaite que la fonction renvoie 5 si elle est reçue 7 et 7 si elle est reçue 5 sans utiliser aucune condition.

On m’a demandé cela dans une interview et j’étais plutôt perplexe, merci.

Arithmétique simple:

return 7 - input + 5;

(qui peut être simplifié comme return 12 - input; )

Disons que l’entrée est 7:

retour 7 – 7 + 5 -> retour 5

Ou si l’entrée est 5:

retour 7 – 5 + 5 -> retour 7

Vous pouvez utiliser n’importe quel calcul commutatif simple qui peut être inversé:

  • addition: f(x)=7+5-x
  • xor: f(x)=7^5^x
  • multiplication: f(x)=7*5/x
 public int f(int x) { return x ^ 2; } 

En binary:

 7 = 111 5 = 101 2 = 010 

XOR (^ in java) active le bit 2 s’il est éteint et éteint s’il est activé.

Que diriez-vous:

 public int q(int in) { static final int[] ret = {0, 0, 0, 0, 0, 7, 0, 5}; return ret[in]; } 

Si j’avais été l’intervieweur et que vous l’avez résolu uniquement pour une saisie numérique, ma prochaine question aurait été: “Comment résoudriez-vous ce problème pour une saisie non numérique?” parce que je ne chercherais pas d’intelligence mathématique. Au lieu de cela, qu’en est-il de cela?

 List options = new ArrayList<>(Arrays.asList("bob", "fred")); options.remove("bob"); System.out.println(options.get(0)); 

Cela peut évidemment être facilement adapté à n’importe quel type, y compris Object , tant que l’égalité des objects fonctionne correctement, et en prime, il peut être exprimé de manière beaucoup plus concise dans d’autres langages, tels que Groovy:

 println((["bob", "fred"] - "bob").first()) 

La sortie, dans les deux cas, est évidemment “fred”. Si j’étais l’intervieweur, c’est la réponse que je chercherais.

 public int xyz(int x) { return 35 / x; } 

Comment fonctionne le xor un? [pour le cas f (x) = 7 ^ 5 ^ x]

XOR (^) est OU exclusif et fonctionne de cette façon

 a|b|a^b ------- 0|0| 0 0|1| 1 1|0| 1 1|1| 0 

Donc, XOR (^) peut être utilisé pour changer des bits d’un certain nombre. Par exemple, lorsque nous voulons changer les deux derniers bits d’un nombre quelconque (comme xxxx10 à xxxx01 ), nous pouvons le faire avec le numbrer ^ 3 car 3 est le binary 00011.

Voici quelques faits sur XOR

  1. XOR est symésortingque -> a^b = b^a
  2. XOR est associatif -> (a^b)^c = a^(b^c)
  3. a^a = 0 (ceux dans a seront remplacés par des zéros et les zéros ne seront pas modifiés)

    exemple pour a = 157 (binary 010011101)

      010011101 ^ 010011101 ----------- 000000000 
  4. 0^a = a (ceux dans a ne peuvent changer que des zéros pour qu’ils les modifient)

      000000000 ^ 010011101 ----------- 010011101 

donc en utilisant les faits (1) et (2) 7^5^x == x^7^5 == x^5^7

Essayons de vérifier comment x^7^5 fonctionnera pour x=7 .

 (x^7)^5 = (7^7)^5 = 0^5 = 5 

Et même chose pour x=5

 (x^5)^7 = (5^5)^7 = 0^7 = 7