Java 我怎样才能把这个问题写得少一点？

我的问题是，我怎样才能用更少的行来编写这个程序

问题是：

编写一个函数，给定一个由N个整数组成的数组，该函数返回最大值 两个数字相加等于和的数字之和。如果没有 两个数字的和相等，函数应返回-1

def solution(A):
    list1=[]
    list2=[]
    l=[]
    b=[]
    r=[]

    for i in range(0,len(A)):
        for j in range(0,len(A)):
            if A[i]!=A[j]:
                list1.append([A[i],A[j]])
            
    for i in range(0,len(list1)):
        list2.append([])
        for j in list1[i]:
            num1=j%10
            num2=j//10
            sum1=num1+num2
            list2[i].append(sum1)

    for i in range(0,len(list2)):
        if list2[i][0]==list2[i][1]:
            l.append(i)
       
    for i in l:
        k=list1[i][0]+list1[i][1]
        r.append(k)
    
    if r:
        return max(r)
    else:
        return -1

k=[51,71,17,42]
print(solution(k))

测试用例：

51,71,17,42 returnNum=93。51和42（5+1=64+2=6，51+42=93）17和71的和相等，但数字是88

42,33,60 returnNum=102加起来等于6，但60+42=102

51,32,43无一等于和，因此返回-1

这是一次网上求职面试，而且是有时间安排的，尽管我没有在规定的时间内完成，但我知道我能够写出来，并且有了这个想法。我坚持了下来，并且非常自豪我能够编写代码而不用在网上查找答案。但我觉得这是一个尴尬和可怕的代码，即使它工作

