一共298行
2025-11-10 17:52:57
发布于：浙江
1阅读
0回复
0点赞
//超长A+B问题。
//注意，Dev-C++编译时应该不加入命令。
//要是加了-std=c++11就会报错。
//Dev-C++外的其他编辑器能不用最好不用。
//比如别用一中的在线编辑。
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <memory>
#include <stdexcept>
#include <type_traits>
#include <utility>
#include <tuple>
#include <array>
#include <deque>
#include <list>
#include <forward_list>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <stack>
#include <queue>
#include <iterator>
#include <numeric>
#include <limits>
#include <cmath>
#include <cctype>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <climits>
#include <cwchar>
#include <cwctype>
#include <exception>
#include <locale>
#include <codecvt>
#include <fstream>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <istream>
#include <ostream>
#include <sstream>
#include <streambuf>
#include <complex>
#include <valarray>
#include <bitset>
#include <regex>
#include <random>
#include <chrono>
#include <initializer_list>
#include <system_error>
#include <future>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <atomic>
#include <cfenv>
#include <cinttypes>
#include <cstdint>
#include <cuchar>
#include <new>
#include <typeinfo>
#include <ratio>
#include <scoped_allocator>
#include <ciso646>
#include <clocale>
#include <cstdarg>
#include <cstdbool>
#include <cstddef>
#include <csetjmp>
#include <csignal>
#include <cfloat>
#include <cerrno>
namespace UltraLongAdditionImplementation {
namespace Detail {
namespace InputValidation {
class InputProcessor {
public:
static bool isIntegerString(const std::string& s) {
if (s.empty()) return false;
size_t start = 0;
if (s[0] == '-') {
if (s.length() == 1) return false;
start = 1;
}
for (size_t i = start; i < s.length(); ++i) {
if (!isdigit(static_cast<unsigned char>(s[i]))) {
return false;
}
}
return true;
}
static bool isPositiveInteger(const std::string& s) {
return !s.empty() && s[0] != '-' && isIntegerString(s);
}
};
}
namespace MathOperations {
class HighPrecisionCalculator {
private:
static std::string addUnsignedStrings(const std::string& num1, const std::string& num2) {
std::string result;
int carry = 0;
int i = num1.length() - 1;
int j = num2.length() - 1;
while (i >= 0 || j >= 0 || carry > 0) {
int digit1 = (i >= 0) ? (num1[i--] - '0') : 0;
int digit2 = (j >= 0) ? (num2[j--] - '0') : 0;
int sum = digit1 + digit2 + carry;
carry = sum / 10;
result.push_back(static_cast<char>(sum % 10 + '0'));
}
std::reverse(result.begin(), result.end());
return result;
}
static std::string subtractUnsignedStrings(const std::string& larger, const std::string& smaller) {
std::string result;
int borrow = 0;
int i = larger.length() - 1;
int j = smaller.length() - 1;
while (i >= 0) {
int digit1 = larger[i--] - '0';
int digit2 = (j >= 0) ? (smaller[j--] - '0') : 0;
digit1 -= borrow;
borrow = 0;
if (digit1 < digit2) {
digit1 += 10;
borrow = 1;
}
result.push_back(static_cast<char>(digit1 - digit2 + '0'));
}
std::reverse(result.begin(), result.end());
size_t nonZeroPos = result.find_first_not_of('0');
if (nonZeroPos == std::string::npos) {
return "0";
}
return result.substr(nonZeroPos);
}
static int compareAbsoluteValues(const std::string& num1, const std::string& num2) {
if (num1.length() != num2.length()) {
return num1.length() > num2.length() ? 1 : -1;
}
for (size_t i = 0; i < num1.length(); ++i) {
if (num1[i] != num2[i]) {
return num1[i] > num2[i] ? 1 : -1;
}
}
return 0;
}
public:
static std::string add(const std::string& num1, const std::string& num2) {
bool isNum1Negative = !num1.empty() && num1[0] == '-';
bool isNum2Negative = !num2.empty() && num2[0] == '-';
std::string abs1 = isNum1Negative ? num1.substr(1) : num1;
std::string abs2 = isNum2Negative ? num2.substr(1) : num2;
abs1.erase(0, abs1.find_first_not_of('0'));
abs2.erase(0, abs2.find_first_not_of('0'));
if (abs1.empty()) abs1 = "0";
if (abs2.empty()) abs2 = "0";
if (isNum1Negative == isNum2Negative) {
std::string result = addUnsignedStrings(abs1, abs2);
if (isNum1Negative && result != "0") {
return "-" + result;
}
return result;
} else {
int comparison = compareAbsoluteValues(abs1, abs2);
if (comparison == 0) {
return "0";
}
if (comparison > 0) {
std::string result = subtractUnsignedStrings(abs1, abs2);
return isNum1Negative ? "-" + result : result;
} else {
std::string result = subtractUnsignedStrings(abs2, abs1);
return isNum2Negative ? "-" + result : result;
}
}
}
};
class SimpleAdder {
public:
static int add(int a, int b) {
return a + b;
}
};
}
namespace OutputGeneration {
class ResultPresenter {
public:
static void present(int result) {
std::cout << result;
}
static void present(const std::string& result) {
std::cout << result;
}
};
}
}
class AdvancedArithmeticEngine {
public:
AdvancedArithmeticEngine() {
initializeComponents();
}
void executeCalculation() {
acquireInputData();
performComputation();
displayFinalResult();
}
private:
void initializeComponents() {
highPrecisionCalculator_ = std::make_unique<Detail::MathOperations::HighPrecisionCalculator>();
simpleAdder_ = std::make_unique<Detail::MathOperations::SimpleAdder>();
resultPresenter_ = std::make_unique<Detail::OutputGeneration::ResultPresenter>();
}
void acquireInputData() {
std::string inputBuffer;
while (true) {
std::cin >> inputBuffer;
if (!Detail::InputValidation::InputProcessor::isIntegerString(inputBuffer)) {
continue;
}
try {
if (inputBuffer.size() <= 9) {
operandAInt_ = std::stoi(inputBuffer);
useExtendedPrecision_ = false;
} else {
throw std::out_of_range("数值过大");
}
break;
} catch (...) {
operandAStr_ = inputBuffer;
useExtendedPrecision_ = true;
break;
}
}
while (true) {
std::cin >> inputBuffer;
if (!Detail::InputValidation::InputProcessor::isIntegerString(inputBuffer)) {
continue;
}
try {
if (!useExtendedPrecision_ && inputBuffer.size() <= 9) {
operandBInt_ = std::stoi(inputBuffer);
} else {
throw std::out_of_range("需要高精度");
}
break;
} catch (...) {
operandBStr_ = inputBuffer;
useExtendedPrecision_ = true;
break;
}
}
}
void performComputation() {
if (useExtendedPrecision_) {
if (operandAStr_.empty()) {
operandAStr_ = std::to_string(operandAInt_);
}
if (operandBStr_.empty()) {
operandBStr_ = std::to_string(operandBInt_);
}
highPrecisionResult_ = highPrecisionCalculator_->add(operandAStr_, operandBStr_);
} else {
simpleResult_ = simpleAdder_->add(operandAInt_, operandBInt_);
}
}
void displayFinalResult() {
if (useExtendedPrecision_) {
resultPresenter_->present(highPrecisionResult_);
} else {
resultPresenter_->present(simpleResult_);
}
}
int operandAInt_ = 0;
int operandBInt_ = 0;
int simpleResult_ = 0;
std::string operandAStr_;
std::string operandBStr_;
std::string highPrecisionResult_;
bool useExtendedPrecision_ = false;
std::unique_ptr<Detail::MathOperations::HighPrecisionCalculator> highPrecisionCalculator_;
std::unique_ptr<Detail::MathOperations::SimpleAdder> simpleAdder_;
std::unique_ptr<Detail::OutputGeneration::ResultPresenter> resultPresenter_;
};
}
int main() {
UltraLongAdditionImplementation::AdvancedArithmeticEngine computationEngine;
computationEngine.executeCalculation();
#define $r$e$t$u$r$n$0$ return 0;
$r$e$t$u$r$n$0$
}
这里空空如也
有帮助，赞一个