To solve this problem, we need to handle the addition of very large numbers (up to 1000 digits) that cannot be stored in standard integer types. The solution involves using string manipulation to perform the addition manually, similar to how we add numbers by hand.
Approach
- Reverse the Input Strings: This allows us to start adding from the least significant digit (rightmost in the original string, leftmost in the reversed string).
- Add Digits with Carry: Iterate over each position, add the corresponding digits from both numbers (using 0 if one number is shorter) plus any carry from the previous position.
- Handle Remaining Carry: After processing all digits, if there is any remaining carry, add it to the result.
- Remove Leading Zeros: Ensure the result does not have leading zeros (except for the case where the result is zero itself).
- Format Output: Print the result in the required format, including case numbers and a blank line between cases (except after the last case).
Solution Code
def add_big(a, b):
a_rev = a[::-1]
b_rev = b[::-1]
max_len = max(len(a_rev), len(b_rev))
carry = 0
res = []
for i in range(max_len):
da = int(a_rev[i]) if i < len(a_rev) else 0
db = int(b_rev[i]) if i < len(b_rev) else 0
total = da + db + carry
res.append(str(total % 10))
carry = total // 10
if carry != 0:
res.append(str(carry))
# Process result to remove leading zeros
result = ''.join(reversed(res))
result = result.lstrip('0')
return result if result else '0'
T = int(input())
for case in range(1, T + 1):
a, b = input().split()
sum_ab = add_big(a, b)
print(f"Case {case}:")
print(f"{a} + {b} = {sum_ab}")
if case != T:
print()
Explanation
- Reversing Strings: Reversing the input strings makes it easier to add digits from the least significant to the most significant.
- Adding Digits: For each position, we calculate the sum of the digits from both numbers plus the carry. The current digit of the result is the remainder of the sum divided by 10, and the carry is the quotient.
- Handling Carry: If there is a carry left after processing all digits, it is added to the result (e.g., 999 + 1 = 1000).
- Leading Zeros: The result is stripped of leading zeros to ensure correctness (e.g., "00123" + "0456" = "579").
- Output Format: The result is printed in the specified format, with case numbers and a blank line between cases to meet the problem's requirements.
This approach efficiently handles large numbers and ensures correctness for all edge cases. The time complexity is O(n), where n is the length of the longer number, making it suitable for the given constraints.


作者声明:本文包含人工智能生成内容。