Поменять местами два числа, не используя третью переменную: C, Python Программа

В программировании подмена языка означает замену значений двух переменных. Переменная может содержать число, строку, список или массив, объект и т. д. Общий способ замены — использовать временную переменную для хранения значений. Например,

Обменять два Numbers

Общие этапы замены двух чисел:

  • Объявлена ​​временная переменная C
  • Присвойте значение A значению C, что означает C = A. Теперь C = 20.
  • Присвойте значение B значению A, поэтому A = 30.
  • Присвойте значение C значению B, поэтому B = 20, поскольку C имеет значение 20.

Именно так осуществляется замена с помощью временной переменной. Этот метод будет работать как для целых чисел, так и для чисел с плавающей запятой.

Обмен с использованием арифметического уравнения

Как мы знаем, замена означает замену содержимого двух объектов, полей или переменных. Обмен с использованием арифметической операции означает выполнение операции обмена с использованием математического уравнения, т. е. сложения и вычитания.

Если нам даны два числа и их просят поменять местами без использования временной переменной, то, используя три арифметических уравнения, мы можем поменять местами числа.

Псевдокод для замены чисел с помощью арифметической операции:

A = A + B
B = A - B
A = A - B

Предположим, у нас есть два числа: A = 20 и B = 30.

Состояние 1:    А = А+Б

                  Итак, текущее значение A равно 20+30 = 50.

Состояние 2:    Б = АВ

                   Теперь Б = 50-30 = 20
                   Мы видим, что мы получили значение A в B.

Состояние 3:    А = АВ

                   Наконец, А = 50-20 = 30
                   A имеет начальное значение B.

Итак, мы просто поменяли номера местами.

Вот программа для обмена двух чисел на языке C/C++:

#include<stdio.h>
int main()
{
	int a, b;
	printf("Enter value of A: ");
	scanf("%d", & a);
	printf("Enter value of B: ");
	scanf("%d", & b);
	printf("A = %d, B = %d", a, b);
	a = a + b;
	b = a - b;
	a = a - b;
	printf("\nNow, A = %d, B = %d", a, b);
}

Вывод:

Enter value of A: 20
Enter value of B: 30
A = 20 , B = 30
Now, A = 30 , B = 20

Программа в Python:

a = int(input("Enter value of A: "))
b = int(input("Enter value of B: "))
print("A = {} and B = {}".format(a, b))
a = a + b
b = a - b
a = a - b
print("Now, A = {} and B = {}".format(a, b))

Вывод:

Enter value of A: 20
Enter value of B: 30
A = 20 , B = 30
Now, A = 30 , B = 20

Сейчас в Python, нам даже не нужно выполнять арифметические операции. Мы можем использовать:

а, б = б, а

Вот демонстрация, где a=20, b=30;

Обмен с использованием арифметического уравнения

Обмен с использованием побитового XOR Operaтор

Этот метод также известен как обмен XOR. XOR означает исключающее ИЛИ. В этой побитовой операции мы принимаем два бита в качестве входных данных для XOR. Чтобы получить один выходной результат операции XOR, только один входной сигнал должен быть равен 1. В противном случае выходной сигнал будет равен 0. В следующей таблице показаны выходные данные для всех комбинаций входных данных A B.

Нам нужно знать, как работает операция XOR, чтобы поменять местами два числа с помощью побитовой операции. Вот таблица для XOR, где A и B — входные значения.

A B А исключающее ИЛИ Б
0 0 0
0 1 1
1 0 1
1 1 0

Если два входа имеют одинаковое значение, операция XOR дает 0; в противном случае — 1. В этом примере мы будем использовать операцию 3 XOR. В большинстве языков программирования XOR обозначается как «^».

Предположим, A=4 (в двоичном формате = 0100) и B=7 (в двоичном формате 0111).

Состояние 1:    А = А ^ Б

A 0 1 0 0
B 0 1 1 1
А ^ В 0 0 1 1

Теперь A = 0011 (в двоичном формате).

Состояние 2:    Б = А^Б

A 0 0 1 1
B 0 1 1 1
А ^ В 0 1 0 0

Итак, B = 0100, что было начальным двоичным значением A.

Состояние 3:    А = А^Б

A 0 0 1 1
B 0 1 0 0
А ^ В 0 1 1 1

Наконец, A = 0111, что было эквивалентным двоичным значением B.

Программа на C/C++:

#include<stdio.h>
int main()
{
	int a, b;
	printf("Enter value of A: ");
	scanf("%d", & a);
	printf("Enter value of B: ");
	scanf("%d", & b);
	printf("A = %d, B = %d", a, b);
	a = a ^ b;
	b = a ^ b;
	a = a ^ b;
	printf("\nNow, A = %d, B = %d", a, b);
}

Вывод:

