如何不转十进制直接实现八进制数减法？求基于加法代码改写

Great question! We can adapt your existing octal addition logic to handle subtraction by swapping out carry logic for borrowing—here's a complete implementation that follows your requirements to a T:

Core Logic Breakdown #

• Loop Termination: We keep looping as long as either number has remaining digits, or there's an outstanding borrow to resolve (so the condition is num1 > 0 || num2 > 0 || borrow > 0).
• Borrow Handling: In octal, borrowing 1 from the next higher digit is equivalent to adding 8 to the current digit. If the current digit of num1 can't cover the digit from num2 plus the borrow, we adjust and set the borrow flag for the next iteration.
• Result Construction: Just like your addition code uses digit_rank, we'll use a variable m (starting at 1, multiplying by 10 each loop) to build the result as a decimal-encoded octal number.

Complete Subtraction Function #

static int subtraction(int num1, int num2) {
    // Handle cases where num1 is smaller than num2 (return negative result)
    if (num1 < num2) {
        return -subtraction(num2, num1);
    }

    int result = 0;
    int borrow = 0;
    int m = 1; // Multiplier to position digits correctly (10^0, 10^1, etc.)

    while (num1 > 0 || num2 > 0 || borrow > 0) {
        // Extract current octal digits (last digit of the decimal-encoded input)
        int digit1 = num1 % 10;
        int digit2 = num2 % 10;

        // Calculate current digit difference, accounting for previous borrow
        int digit = digit1 - digit2 - borrow;

        // Resolve negative digit by borrowing from the next higher position
        if (digit < 0) {
            digit += 8; // Borrow 1 = +8 in octal base
            borrow = 1;
        } else {
            borrow = 0;
        }

        // Add the current digit to the result at the correct place
        result += digit * m;
        m *= 10; // Shift to the next digit position for the next iteration

        // Remove the processed digit from both input numbers
        num1 /= 10;
        num2 /= 10;
    }

    return result;
}

Key Details Explained #

1. Smaller Input Handling: The initial if statement handles cases where num1 is smaller than num2 by recursively calling the function with swapped inputs and returning the negative result—this matches standard subtraction behavior.
2. Borrow Logic: When digit comes out negative, we add 8 (since octal is base-8) to make it positive, and set borrow = 1 to alert the next higher digit that it needs to account for the borrowed value.
3. Result Building: The m variable ensures each calculated digit is placed in the correct position (units, tens, hundreds, etc. in the decimal-encoded octal result)—exactly like your addition code's digit_rank.

Example Tests #

Let's verify with octal values:

• subtraction(17, 7) (octal 17 - 7 = 10): Returns 10 (decimal-encoded octal, equal to 8 in decimal)
• subtraction(20, 11) (octal 20 - 11 = 7): Returns 7
• subtraction(7, 17): Returns -10

内容的提问来源于stack exchange，提问作者askomal