Java 在二维数组中添加对角线值

我有以下2d数组

        int [][] array = {{ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9},
                          {10, 11, 12, 13, 14, 15, 16, 17, 18, 19},
                          {20, 21, 22, 23, 24, 25, 26, 27, 28, 29},
                          {30, 31, 32, 33, 34, 35, 36, 37, 38, 39},
                          {40, 41, 42, 43, 44, 45, 46, 47, 48, 49},
                          {50, 51, 52, 53, 54, 55, 56, 57, 58, 59},
                          {60, 61, 62, 63, 64, 65, 66, 67, 68, 69},
                          {70, 71, 72, 73, 74, 75, 76, 77, 78, 79},
                          {80, 81, 82, 83, 84, 85, 86, 87, 88, 89},
                          {90, 91, 92, 93, 94, 95, 96, 97, 98, 99}};

我有这段代码来查找数组中所有值的总和。如何修改它以仅添加从0开始的对角线值（0+11+22+33等）

公共静态int-arraySum（int[][]数组）
{
int-total=0；
for（int row=0；row

公共静态int-arraySum（int[][]数组）
{
int-total=0；
for（int index=0；index

---

当然，这假设尺寸为m x m。

因为对角线是完全正方形的，所以只需要一个循环就可以添加对角线

---

从orgin添加对角线：

public static int arraySum(int[][] array){
    int total = 0;

    for (int row = 0; row < array.length; row++)
    {

        total += array[row][row];
    }

    return total;
}

公共静态int-arraySum（int[][]数组）{
int-total=0；
for（int row=0；row

---

添加两条对角线：

从原点添加对角线：（注意，它将中心添加两次..如果需要，可以减去一）

公共静态int-arraySum（int[][]数组）{
int-total=0；
for（int row=0；row

导入java.util.Scanner；
公共类解决方案{
公共静态void main（字符串[]args）{
扫描仪输入=新扫描仪（系统输入）；
int n=in.nextInt（）；
int leftStartDiagnol=0；
int rightStartDiagnol=n；
int leftTotal=0；
int rightotal=0；
int a[][]=新int[n][n]；
for（int a_i=0；a_i

这是我的解决方案-

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    int n = in.nextInt();
    int a[][] = new int[n][n];
    for(int a_i=0; a_i < n; a_i++){
        for(int a_j=0; a_j < n; a_j++){
            a[a_i][a_j] = in.nextInt();
        }
    }
    int l_sum = 0;
    for(int i = 0; i<n ; i++){
        l_sum+=a[i][i];
    }
    int r_sum = 0;
    for(int j = 0; j<n ; j++){
        r_sum+=a[j][n-1-j];
    }

    int sum = l_sum + r_sum;

    System.out.println(sum);
   }
 }

import java.io.*；
导入java.util.*；
导入java.text.*；
导入java.math.*；
导入java.util.regex.*；
公共类解决方案{
公共静态void main（字符串[]args）{
扫描仪输入=新扫描仪（系统输入）；
int n=in.nextInt（）；
int a[][]=新int[n][n]；
for（int a_i=0；a_iimportjava.io.*；
导入java.util.*；
公共级数字图书馆{
公共静态void main（字符串[]args）{
扫描仪s=新的扫描仪（System.in）；
int n=Integer.parseInt（s.nextLine（））；//数组大小
int[][]a=新int[n][n]；//新数组
对于（inti=0；i这是我的解决方案。请查看它

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
public class Solution {
public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    int n = in.nextInt();
    int a[][] = new int[n][n];
    int total1=0;
    int total2=0;

    for(int a_i=0; a_i < n; a_i++){
        for(int a_j=0; a_j < n; a_j++){
            a[a_i][a_j] = in.nextInt();
        }
        total1+= a[a_i][a_i];
        total2+=a[a_i][n-1-a_i];
    }
    System.out.println(Math.abs(total1-total2));
}

import java.io.*；
导入java.util.*；
导入java.text.*；
导入java.math.*；
导入java.util.regex.*；
公共类解决方案{
公共静态void main（字符串[]args）{
扫描仪输入=新扫描仪（系统输入）；
int n=in.nextInt（）；
int a[][]=新int[n][n]；
整数total1=0；
整数2=0；
for（int a_i=0；a_i

}
PHP解决方案。逻辑与此处已发布的完全相同。只有在PHP中不同

<?php

$handle = fopen ("php://stdin", "r");
function diagonalDifference($a) {
    $sumA = [];
    $sumB = [];

    $n = count($a);

    for ($i = 0; $i < $n; $i++) {
        for ($j = 0; $j < $n; $j++) {
            if ($i === $j) {
                $sumA[] = $a[$i][$j];
            }

            if ($i + $j == count($a) -1 ) {
                $sumB[] = $a[$i][$j];
            }
        }
    }

    $sum1 = array_sum($sumA);
    $sum2 = array_sum($sumB);

    return abs($sum1 - $sum2);
}

fscanf($handle, "%i",$n);
$a = array();
for($a_i = 0; $a_i < $n; $a_i++) {
    $a_temp = fgets($handle);
    $a[] = explode(" ",$a_temp);
    $a[$a_i] = array_map('intval', $a[$a_i]);
}
$result = diagonalDifference($a);
echo $result . "\n";
?>


解决方案是：

int total = 0;
for (int row = 0; row < array.length; row++)
{
    total += array[row][row] + array[row][array.length - row - 1];
}

System.out.println("FINAL ANSWER: " + total);

int-total=0；
for（int row=0；row
这是我用来求主对角线数和次对角线数之和的代码

static int diagSum(int[][] arr) {
    int pd=0;
    int sd=0;
    int sum=0; 
    for(int i=0;i<=arr.length-1;i++){
       pd=pd+arr[i][i];
    } 

    for (int k=0,l=arr.length-1; k<arr.length&&l>=0 ; k++,l--) {
        sd=sd+arr[k][l];
    }

    sum=pd+sd;
    return sum;
}

static int diagSum（int[]arr）{
int-pd=0；
int-sd=0；
整数和=0；
对于（int i=0；i如果您想在二维数组中添加两个对角线，那么下面是我的程序

static int diagonalDifference(int[][] arr) {


    int r = arr.length;     
    int sum1 = 0;
    int sum2 = 0;

    int j=0;
    for(int i=0;i<r;i++){
        sum1 = sum1 + arr[i][j];
        j++;
    }
    j--;
    for(int i=0;i<r;i++) {
        sum2 = sum2 + arr[i][j];
        j--;
    }
    int sum=sum1+sum2; 
    return sum;
}

静态int对角线差（int[]arr）{
int r=阵列长度；
int sum1=0；
int-sum2=0；
int j=0；
对于（int i=0；i其对角线之和在kotlin中的差值：

val total = (0 until array.size).sumBy { array[it][it] - array[it][array.size - it - 1] }

如果您想要绝对差异：

return Math.abs(total)

公共类矩阵{
公共静态void main（字符串[]args）{
整数和=0；
int a[][]=新int[][{{2,3,4}，{4,5,6}，{5,5,5}；
对于（int i=0；i如果要在二维数组中添加两个对角线，则有一个解决方案：

    int j = row_col_size-1;
    for (int i = 0; i < intArray.length; i++) {
        sum_left += intArray[i][i];
        sum_right += intArray[i][j];
        j--;
    }

int j=row\u col\u size-1；
for（int i=0；i
虽然这篇文章很老。提供我的解决方案。这可能对某人有用

func diagonalDifference(arr [][]int32) int32 {


return int32(math.Abs(float64(arraySumPrimary(arr)) - float64(arraySumSecondary(arr))) )

}
func arraySumPrimary(arr [][]int32) int32{
    var total int32 =0
    for row :=0; row < len(arr) ; row ++{
        total = total + arr[row][row]
    }
    return total
}

func arraySumSecondary(arr [][]int32) int32{
    var total int32 =0
    x := len(arr)-1 
    y := 0
    for x >=0 && y < len(arr){
        total = total + arr[x][y]
        x--
        y++
    }
    return total
}

func对角线差分（arr[]]int32）int32{
返回int32（math.Abs（float64（arraySumPrimary（arr））-float64（arraySumSecondary（arr）））
}
func数组通用（arr[][]int32）int32{
变量总计int32=0
对于行：=0；行=0&&y
D
static int diagonalDifference(int[][] arr) {


    int r = arr.length;     
    int sum1 = 0;
    int sum2 = 0;

    int j=0;
    for(int i=0;i<r;i++){
        sum1 = sum1 + arr[i][j];
        j++;
    }
    j--;
    for(int i=0;i<r;i++) {
        sum2 = sum2 + arr[i][j];
        j--;
    }
    int sum=sum1+sum2; 
    return sum;
}

val total = (0 until array.size).sumBy { array[it][it] - array[it][array.size - it - 1] }

return Math.abs(total)

public class matrix {

    public static void main(String[] args) {
        int sum=0;
        int a[][]= new int[][]{{2,3,4},{4,5,6},{5,5,5}};

        for(int i=0;i<=2;i++)
        {
            sum=sum+a[i][i];
        }

        System.out.println(sum);
    }

}

    int j = row_col_size-1;
    for (int i = 0; i < intArray.length; i++) {
        sum_left += intArray[i][i];
        sum_right += intArray[i][j];
        j--;
    }

func diagonalDifference(arr [][]int32) int32 {


return int32(math.Abs(float64(arraySumPrimary(arr)) - float64(arraySumSecondary(arr))) )

}
func arraySumPrimary(arr [][]int32) int32{
    var total int32 =0
    for row :=0; row < len(arr) ; row ++{
        total = total + arr[row][row]
    }
    return total
}

func arraySumSecondary(arr [][]int32) int32{
    var total int32 =0
    x := len(arr)-1 
    y := 0
    for x >=0 && y < len(arr){
        total = total + arr[x][y]
        x--
        y++
    }
    return total
}