Enter value of A:4
Enter value of B:7
A=4, B=7
Now, A=7, B=4.

Программа в Python:

a = int(input("Enter value of A: "))
b = int(input("Enter value of B: "))
print("A = {} and B = {}".format(a, b))
a = a ^ b
b = a ^ b
a = a ^ b
print("Now, A = {} and B = {}".format(a, b))

Вывод:

Enter the value of A:10
Enter the value of B:15
A=10 and B=15
Now, A=15,B=10.

Обмен Numbers с использованием побитовой арифметики

Этот метод аналогичен арифметическому методу, но для выполнения сложения и вычитания мы будем использовать побитовые операции, такие как И, ИЛИ и Комплимент. Прежде чем перейти к шагам, давайте быстро просмотрим «Комплимент».

Дополнение до 1 означает замену всех 0 на 1 и 1 на 0. Давайте приведем пример.

  • Предположим, число 23 — десятичное число.
  • Преобразование в двоичный формат дает использование 10111. Битов всего 5, но компьютер хранит числа в 8,16,32,64..битах. Итак, давайте добавим ноль перед двоичным числом. Это не изменит исходное значение числа. Так что это станет 00010111.
  • Как мы знаем, дополнение до 1 означает замену всех 0 на 1 и 1 на 0, поэтому выполнение дополнения до 1 00010111 дает 11101000

Дополнение к единице обозначается символом «~» в большинстве языков программирования. Помещение этого символа перед любыми целочисленными значениями или значениями с плавающей запятой даст дополнение до 1.

А дополнение до 2 означает добавление двоичной «1» к дополнению до 1. Если мы дополним 2 к указанному выше числу:

  • Двоичный = 00010111
  • 1 комплимент = 11101000
  • 2-й комплимент:

          11101000

          + 1

          11101001

Итак, дополнение до 2 равно 11101001. Это двоичный код для -23.
Вкратце, для выполнения дополнения до двух числа А это будет выглядеть так:

Дополнение до 2 к A = (~A) + 1

Теперь предположим, что A=8 (двоичный 00001000), B=10(00001010).

Состояние 1:    А = (А и В) + (А | В)

                   Это эквивалентно А = А + В.

                   А и Б = 00001000 и 00001010 = 00001000

                   А | Б = 00001000 | 00001010 = 00001010

Теперь 00001000 + 00001010 = 00010010 (десятичное 18).

Итак, А = 18

Состояние 2: В = А + (~В) + 1

                   Это эквивалентно B = AB

Здесь В = А – В

Судя по приведенному выше обсуждению, если нам нужно выполнить вычитание, мы выполняем дополнение до 2 к отрицательному числу, а затем добавляем его.

Итак, -B = ~B + 1.

Теперь B = 00010010 + (11110101) + 1 = 00001000.

Значение B эквивалентно десятичному числу 8, которое было начальным значением.

Состояние 3: А = А + (~В) + 1

                   Это эквивалентно A = AB

Теперь А = 00010010 + 11110111 + 1.

          A = 00001010 (эквивалент десятичной 10)

Наконец, A получил значение B. Таким образом, обмен был завершен.

Программа на C/C++:

#include<stdio.h>
int main()
{
	int a, b;
	printf("Enter value of A: ");
	scanf("%d", & a);
	printf("Enter value of B: ");
	scanf("%d", & b);
	printf("A = %d, B = %d", a, b);
	a = (a & b) + (a | b);
	b = a + ~b + 1;
	a = a + ~b + 1;
	printf("\nNow, A = %d, B = %d", a, b);
}

Вывод:

Enter the value of A: 8
Enter the value of B:10
A=8, B=10
Now, A=10, B=8

Программа в Python:

a = int(input("Enter value of A: "))
b = int(input("Enter value of B: "))
print("A = {} and B = {}".format(a, b))
a = (a & b) + (a | b)
b = a + ~b + 1
a = a + ~b + 1
print("Now, A = {} and B = {}".format(a, b))

Вывод:

Enter the value of A: 25
Enter the value of B: 25
A = 25 and B = 25
Now, A = 25 and B = 25

Что такое арифметическое переполнение?

Термин «переполнение» означает превышение лимита. Арифметическое переполнение означает, что результат любой арифметической операции выходит за пределы диапазона или предела представления чисел в архитектуре компьютера. Например, если число разделить на ноль, оно станет бесконечным, и компьютерная система счисления не сможет удержать его в 32 или 64 битах.

Представление целочисленного числа
Представление целочисленного числа в 32-битной системе

Последствием арифметического переполнения может быть:

  • Сложение двух положительных чисел становится отрицательным. Потому что знаковый бит может стать равным 1, что означает отрицательное число.
  • Сложение двух отрицательных чисел становится положительным. Потому что знаковый бит может стать равным 0, что означает положительное число.