import java.util.stream.*；
导入java.util.array；
公共班机{
公共静态int解决方案（int[]A）{
int mainArr[]=A，sumArr[]，sumArrTwo[]；
int maxNum[]=新的int[mainArr.length]；
int number=0，digitSum=0，digitSumTwo=0，count=0，sumIndex=0；
int-solNum=0，k=0；
如果（主阵列长度>1）{
对于（int i=0；i 0）{
sumArr[sumIndex]=编号%10；
数量=数量/=10；
++sumIndex；
}
digitSum=IntStream.of（sumArr.sum（）；
//将计数重新初始化为零
计数=0；
sum指数=0；
//开始
对于（int j=0；j

我们采用每个元素的数字和，就像你已经做的那样
我们创建一个和的映射，并将其各自的元素存储在一个大小为
3
的数组中
我们选择大小为
3
，以便于容纳导致相同和的新数字，并对数组元素进行排序。这样，我们将始终有两个最大的数字在图中的索引
1
和索引
2
处给出相同的和
为了获得最大和，我们在映射中保持两个最高的数字，导致相同的和，并在最后迭代并返回最大和时保持最大值

片段：

import java.util.*;
class Solution {
    public static void main(String[] args) {
        int[][] tests = {
            {51,71,17,42},
            {42,33,60},
            {51,32,43},
            {101,20,40}
        };

        for(int[] test : tests){
            System.out.println(Arrays.toString(test) + " => " + solve(test));   
        }
    }

    private static int solve(int[] arr){
        Map<Integer,int[]> map = new HashMap<>();
        int max_sum = -1;
        for(int i=0;i<arr.length;++i){
            int temp = arr[i]; 
            int sum = 0;
            while(temp > 0){
                sum += (temp % 10);
                temp /= 10;
            }
            if(!map.containsKey(sum)){
                map.put(sum,new int[3]);
                map.get(sum)[2] = arr[i];
            }else{
                int[] nums = map.get(sum);
                nums[0] = arr[i];
                Arrays.sort(nums);
                max_sum = Math.max(max_sum,Integer.sum(map.get(sum)[1],map.get(sum)[2]));
            }
        }

        return max_sum;
    }
}

import java.util.*；
类解决方案{
公共静态void main（字符串[]args）{
int[][]测试={
{51,71,17,42},
{42,33,60},
{51,32,43},
{101,20,40}
};
for（int[]测试：测试）{
System.out.println（Arrays.toString（test）+“=>”+solve（test））；
}
}
私有静态int-solve（int[]arr）{
Map Map=newhashmap（）；
int max_sum=-1；
对于（int i=0；i


时间复杂度是
O（n）
其中
n
是数组大小，空间复杂度是
O（n）

注意：如果是负数，可以在任何地方取绝对值

首先，你可以去掉check
if（mainArr.length>1）
和else分支。只需返回
Arrays.stream（maxNum.max（）.orElse（-1）

其次，您有2个循环和IntStream来获得数字之和，您可以在一个循环中完成，以您的解决方案为基础（并且为其创建一个方法会更大）：

第三，当j大于主数组长度时，通过中断循环，可以避免对j小于第二次迭代的arr.length的双重检查

第四：为什么您需要maxNum作为数组？您可以去掉数组，而是使用maxValue的单个变量进行操作（顺便说一句，这也有助于减少第一点）

第五：更多的是一个设计缺陷。不是检查输入[j]==数字，而是检查i和j是否相等。目前，121、4、121数组的代码将返回125

第六：代替O（n^2）（粗略地说，不要@me），你可以把它改为O（n）。
可能会有不同的方法，我建议使用一个地图来存储给定数字的关键数字和数组中的最大值数字。结合第四点以最大化您的利益

那么，如果您需要基于所有给定点的完整解决方案：

 public static int solve(int[] arr) {
    int maximumSum = -1;
    Map<Integer, Integer> biggestNumbers = new HashMap<>();
    for (int input : arr) {
        int sumOfDigits = calculateSumOfDigits(input);
        Integer biggestNumber = biggestNumbers.get(sumOfDigits);
        if (biggestNumber == null) {
            biggestNumbers.put(sumOfDigits, input);
        } else {
            int sum = input + biggestNumber;
            if (sum > maximumSum) {
                maximumSum = sum;
            }
            if (input > biggestNumber) {
                biggestNumbers.replace(sumOfDigits, input);
            }
        }
    }
    return maximumSum;
}

private static int calculateSumOfDigits(int input) {
    int sum = 0;
    while (input > 0) {
        sum += input % 10;
        input /= 10;
    }
    return sum;
}

公共静态int-solve（int[]arr）{
int-maximumSum=-1；
Map biggestNumbers=newhashmap（）；
for（整数输入：arr）{
int SUMOFDIGTS=计算数字量（输入）；
整数biggestNumber=biggestNumbers.get（sumOfDigits）；
if（biggestNumber==null）{
最大数字。输入（数字总和，输入）；
}否则{
整数和=输入+最大数字；
如果（总和>最大总和）{
最大总和=总和；
}
如果（输入>最大数字）{
最大数字。替换（数字总和，输入）；
}
}
}
返回最大和；
}
私有静态整数计算数字量（整数输入）{
整数和=0；
while（输入>0）{
总和+=输入%10；
输入/=10；
}
回报金额；
}
行数（90行）可能与您的相同或更差，包括导入和测试。但这是一种不同的方法：

创建一个类来保存一个数字。

让它在构造函数中计算和
使其具有可比性
为每个实例指定一个唯一的id，这样就可以将两个相同的数字放在一组中

浏览数字数组

将每个数字映射到一个新类
使用类的总和作为映射中的键，将类分组到已排序的集合中

浏览地图

放弃少于2个元素的集
使用每个集合中的前两个元素计算一个和
减少到计算值的最大值

我将“计算器”与测试放在同一个类中：

import java.util.Comparator; // used in the sumPair class
import java.util.Arrays;
import java.util.Map;
import java.util.HashMap;
import java.util.Set;
import java.util.TreeSet;
import java.util.stream.Collectors;
import java.util.function.Function;

public class StackOverflowTest {
  public static void main(String[] args) {
    int[] array_Q1 = {51,71,17,42};
    int[] array_Q2 = {42,33,60};
    int[] array_Q3 = {51,32,43};
    int[] array_123 = {57,89,66,94,17,26,82,35};
    int[] array_none = {10,89,66,94,11,13,82,35};
    int[] array_180_dub = {90,89,66,94,90,13,82,35};

    StackOverflowTest test = new StackOverflowTest();

    System.out.println("test.sumPair(array_Q1): " 
                          + test.sumPair(array_Q1));
    System.out.println("test.sumPair(array_Q2): "
                          + test.sumPair(array_Q2));
    System.out.println("test.sumPair(array_Q3): "
                          + test.sumPair(array_Q3));

    System.out.println("test.sumPair(array_123): "
                          + test.sumPair(array_123));
    System.out.println("test.sumPair(array_none): "
                          + test.sumPair(array_none));
    System.out.println("test.sumPair(array_180_dub): "
                          + test.sumPair(array_180_dub));
  }

  public int sumPair(int[] array){
    Map<Integer, Set<SumPoint>> map =
      Arrays.stream(array)
            .mapToObj(e -> new SumPoint(e))
            .collect(Collectors.groupingBy(
                       e -> e.getSum(),
                       HashMap::new,
                       Collectors.mapping(e -> e, // Function.identity(),
                                          Collectors.toCollection(TreeSet::new))));
//    System.out.println(map);  // Just checking

    return map.entrySet().stream()
                  .map(e -> e.getValue())
                  .filter(e -> e.size() > 1)
                  .mapToInt(e -> e.stream()
                                  .limit(2)
                                  .mapToInt(s -> s.getNumber())
                                  .sum())
                  .max()
                  .orElse(-1);
  }
}

import java.util.Comparator；//u
class SumPoint implements Comparable<SumPoint>{
  static int idSequence;
  int id;
  int sum;
  int number;

  SumPoint(int number) {
    this.number = number;
    this.sum = summing(number);
    this.id = idSequence++;
  }

  int summing(int number){ // assuming there are always only 2 digits
    return number%10 + number/10;
  }

  int getSum() {return sum;}
  int getNumber() {return number;}

  public String toString(){
    return sum+"-"+number;
  }

  public int compareTo(SumPoint other) {
    return Comparator.comparing((SumPoint e) -> e.sum)
                     .thenComparing((SumPoint e) -> e.number)
                     .thenComparing((SumPoint e) -> e.id)
                     .reversed() // highest numbers first.
                     .compare(this,other);
  }
}  

def solution(A):
    list1=[]
    list2=[]
    l=[]
    b=[]
    r=[]

    for i in range(0,len(A)):
        for j in range(0,len(A)):
            if A[i]!=A[j]:
                list1.append([A[i],A[j]])
            
    for i in range(0,len(list1)):
        list2.append([])
        for j in list1[i]:
            num1=j%10
            num2=j//10
            sum1=num1+num2
            list2[i].append(sum1)

    for i in range(0,len(list2)):
        if list2[i][0]==list2[i][1]:
            l.append(i)
       
    for i in l:
        k=list1[i][0]+list1[i][1]
        r.append(k)
    
    if r:
        return max(r)
    else:
        return -1

k=[51,71,17,42]
print(solution(k))