一些关于java的题 请知情者回答 谢谢

1. 求出任意一个数字二维数组两条对角线上的和。
2. 假设数字A的所有因数之和等于数字B，而B的因数之和也等于A.求出1到1000中满足这种条件的数字对.
3. 有数列1/2、2/3、3/5、5/8、8/13、13/21…..求该数列前10项的和。
4. 判断一个数字是否是回文。(123321)
5. 有A，B，C，D和E共5所学校。在一次检查评比中，已知e肯定不是第二名或第三名，他们相互进行推测，a说，e一定是第一名；b说，我校可能是第二名；c说，a校最差；d说，c不是最好；e说，d是第一名。结果只有第一和第二名的学校猜对了。编写一个程序，求出这5所学校的名次。
这五道题 帮忙回答 题号写清楚 谢谢

第二题毫无意义，因为除了1以外，所有自然数的因数之和一定大于他本身，因为一个数的因数包括1和他本身。所以A的因数之和B一定大于A，而B的因数之和又会大于A，所以这样的数对是不存在的

第五题对“可能”的理解不太确定，而且，也有不止一组解

1.
public class Test {
public static void main(String[] args) {
int[][] matrix = {
{ 1, 2, 3, },
{ 4, 5, 6, },
{ 7, 8, 9, }
};
System.out.println(diagonalSum(matrix));
}

// Asserts that matrix is a square matrix
static int diagonalSum(int[][] matrix) {
int sum = 0;
int size = matrix.length;
for (int i = 0; i < size; ++i) {
sum += matrix[i][i];
sum += matrix[i][size - 1 - i];
}
return sum;
}
}

2.
public class Test {
public static void main(String[] args) {
for (int i = 1, j; i <= 1000; ++i) {
j = sumOfAllFactors(i);
if (i == sumOfAllFactors(j)) {
System.out.printf("%d, %d\n", i, j);
}
}
}

static int sumOfAllFactors(int n) {
int sum = 0;
for (int i = 1; i <= n; ++i) {
if (n % i == 0) {
sum += i;
}
}
return sum;
}
}

3.
public class Test {
public static void main(String[] args) {
int a = 1, b = 2, c;
double sum = 0, current;
for (int i = 0; i < 10; ++i) {
current = ((double) a) / b;
sum += current;
c = b;
b = a + b;
a = c;
}
System.out.println(sum);
}
}

4.
public class Test {
public static void main(String[] args) {
int n = 123321, m = 1234321, a = 123421;
System.out.println(isSymmetric(m));
System.out.println(isSymmetric(n));
System.out.println(isSymmetric(a));
}

static boolean isSymmetric(int n) {
String number = String.valueOf(n);
int length = number.length() - 1;
for (int i = 0; i <= (length >> 1); ++i) {
if (number.charAt(i) != number.charAt(length - i)) {
return false;
}
}
return true;
}
}

5.
import java.util.Arrays;

public class Test {
public static void main(String[] args) {
School a = new School("A"), b = new School("B"), c = new School("C"),
d = new School("D"), e = new School("E");
School[] schools = { a, b, c, d, e, };

a.predictRank(e, 1, true, true);
b.predictRank(b, 2, true, false);
c.predictRank(a, 5, true, true);
d.predictRank(c, 1, false, true);
e.predictRank(d, 1, true, true);

permutate(schools, 0);

}

static boolean check(School[] array) {
return array[0].prediction.isTrue(array) && array[1].prediction.isTrue(array) &&
!array[2].prediction.isTrue(array) && !array[3].prediction.isTrue(array) &&
!array[4].prediction.isTrue(array);
}

static void permutate(School[] array, int depth) {
if (depth == array.length) {
if (check(array)) {
System.out.println(Arrays.toString(array));
}
return;
}

for (int i = depth; i < array.length; ++i) {
swap(array, depth, i);
permutate(array, depth + 1);
swap(array, depth, i);
}
}

static void swap(School[] array, int i, int j) {
School temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}

class School {
String name;
Prediction prediction;

School(String name) {
this.name = name;
}

void predictRank(School school, int rank, boolean isTruth, boolean isSure) {
prediction = new RankPrediction(school, rank-1, isTruth, isSure);
}

public String toString() {
return name;
}
}

interface Prediction {
boolean isTrue(School[] schools);
}

class RankPrediction implements Prediction {
int rank;
School school;
boolean isTruth, isSure;
RankPrediction(School school, int rank, boolean isTruth, boolean isSure) {
this.rank = rank;
this.school = school;
this.isTruth = isTruth;
this.isSure = isSure;
}
public boolean isTrue(School[] schools) {
if (isTruth) {
return schools[rank] == school;
} else {
return schools[rank] != school;
}
}

}

如以上回答内容为低俗、色情、不良、暴力、侵权、涉及违法等信息，可以点下面链接进行举报！

点此我要举报以上问答信息