432 lines
13 KiB
Markdown
432 lines
13 KiB
Markdown
# ARPZ-s1-pr3
|
||
|
||
Алгоритмы решения прикладных задач, 1-й семестр, 3-я прктика
|
||
|
||
## Задание 1
|
||
Написать программу для сложения и вычитания двух больших чисел в
|
||
столбик. Для представления чисел использовать массив, в котором будут
|
||
храниться цифры числа. При реализации процедуры вычитания
|
||
предпочтительно из большего вычитать меньшее. Для этого
|
||
первоначально определять, какое из двух чисел больше
|
||
```cpp
|
||
#include <iostream>
|
||
|
||
int compare(int *a, int *b, int size)
|
||
{
|
||
// Сравнение чисел
|
||
// a - первое число
|
||
// b - второе число
|
||
// size - длина числа
|
||
|
||
for (int i = 0; i < size; i++)
|
||
{
|
||
if (a[i] > b[i])
|
||
{
|
||
return 1; // a > b
|
||
}
|
||
else if (a[i] < b[i])
|
||
{
|
||
return -1; // a < b
|
||
}
|
||
}
|
||
return 0; // a равно b
|
||
}
|
||
|
||
int* sum(int *A, int* B, int size)
|
||
{
|
||
// Сложение чисел
|
||
// a - первое число
|
||
// b - второе число
|
||
// size - длина числа
|
||
|
||
int *a = new int[size]();
|
||
int *b = new int[size]();
|
||
|
||
for (int i = 0; i < size; i++) {
|
||
a[i] = A[i];
|
||
b[i] = B[i];
|
||
}
|
||
|
||
// Инициализируем массив для хранения результирующего числа с длиной size
|
||
// ************************************************************************
|
||
// *ВНИМАНИЕ! Скобки на конце инициализируют массив нулями! ЭТО ВАЖНО!
|
||
// *В Windows массив может изначально содержать биты, неочищенные из памяти
|
||
// *после работы других программ, что приведет непредвиденным последствиям!
|
||
// ************************************************************************
|
||
int *result = new int[size]();
|
||
|
||
// Выполняем поразрядное сложение
|
||
for (int i = size - 1; i >= 0; i--)
|
||
{
|
||
int sum = a[i] + b[i];
|
||
result[i] = sum % 10; // Помещаем то, что оказалось меньше 10, в текущий разряд
|
||
|
||
if(i - 1 >= 0 && sum >= 10) // Избегаем вставку в следующий разряд при переполнении
|
||
{
|
||
b[i - 1] = b[i - 1] + sum / 10; // Помещаем то, что оказалось больше 10, в следующий разряд
|
||
}
|
||
}
|
||
|
||
// Очищаем память от временных массивов
|
||
delete[] a;
|
||
delete[] b;
|
||
|
||
// Возвращаем результирующий массив
|
||
return result;
|
||
}
|
||
|
||
int* subtract(int *A, int *B, int size)
|
||
{
|
||
|
||
int *a = new int[size]();
|
||
int *b = new int[size]();
|
||
|
||
for (int i = 0; i < size; i++)
|
||
{
|
||
a[i] = A[i];
|
||
b[i] = B[i];
|
||
}
|
||
|
||
int *result = new int[size]();
|
||
|
||
// Проверяем, какое из двух чисел больше
|
||
if (compare(a, b, size) == -1)
|
||
{
|
||
int *temp = a;
|
||
a = b;
|
||
b = temp;
|
||
}
|
||
|
||
// Выполняем поразрядное вычитание
|
||
for (int i = size - 1; i >= 0; i--)
|
||
{
|
||
if (a[i] < b[i])
|
||
{
|
||
// Если текущий разряд a меньше b, нужно занять 1 из следующего разряда
|
||
a[i - 1]--; // Уменьшаем следующий разряд
|
||
result[i] = a[i] + 10 - b[i]; // Добавляем 10 к текущему разряду и вычитаем b
|
||
}
|
||
else
|
||
{
|
||
result[i] = a[i] - b[i]; // Обычное вычитание
|
||
}
|
||
}
|
||
|
||
// Очищаем память от временных массивов
|
||
delete[] a;
|
||
delete[] b;
|
||
|
||
return result;
|
||
}
|
||
|
||
int main()
|
||
{
|
||
|
||
std::setlocale(LC_ALL, "ru");
|
||
|
||
int size;
|
||
int *a;
|
||
int *b;
|
||
|
||
std::cout << "Максимально предусматриваемая длина числа: ";
|
||
std::cin >> size;
|
||
|
||
// Инициализируем массивы чисел. Все элементы аналогично инициализируем нулями
|
||
a = new int[size]();
|
||
b = new int[size]();
|
||
|
||
std::cout << "Введите первое число: ";
|
||
for (int i = 0; i < size; i++)
|
||
{
|
||
std::cin >> a[i];
|
||
}
|
||
|
||
std::cout << "Введите второе число: ";
|
||
for (int i = 0; i < size; i++)
|
||
{
|
||
std::cin >> b[i];
|
||
}
|
||
|
||
int *resultSum = sum(a, b, size);
|
||
int *resultSub = subtract(a, b, size);
|
||
|
||
std::cout << "Результат сложения: ";
|
||
for (int i = 0; i < size; i++)
|
||
{
|
||
std::cout << resultSum[i] << " ";
|
||
}
|
||
std::cout << std::endl;
|
||
|
||
std::cout << "Результат вычитания: ";
|
||
for (int i = 0; i < size; i++)
|
||
{
|
||
std::cout << resultSub[i] << " ";
|
||
}
|
||
std::cout << std::endl;
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
## Задание 2
|
||
Написать программу для реализации ускоренного сложения чисел в
|
||
двоичной системе
|
||
```cpp
|
||
#include <iostream>
|
||
|
||
bool* addBinary(bool* A, bool* B, int size) {
|
||
bool* result = new bool[size]();
|
||
bool carry = false; // Перенос
|
||
|
||
for (int i = size - 1; i >= 0; i--) {
|
||
// Сложение с учетом переноса
|
||
bool sum = A[i] ^ B[i] ^ carry; // XOR для сложения
|
||
carry = (A[i] && B[i]) || (carry && (A[i] || B[i])); // Логика переноса
|
||
result[i + 1] = sum; // Запись результата
|
||
}
|
||
result[0] = carry; // Записываем перенос в старший бит
|
||
|
||
return result;
|
||
}
|
||
|
||
int main() {
|
||
std::setlocale(LC_ALL, "ru");
|
||
|
||
int size;
|
||
std::cout << "Введите длину двоичных чисел: ";
|
||
std::cin >> size;
|
||
|
||
bool* a = new bool[size]();
|
||
bool* b = new bool[size]();
|
||
|
||
std::cout << "Введите первое двоичное число (0 или 1): ";
|
||
for (int i = 0; i < size; i++) {
|
||
int bit;
|
||
std::cin >> bit;
|
||
a[i] = (bit != 0); // Преобразуем в bool
|
||
}
|
||
|
||
std::cout << "Введите второе двоичное число (0 или 1): ";
|
||
for (int i = 0; i < size; i++) {
|
||
int bit;
|
||
std::cin >> bit;
|
||
b[i] = (bit != 0); // Преобразуем в bool
|
||
}
|
||
|
||
bool* result = addBinary(a, b, size);
|
||
|
||
std::cout << "Результат сложения: ";
|
||
for (int i = 0; i < size + 1; i++) {
|
||
std::cout << result[i] << " ";
|
||
}
|
||
std::cout << std::endl;
|
||
|
||
// Освобождаем память
|
||
delete[] a;
|
||
delete[] b;
|
||
delete[] result;
|
||
|
||
return 0;
|
||
}
|
||
|
||
```
|
||
## Задание 3
|
||
В задании 2 была реализована идея ускорения суммирования двоичных
|
||
чисел. Реализуйте сложение десятичных чисел с использованием
|
||
подобного механизма ускорения.
|
||
```cpp
|
||
#include <iostream>
|
||
|
||
int* addDecimal(int* A, int* B, int size) {
|
||
int* result = new int[size + 1](); // Результат может быть на 1 разряд больше
|
||
int carry = 0; // Перенос
|
||
|
||
for (int i = size - 1; i >= 0; i--) {
|
||
// Сложение с учетом переноса
|
||
int sum = A[i] + B[i] + carry; // Сложение
|
||
result[i + 1] = sum % 10; // Текущий разряд
|
||
carry = sum / 10; // Перенос
|
||
}
|
||
result[0] = carry; // Записываем перенос в старший разряд
|
||
|
||
return result;
|
||
}
|
||
|
||
int main() {
|
||
std::setlocale(LC_ALL, "ru");
|
||
|
||
int size;
|
||
std::cout << "Введите длину десятичных чисел: ";
|
||
std::cin >> size;
|
||
|
||
int* a = new int[size]();
|
||
int* b = new int[size]();
|
||
|
||
std::cout << "Введите первое десятичное число (цифры от 0 до 9): ";
|
||
for (int i = 0; i < size; i++) {
|
||
std::cin >> a[i];
|
||
}
|
||
|
||
std::cout << "Введите второе десятичное число (цифры от 0 до 9): ";
|
||
for (int i = 0; i < size; i++) {
|
||
std::cin >> b[i];
|
||
}
|
||
|
||
int* result = addDecimal(a, b, size);
|
||
|
||
std::cout << "Результат сложения: ";
|
||
|
||
for (int i = 0; i < size + 1; i++) {
|
||
std::cout << result[i] << " ";
|
||
}
|
||
std::cout << std::endl;
|
||
|
||
// Освобождаем память
|
||
delete[] a;
|
||
delete[] b;
|
||
delete[] result;
|
||
|
||
return 0;
|
||
}
|
||
|
||
```
|
||
## Задание 4
|
||
Написать программу для умножения двух больших чисел столбиком.
|
||
Обратите внимание на количество цифр в произведении: их скорее всего
|
||
будет больше, чем в исходных числах
|
||
```cpp
|
||
#include <iostream>
|
||
|
||
void printArray(int* arr, int size)
|
||
{
|
||
// Печать массива, пропуская ведущие нули
|
||
bool leadingZero = true;
|
||
for (int i = 0; i < size; i++)
|
||
{
|
||
if (arr[i] != 0)
|
||
{
|
||
leadingZero = false;
|
||
}
|
||
if (!leadingZero)
|
||
{
|
||
std::cout << arr[i];
|
||
}
|
||
}
|
||
if (leadingZero)
|
||
{
|
||
std::cout << "0"; // Если все нули
|
||
}
|
||
std::cout << std::endl;
|
||
}
|
||
|
||
int* multiplyDecimal(int* A, int sizeA, int* B, int sizeB, int& resultSize)
|
||
{
|
||
resultSize = sizeA + sizeB; // Максимально возможный размер результата
|
||
int* result = new int[resultSize](); // Инициализируем массив нулями
|
||
|
||
// Умножаем каждую цифру первого числа на каждую цифру второго числа
|
||
for (int i = sizeA - 1; i >= 0; i--)
|
||
{
|
||
for (int j = sizeB - 1; j >= 0; j--)
|
||
{
|
||
int product = A[i] * B[j];
|
||
int sum = product + result[i + j + 1]; // Добавляем к текущему разряду результата
|
||
|
||
result[i + j + 1] = sum % 10; // Текущий разряд
|
||
result[i + j] += sum / 10; // Перенос
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
int main()
|
||
{
|
||
std::setlocale(LC_ALL, "ru");
|
||
|
||
int sizeA, sizeB;
|
||
std::cout << "Введите длину первого числа: ";
|
||
std::cin >> sizeA;
|
||
int* A = new int[sizeA];
|
||
|
||
std::cout << "Введите первое число (цифры от 0 до 9): ";
|
||
for (int i = 0; i < sizeA; i++)
|
||
{
|
||
std::cin >> A[i];
|
||
}
|
||
|
||
std::cout << "Введите длину второго числа: ";
|
||
std::cin >> sizeB;
|
||
int* B = new int[sizeB];
|
||
|
||
std::cout << "Введите второе число (цифры от 0 до 9): ";
|
||
for (int i = 0; i < sizeB; i++)
|
||
{
|
||
std::cin >> B[i];
|
||
}
|
||
|
||
int resultSize;
|
||
int* result = multiplyDecimal(A, sizeA, B, sizeB, resultSize);
|
||
|
||
std::cout << "Результат умножения: ";
|
||
printArray(result, resultSize);
|
||
|
||
// Освобождаем память
|
||
delete[] A;
|
||
delete[] B;
|
||
delete[] result;
|
||
|
||
return 0;
|
||
}
|
||
|
||
```
|
||
## Задание 6
|
||
Написать программу для нахождения частного и остатка от деления двух
|
||
чисел методом половинного деления
|
||
```cpp
|
||
#include <iostream>
|
||
|
||
// Функция для нахождения частного и остатка от деления
|
||
void divide(int dividend, int divisor, int "ient, int &remainder) {
|
||
quotient = 0;
|
||
remainder = dividend;
|
||
|
||
int currentDivisor = divisor;
|
||
int currentQuotient = 1;
|
||
|
||
while (remainder >= divisor) {
|
||
currentDivisor = divisor;
|
||
currentQuotient = 1;
|
||
|
||
while (remainder >= currentDivisor + currentDivisor) {
|
||
currentDivisor += currentDivisor;
|
||
currentQuotient += currentQuotient;
|
||
}
|
||
|
||
remainder -= currentDivisor;
|
||
quotient += currentQuotient;
|
||
}
|
||
}
|
||
|
||
int main() {
|
||
int dividend, divisor;
|
||
|
||
std::cout << "Введите делимое: ";
|
||
std::cin >> dividend;
|
||
std::cout << "Введите делитель: ";
|
||
std::cin >> divisor;
|
||
|
||
if (divisor == 0) {
|
||
std::cout << "Ошибка: деление на ноль!" << std::endl;
|
||
return 1;
|
||
}
|
||
|
||
int quotient, remainder;
|
||
divide(dividend, divisor, quotient, remainder);
|
||
|
||
std::cout << "Частное: " << quotient << std::endl;
|
||
std::cout << "Остаток: " << remainder << std::endl;
|
||
|
||
return 0;
|
||
}
|
||
|
||
```
|