Question

假设我有一个包含5个字符串的数组，与该数组相关的是3个整数数组，大小相同。 e.g.`

String a[] = new String[5]
int x[] = new int[5]
int y[] = new int[5]

int z[] = new int[5]

因此a [0]，x [0]，y [0]，z [0]都与同一事物有关。我想找出x []中哪个索引保持最高数字。如果不止一个具有相同的最高数量，那么哪个具有最高数量y []并且如果存在多个具有相同最高数量的那个具有最高数量z []（可以安全地假设没有在z []

中具有相同的最大值

我试图尽我所能解释..

如果得到它只检查前两个条件

，这是最好的

for(int i=0;i<a.length;i++)
{

if(x[i]>=maximum){
if(x[i]==maximum)
{
    if(y[i]>=maximum)
    {
        maximum=x[i];
        winner=a[i];
        maximum=y[i];
    }
}
else
{
    maximum=x[i];
    winner=teams[i];
    maximum=y[i];
    }
}

所以这是我的新代码

static int compareValues(){
for (int i=0; i<a.length; i++){
        int max =0;
        int diff = x[i] - x[max];
        if (diff == 0){
            diff = y[i] - y[max];   
        }
        if (diff == 0){
            diff = z[i] - z[max];
        }
        if (diff > 0){
         max = i    
        }
}
return max;

}

Answer 1

如果String[n]与每个n的int[n]相关，那么您应该正确地构建它们，使它们Comparable并对它们进行排序。

class Thing implements Comparable<Thing> {

    final String a;
    final int x;
    final int y;
    final int z;

    public Thing(String a, int x, int y, int z) {
        this.a = a;
        this.x = x;
        this.y = y;
        this.z = z;

    }

    @Override
    public int compareTo(Thing o) {
        int diff = o.x - x;
        if (diff == 0) {
            diff = o.y - y;
        }
        if (diff == 0) {
            diff = o.z - z;
        }
        return diff;
    }

    @Override
    public String toString() {
        return "{" + a + "," + x + "," + y + "," + z + "}";
    }
}

public static int max(Thing[] things) {
    // NB - This should really call compareTo.
    int max = 0;
    for (int i = 1; i < things.length; i++) {
        int diff = things[i].x - things[max].x;
        if (diff == 0) {
            diff = things[i].y - things[max].y;
        }
        if (diff == 0) {
            diff = things[i].z - things[max].z;
        }
        if (diff > 0) {
            // Higher
            max = i;
        }
    }
    return max;
}

public void test() {
    Thing[] things = new Thing[6];
    things[0] = new Thing("Hello", 1, 2, 3);
    things[1] = new Thing("There", 1, 2, 4);
    things[2] = new Thing("Everyone", 0, 2, 3);
    things[3] = new Thing("How", 9, 0, 3);
    things[4] = new Thing("Are", 8, 9, 3);
    things[5] = new Thing("You", 7, 2, 3);
    System.out.println("Before: " + Arrays.toString(things));
    System.out.println("Max: " + things[max(things)]);
    Arrays.sort(things);
    System.out.println("Sorted: " + Arrays.toString(things));
}

Answer 2

此解决方案可能更容易理解：

static String compareValues() {
    // find the maximum in x
    int xMax = Integer.MIN_VALUE;
    for (int i = 0; i < 5; i++) {
        if (x[i] > xMax) {
            xMax = x[i];
        }
    }

    // find the maximum in y, but limited to the positions where x is maximal according to the calculation above
    int yMax = Integer.MIN_VALUE;
    for (int i = 0; i < 5; i++) {
        if (x[i] == xMax && y[i] > yMax) {
            yMax = y[i];
        }
    }

    // find the maximum in z, but limited to the positions where y is maximal according to the calculation above
    int zMax = Integer.MIN_VALUE;
    int iMax = 0;
    for (int i = 0; i < 5; i++) {
        if (y[i] == yMax && z[i] > zMax) {
            zMax = z[i];
            iMax = i; // record the maximum position
        }
    }

    return a[iMax];
}

我没有测试代码，但我认为它应该可行。

试图围绕3个嵌套的if语句

2 个答案: