我有一个很简单的想法。首先将两个整数“n1”和“n2”转换为c字符串“s1”和“s2”。如果s1[0]='-'（n1为负）更改为's1[1]=0'，否则（n1>0）更改为's1[0]=9'。类似于c字符串“s2”。最后比较哪个和较大：n1+stoi（s2）或n2+stoi（s1）以确定要选择的集合。
需要特别注意的是，对于大于0的整数，从数字“999…”开始，为了考虑这种情况，我们使用for循环来更改不等于“9”的第一个数字。如果所有数字都是'9'，我们对整数不做任何处理。

# include <iostream>

# include <fstream>

# include <cstring>

int main()
{
    int n1, n2, a, b;
    char s1[32], s2[32];
    while (1)
     {
       std::cout << "\n input n1 & n2 = ";
       std::cin >> n1 >> n2;
       itoa(n1, s1, 10);
       itoa(n2, s2, 10);
       if (s1[0] == '-') s1[1] = '0';
      else for (int i=0; i<strlen(s1); i++) {
              if (s1[i] = '9') continue;
              else {s1[i] = '9'; break;}
       if (s2[0] == '-') s2[1] = '0';
      else for (int i=0; i<strlen(s2); i++) {
              if (s2[i] = '9') continue;
              else {s2[i] = '9'; break;}
       a = n1 + std::stoi(s2);
       b = n2 + std::stoi(s1);
       if (a > b) std::cout << "two integers: " << n1 << ", " << s2 <<std::endl;
       else  std::cout << "two integers: " << s1 << ", " << n2 <<std::endl;
     }
   return 0;
}

一些测试集：

$ ./a.exe

 input n1 & n2 = 12 78
 two integers: 92, 78

 input n1 & n2 = -45 90
 two integers: -05, 90

 input n1 & n2 = -34 -78
 two integers: -34, -08

 input n1 & n2 = 23 9999
 two integers: 93, 9999

下面是一个简单的javascript递归（很容易翻译成java或c++）。这个想法是为每个数字选择最好的加法或减法（对于负数）。复杂度是o（log10n），其中n是较大的数。

function improve(n){
  if (n > -10 && n < 10)
    return n < 0 ? -n : 9 - n;

  return Math.max(
    10 * improve(~~(n / 10)),
    n < 10 ? -(n % 10) : 9 - (n % 10)
  );
}

function f(a, b){
  return a + b + Math.max(improve(a), improve(b));
}

var abs = [
  [1, 90],
  [23, 45],
  [-94, 5]
];

for (let [a, b] of abs){
  console.log(a, b);
  console.log(f(a, b));
  console.log('');
}

当数字是个位数或相同的数字时，解决办法很简单，就是用一个数字代替第一个数字 9 .
当它们不同时，您必须将第一个或第二个数字改为 9 如下图所示：

public class Main {
    public static void main(String[] args) {
        // Tests
        System.out.println(getSum(90, 1));
        System.out.println(getSum(1, 90));
        System.out.println(getSum(8, 80));
        System.out.println(getSum(80, 8));
        System.out.println(getSum(45, 23));
        System.out.println(getSum(23, 45));
        System.out.println(getSum(45, 45));
        System.out.println(getSum(4, 4));
        System.out.println(getSum(9, 9));
        System.out.println(getSum(0, 0));
    }

    static int getSum(int a, int b) {
        int result = 0;
        String strA = String.valueOf(a);
        String strB = String.valueOf(b);
        if (a >= b) {
            if (strA.length() == 1) {
                result = 9 + a;
            } else {
                if (strA.length() > strB.length()) {
                    result = getResult(a, b);
                } else {
                    result = getResult(b, a);
                }
            }
        } else {
            if (strB.length() == 1) {
                result = 9 + b;
            } else {
                if (strB.length() > strA.length()) {
                    result = getResult(b, a);
                } else {
                    result = getResult(a, b);
                }
            }
        }
        return result;
    }

    static int getResult(int a, int b) {
        String strA = String.valueOf(a);
        int firstDigA = Character.getNumericValue(strA.charAt(0));
        return Integer.parseInt(firstDigA == 9 ? "99" + strA.substring(2) : "9" + strA.substring(1)) + b;
    }
}

输出：

100
100
98
98
138
138
140
13
18
9

为了让你更容易理解逻辑，我在下面写了一个函数的扩展形式， getSum :

static int getSum(int a, int b) {
    int result = 0;
    String strA = String.valueOf(a);
    String strB = String.valueOf(b);
    if (a >= b) {
        if (strA.length() == 1) {
            result = 9 + a;
        } else {
            if (strA.length() > strB.length()) {
                int firstDigA = Character.getNumericValue(strA.charAt(0));
                result = Integer.parseInt(firstDigA == 9 ? "99" + strA.substring(2) : "9" + strA.substring(1)) + b;
            } else {
                int firstDigB = Character.getNumericValue(strB.charAt(0));
                result = Integer.parseInt(firstDigB == 9 ? "99" + strB.substring(2) : "9" + strB.substring(1)) + a;
            }
        }
    } else {
        if (strB.length() == 1) {
            result = 9 + b;
        } else {
            if (strB.length() > strA.length()) {
                int firstDigB = Character.getNumericValue(strB.charAt(0));
                result = Integer.parseInt(firstDigB == 9 ? "99" + strB.substring(2) : "9" + strB.substring(1)) + a;
            } else {
                int firstDigA = Character.getNumericValue(strA.charAt(0));
                result = Integer.parseInt(firstDigA == 9 ? "99" + strA.substring(2) : "9" + strA.substring(1)) + b;
            }
        }
    }
    return result;
}

用这个

if(a>b || a==b){
   a=10*((a/10)+1)
   return a;
}
else{
b=10*((b/10)+1)
return b;
}

假设第一个数字有d1位，第二个数字有d2位，为了简单起见，我们进一步假设

d1 >= d2

和

k = d1 - d2

所以，k>=0。如果较大数字的前k个数字是可修改的（可修改的：如果数字是正数，但数字不是9，或者数字是负数），则按前面所述，以最佳方式修改该数字。
否则，在随后的数字中，检查是否有任何数字是可修改的，如果是，请计算对两个数字所做更改之间的差异，并选择更改较大的数字。
当第一次修改完成后，工作应该停止。