从for循环中查找最大值

时间：2017-05-02 14:00:19

标签： java for-loop

我创建的代码在查找回文数字时为我提供了数千个解决方案。任务是找到尽可能多的数字：

 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循环创建的最高值？

6 个答案:

答案 0 :(得分：1)

保存您的产品以供日后比较。 如果你发现一个palindrom与最后一个最高的palindrom相比较。如果它高于保存的值，则将新值存储为最后一个最高的palindrom。同时存储相应的i和j值。 在循环结束时，只打印最后一个最高的palindrom及其i和j值。

答案 1 :(得分：1)

这是我的两分钱。

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

不要使用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()大约快七倍。

如果b已a已被选中，请勿尝试将a与b匹配

这个代码段看起来不错，但它不是：

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

检查所有组合需要两倍的时间，因为如果对a检查b，则不必检查b a。以下代码段解决了这个问题：

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 }。

答案 2 :(得分：0)

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

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

您将获得的第一个回文数将是最大的回文数。

您将以降序排列结果。

答案 3 :(得分：0)

更新代码，以获得您现在只需打印最大的PALINDROME号码的要求

您将产品作为回文数字，因此请创建数组列表并将结果推送到其中

 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));

    }

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

答案 4 :(得分：0)

此代码将解决您的问题。

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，然后每当你找到一个回文，检查它是否大于最大值，如果是，则设置max = product。
所以，最后得到最大回文数。

注意：观察break声明。我使用它是因为无论何时你找到最大回文，那么具有相同第一个数字的其他回文将小于这个回文。所以你可以直接转到下一个第一个数字。

答案 5 :(得分：-1)

代码中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);
相关问题
最新问题