从 for 循环中找到最大值

Question

我创建的代码在寻找回文数时为我提供了数以千计的解决方案。任务是找到可能的最大数字：

 public static void main(String[] args) {
        long product;
        outer: for (int i = 999; i >= 100; i--) {
            for (int j = 999; j >= 100; j--) {
                product = j * i;
                if (reverse(product)) {
                    System.out.printf("%d * %d = %d%n", i, j, product);
                    continue;
                }
            }
        }
    }
    private static final boolean reverse(long value) {
        String str = String.valueOf(value);
        return str.equals(new StringBuilder(str).reverse().toString());
    }}

我怎样才能使代码只显示 for 循环创建的最大值？

Answer 1

保存您的产品以供以后比较。 如果你找到一个回文，将它与最后一个最高的回文进行比较。如果它高于保存的值，则将新值存储为最后最高的回文。也存储相应的 i 和 j 值。 在循环结束时只打印最后一个最高的回文及其 i 和 j 值。

Answer 2

这是我的两分钱。

虽然其他答案包含实际解决问题的有效代码，但它们会严重影响性能。

不要使用StringBuilder.reverse()

为了检查一个字符串是否是回文，经常使用StringBuilder 的反向方法。它创建一个新的StringBuilder 对象，复制字符串的字符并将它们以相反的顺序排列。然后检索 String 实例并与原始字符串进行比较。
这种方法有两个含义：

• 为每个回文检查创建一个 StringBuilder 对象。
• 两个字符串的每个字符都相互检查。

最好将第一个字符与最后一个字符进行比较，将第二个字符与倒数第二个字符进行比较，等等。您只需要检查前半部分，后半部分已经与字符串的前半部分匹配。

所以回文检查器函数如下：

private static boolean isPalindrome(String str) {
    for (int i = 0; i < str.length() / 2; i++) {
        if (str.charAt(i) != str.charAt(str.length() - 1 - i)) {
            return false;
        }
    }
    return true;
}

它比使用reverse() 快大约七倍。

如果 a 与 b 已被选中，则不要尝试将 b 与 a 匹配

这个 sn-p 看起来不错，但不是：

for (int i = 999; i >= 100; i--) {
    for (int j = 999; j >= 100; j--) {
        ...
    }
}

检查所有组合需要两倍的时间，因为如果检查 a 和 b，您就不必检查 b 和 a。以下 sn-p 解决了这个问题：

for (int i = 999; i > 100; i--) {
    for (int j = i; j > 100; j--) {
        ...
    }
}

它只是将i 存储到j 中，所以j 以i 的值开头。

代码

所以你最好使用这个代码：

private static void checkNumbers() {

    long max = 0;
    long a = 0;
    long b = 0;
    int lowerBounds = 0;

    for (int i = 999; i > lowerBounds; i--) {
        for (int j = i; j > lowerBounds ; j--) {
            long product = i * j;

            // Check if the product is already smaller than our found
            // maximum. If that's the case, than any value of j lower
            // than the current value of j will always be smaller than
            // the currently found value.
            if (product <= max) {
                break;
            }
            else if (isPalindrome(String.valueOf(product))) {
                max = product;
                a = i;
                b = j;
                // If we found a match, then this is the least of the two
                // products of our result. We don't have to go any lower
                // than j.
                lowerBounds = j;
            }
        }
    }

    System.out.println(max);
    System.out.println(a + " * " + b);
}

private static boolean isPalindrome(String str) {
    for (int i = 0; i < str.length() / 2; i++) {
        if (str.charAt(i) != str.charAt(str.length() - 1 - i)) {
            return false;
        }
    }
    return true;
}

它至少比接受的答案快 15 倍。

请注意，还有更多方法可以提高性能。例如，您可以存储找到的两个因子中的最小值，然后 i 和 j 都不必再降低了。例如：如果我们找到i 的值995 和j 的值583，我们不必低于583。

Answer 3

当您开始从最大数字到最小数字的迭代时

for (int j = 999; j >= 100; j--)

你将得到的第一个回文数将是最大的回文数。

你会得到降序的结果。

Answer 4

此代码将解决您的问题。

public static void main(String[] args) {
        long product;
        long max=0;
        outer: for (int i = 999; i >= 100; i--) {
            for (int j = 999; j >= 100; j--) {
                product = j * i;
                if (reverse(product)) {
                    if(product>max)
                     {  max=product;
                        break;
                     }
                    continue;
                }
            }
        }
       System.out.printf("%d",max);
    }
    private static final boolean reverse(long value) {
        String str = String.valueOf(value);
        return str.equals(new StringBuilder(str).reverse().toString());
    }}

我所做的是，只保留一个变量最大值，然后每当你找到一个回文，检查它是否大于最大值，如果是则设置 max=product.
所以，最后你得到了最大回文数。

注意：注意break 语句。我使用它是因为每当你找到一个最大回文数时，其他具有相同第一个数字的回文数将小于这个回文数。所以你可以直接移动到下一个第一个数字。

Answer 5

更新代码以获取您的要求，现在它将只打印最大的回文数

您将 product 作为回文数，因此创建一个 array-list 并将结果推送到其中

 public static void main(String[] args) {
        long product;
       ArrayList al=new ArrayList();
        outer: for (int i = 999; i >= 100; i--) {
            for (int j = 999; j >= 100; j--) {
                product = j * i;
                if (reverse(product)) {
                    System.out.printf("%d * %d = %d%n", i, j, product);
                    al.add(product);
                    continue;
                }
            }
        }
   Collections.sort(al, Collections.reverseOrder());
// System.out.println("ArrayList in descending order:");
      System.out.println("The Greatest number is "+al.get(0));

    }

在这里您将按降序获取所有值，因此第一个元素将是最大的回文数

Answer 6

代码中this answer描述的解决方案：

long highest_palindrome = 0L;
int storeI = 0;
int storeJ = 0;
long product;
outer: for (int i = 999; i >= 100; i--) {
    for (int j = 999; j >= 100; j--) {
        product = j * i;
        if (product < highest_palindrome) break;
        if (reverse(product)) {
            if (product > highest_palindrome) {
                highest_palindrome = product;
                storeI = i;
                storeJ = j;
            }
            continue;
        }
    }
}

System.out.printf("%d * %d = %d%n", storeI, storeJ, highest_palindrome);