Échanger des valeurs de variable sans utiliser de variable temporaire en C#

1. Utiliser l’assignation de tuple en C#
2. Utilisez l’opérateur + pour contourner la variable temporaire utilisée en C#
3. Utilisez une fonction pour échanger des valeurs plutôt qu’une implémentation explicite pour masquer l’utilisation de variables temporaires dans C#
4. Comment utiliser l’opérateur XOR pour permuter en C#

Donc, disons que vous écrivez un code maintenant et que vous voulez échanger des valeurs de variables. Vous ferez probablement quelque chose comme ceci :

using System;

public class Program
{
  public static void Main(string[] args)
  {
      var val_one = 123;
      var val_two = 234;

      var val_swap = val_one;
      val_one = val_two;
      val_two = val_swap;

      Console.WriteLine("The value after swapping is: " + val_one + " and -> " + val_two);
  }
}

Maintenant, ici, vous créez d’abord une variable temporaire appelée val_swap, puis vous y copiez la valeur val_one de sorte qu’après la modification de la valeur val_one, vous pouvez facilement copier la valeur val_one d’origine dans val_two en y affectant la valeur de val_swap.

Aujourd’hui, nous chercherons à éliminer l’utilisation de cette variable temporaire et à effectuer un tel échange sans aucune autre allocation.

Utiliser l’assignation de tuple en C#

Une méthode très simple que vous pouvez maintenant utiliser consiste à utiliser une affectation TUPLE comme suit.

(val_one, val_two) = (val_two, val_one);

Console.WriteLine("The value after swapping from the tuple method is: " + val_one + " and -> " +
                  val_two);

Production:

The value after swapping from the tuple method is: 234 and -> 123

Cette méthode a également été utilisée en Python ; cependant, pas soumis aux tuples.

Cependant, il faut parfois utiliser des astuces pour obtenir ce que l’on veut. Regardons un exemple ci-dessous.

Utilisez l’opérateur + pour contourner la variable temporaire utilisée en C#

Disons que nous avons deux nombres: 7 et 9. La première variable a la valeur 7, et la deuxième variable a la valeur 9.

Si nous ajoutons 9 à 7, nous obtiendrons 16. Attribuons maintenant 16 à la première variable.

Pour mettre 9 comme valeur de la première variable, il faut déduire la valeur de 9 de la deuxième variable, qui deviendrait 15-9 = 7 ; utilisez cette valeur et soustrayez-la de 15 dans la première variable pour obtenir maintenant la valeur 9.

val_one += val_two;
val_two = val_one - val_two;
val_one = val_one - val_two;

Console.WriteLine("The value after swapping is: " + val_one + " and -> " + val_two);

Production:

The value after swapping is: 234 and -> 123

Vous pouvez remarquer comment cela utilise une arithmétique simple pour arrêter d’utiliser des variables temporaires lors de l’échange. D’un autre côté, cela peut devenir inefficace s’il existe de très grandes valeurs précises, et l’utilisation d’une telle arithmétique peut entraîner la perte de certaines valeurs.

Si vous souhaitez masquer l’implémentation et ne pas simplement supprimer l’utilisation d’une variable temporaire, vous pouvez utiliser quelque chose comme ce qui suit.

Utilisez une fonction pour échanger des valeurs plutôt qu’une implémentation explicite pour masquer l’utilisation de variables temporaires dans C#

Vous pouvez faire quelque chose comme suit.

static void swap(ref int x, ref int y) {
  var temp = x;
  x = y;
  y = temp;
}

Et puis appelez-le ci-dessous comme:

swap(ref val_one, ref val_two);
Console.WriteLine("The value after swapping is: " + val_one + " and -> " + val_two);

Production:

The value after swapping is: 234 and -> 123

Comment utiliser l’opérateur XOR pour permuter en C#

Regardons le code ci-dessous.

val_one ^= val_two ^= val_one ^= val_two;

Et sa sortie :

The value after swapping is: 0 and -> 123

Vous remarquerez que la première valeur est 0 même si la deuxième variable a maintenant la valeur de la première variable et fonctionne correctement.

Alors, comment résoudre ce problème ? Écrivons d’abord un code comme suit.

val_one ^= val_two;
val_two ^= val_one;
val_one ^= val_two;

Et maintenant la sortie est :

The value after swapping is: 234 and -> 123

Alors que se passe-t-il? Commençons par comprendre le code donné dans la première instruction.

Cela peut être étendu comme suit.

val_one = val_one ^ val_two;
val_two = val_two ^ val_one;
val_one = val_one ^ val_two;

Maintenant, vous pouvez dire que le premier code est similaire à celui présenté plus tard, alors comment ne fonctionne-t-il pas, mais ce dernier fonctionne bien ?

Un changement dans l’ordre de ces opérations arithmétiques peut donner des résultats différents. Dans l’ancien code, val_one a un XOR avec lui-même, ayant ainsi le résultat comme 0.

Dans ce dernier, cependant, l’ordre est déjà défini et les valeurs sont parfaitement calculées, d’où la différence.

Cependant, rappelez-vous de ne pas utiliser l’échange XOR pour des niveaux de code plus élevés. Il est dangereux et doit être conservé comme substitut.