Java 对角线差

我是编程新手，在编写对角差分代码时，我想到了这种方法

 public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    int n = in.nextInt();
    int j = 0;
    int a[][] = new int[n][n];
    int count1 = 0; int count2 = 0;
    int result = 0;
    for(int a_i=0; a_i < n; a_i++){
        for(int a_j = 0;a_j < n;a_j++){
       
            a[a_i][j] = in.nextInt();
        
    }}
    for(int i = 0;i<n;i++)
    {
        count1+=a[i][j];
        System.out.println(count1);
        j++;
    }
    j = 0;
    for(int i = n-1;i>=0;i--)
    {
        count2+=a[i][j];
        System.out.println(count2);
        j++;
    }
    result = Math.abs(count1 - count2);
    System.out.println(result);
}

publicstaticvoidmain（字符串[]args）{
扫描仪输入=新扫描仪（系统输入）；
int n=in.nextInt（）；
int j=0；
int a[][]=新int[n][n]；
int count1=0；int count2=0；
int结果=0；
for（int a_i=0；a_i

输入
3
11.2.4
4.56
10 8-12
预期产出15

---

我的输出16

为什么要做这么多工作？ 您需要一个非常简单的代码：

for(int i = 0;i<n;i++){
    count1+=a[i][i];
    count2+=a[i][n-1-i];
}

---

for（int i=0；i仅根据Frank的答案进行开发，实际上不需要数组：

for(int i=0; i < n; i++){
  for(int j = 0; j < n; j++){
    int v = in.nextInt();
    count1 += (i == j) ? v : 0;
    count2 += (i + j == n-1) ? v : 0;
  }
}

for（int i=0；i
intk=0；
int l=0；
int m；
int z=阵列长度；
int s=arr.length-1；
对于java中的（inti=0；i），解决方案是

    int result = 0;
    for(int i = 0;i<n;i++){
        l+=a[i][i];
        r+=a[i][n-1-i];
    }
    result = abs(l-r);

这里是Javascript，我使用forEach来提高可读性，在Java中也可以这样做

function diagonalDifference(arr) {
    let length = arr.length-1;
    let leftDiag = 0;
    let rightDiag = 0;


    arr.forEach((item, outerIndex) => {
        item.forEach((innerItem, innerIndex) => {
            if (outerIndex === innerIndex) {
                leftDiag = leftDiag + innerItem;
            }
            if (length - outerIndex === innerIndex) {
                rightDiag = rightDiag + innerItem;
            }
        });
    });

    return Math.abs(leftDiag - rightDiag);

}

公共静态int对角线差（列表arr）{
int leftSum=0，rightSum=0；
int i=-1；
内部列表；
迭代器列表=arr.Iterator（）；
while（list.hasNext（））{
内部=list.next（）；
i++；
leftSum+=内部.get（i）；
rightSum+=inner.get（inner.size（）-1-i）；
}
返回Math.abs（leftSum rightSum）；
}
公共静态整数对角线差（列表arr）{
ListIterator itr=arr.ListIterator（）；
int i=0，k=arr.size（）；
int sumdia1=0，sumdia2=0；
内部列表；
System.out.println（“k:：”+k）；
while（itr.hasNext（））{
内部=itr.next（）；
k--；
sumdia1=sumdia1+inner.get（i）；
sumdia2=sumdia2+inner.get（k）；
i++；
}
我的Java对角差分解决方案

public static int diagonalDifference(List<List<Integer>> arr) {
    int primaryDiagnal = 0;
    int secDiagnal = 0;
    int diff;

    for(int i= 0; i<arr.get(0).size(); i++){
        primaryDiagnal += arr.get(i).get(i);
    }

    int col = arr.get(0).size() - 1;
    for(int i= 0; i<arr.get(0).size(); i++){
        secDiagnal += arr.get(i).get(col);
        col--;
    }

    diff = primaryDiagnal - secDiagnal;
    return Math.abs(diff);
 }

公共静态int对角线差（列表arr）{
int primaryDiagnal=0；
int secdiagnol=0；
int-diff；
对于（inti=0；i你可以选择大小/2的遍历方法。这可能看起来很吓人，但一旦你理解了，你就会爱上它的辉煌

int i=arr.Count/2,j=i,sum=0;
        if(arr.Count%2 != 0){
           i--;
           j++; 
        }else{
            i--;
        }
        for(;i>=0;i--,j++){
        sum += arr[i].ElementAt(i)+arr[j].ElementAt(j)-arr[i].ElementAt(j)-arr[j].ElementAt(i);
        }
        return Math.Abs(sum); 

在您的第一个循环中，您使用的是j而不是a_j。不确定这是否是故意的，但我注意到了这一点。请注意，重用变量（就像您使用
j
）通常是一个坏主意，如下所示。在尽可能小的范围内声明变量；声明变量没有内在成本。您可以声明（和更新）for循环中有多个变量（前提是它们的类型相同），因此第三个循环的
for（int i=0，j=0；i=0；i--，j++）
.摘自@Flaom谢谢你的指点。@AndyTurner我当然会记住这一点。非常感谢！虽然这不是太多的代码，但我发现这难以置信地难以理解，如果它不是一个代码，那么它可能是什么？l代表左，r代表右r+=意味着r=r+。这只是一种创建短代码的方法兄弟。一旦你右a[I][I]这有助于你到达左边的对角线。这里的技巧是[i][n-1-i]，它允许你从另一边到达对角线。我希望现在它更容易理解。如果你需要任何解释，请随时询问：）。请在您的答案中添加解释。您能解释为什么这是问题的解决方案吗？欢迎对此答案进行编辑。
public static int diagonalDifference(List<List<Integer>> arr) {

    int leftSum=0, rightSum=0;
    int i=-1;
    List <Integer> inner;
    Iterator<List<Integer>> list = arr.iterator();
    while (list.hasNext()){
        inner=list.next();
        i++;
        leftSum += inner.get(i);
        rightSum += inner.get(inner.size()-1-i);           
            
    }

    return Math.abs(leftSum-rightSum); 

}

public static int diagonalDifference(List<List<Integer>> arr) {
    
    ListIterator<List<Integer>> itr = arr.listIterator();
    int i = 0,k=arr.size();
    int sumdia1=0 , sumdia2=0;
    List <Integer> inner;
    System.out.println(" k ::: "+k);
    while(itr.hasNext()) {
             inner = itr.next();
             k--;
            sumdia1= sumdia1 + inner.get(i);
            sumdia2= sumdia2+ inner.get(k);
            i++;
        
    }

public static int diagonalDifference(List<List<Integer>> arr) {
    int primaryDiagnal = 0;
    int secDiagnal = 0;
    int diff;

    for(int i= 0; i<arr.get(0).size(); i++){
        primaryDiagnal += arr.get(i).get(i);
    }

    int col = arr.get(0).size() - 1;
    for(int i= 0; i<arr.get(0).size(); i++){
        secDiagnal += arr.get(i).get(col);
        col--;
    }

    diff = primaryDiagnal - secDiagnal;
    return Math.abs(diff);
 }

int i=arr.Count/2,j=i,sum=0;
        if(arr.Count%2 != 0){
           i--;
           j++; 
        }else{
            i--;
        }
        for(;i>=0;i--,j++){
        sum += arr[i].ElementAt(i)+arr[j].ElementAt(j)-arr[i].ElementAt(j)-arr[j].ElementAt(i);
        }
        return Math.Abs(sum);