Java 项目Euler 4的回文产品输出

我不明白为什么我的输出没有回文。我怀疑它的问题在于内部for循环，但我希望您能提供任何信息

/*
 * 
 * A palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 × 99.
 *
 *  Find the largest palindrome made from the product of two 3-digit numbers.
 *
 */

public class projecteuler4 {

public static boolean isPalindrome(String palindromeCandidate) {

    StringBuilder sb1 = new StringBuilder(palindromeCandidate);

    if (sb1.equals(sb1.reverse())) 
        return true;
    else
        return false;
}
public static void main(String[] args) {

    String answer;

    for (int i = 100; i <= 999; i++) {
        for (int j = i; j <= 999; j++) {
            int ans = i * j;
            answer = Integer.toString(ans);
            if(isPalindrome(answer)) {
                System.out.println(answer);
            }
            else 
                continue;
        }
    }

}

/*
* 
*回文数字的两种读取方式相同。由两个两位数的乘积构成的最大回文是9009=91×99。
*
*查找由两个3位数字的乘积构成的最大回文。
*
*/
公共类项目EULER4{
公共静态布尔值isAlindrome（字符串回文候选）{
StringBuilder sb1=新的StringBuilder（回文候选）；
if（sb1.equals（sb1.reverse（）））
返回true；
其他的
返回false；
}
公共静态void main（字符串[]args）{
字符串回答；
对于（inti=100；i您需要比较回文候选方法中的字符串，而不是StringBuilders，因此需要进一步更改

if (sb1.equals(sb1.reverse())) 
    return true;
else
    return false;

到

StringBuilder
methods链，因此
sb1.reverse（）
方法在执行反向操作后返回自身。
Replace

if (sb1.equals(sb1.reverse())) 

与

注意：循环结束时也不需要
continue

StringBuilder
s包含相同字符串的字符串不相等，因此需要比较从它们返回的字符串：

return palindromCandidate.equals(new StringBuilder(palindromeCandidate).reverse().toString());


我知道这不关我的事，但这是一个非常昂贵的解谜方法。我建议你想一个更数学的解决办法

你可以这样试试

public class LargestPolindrome {
static List<Integer> polindromes = new ArrayList<Integer>();

/**
 * @param args
 */
public static void main(final String[] args) {
    int polindrome = 0;
    for (int i = 999; i > 1; i--) {
        for (int j = 999; j > 1; j--) {
            polindrome = i * j;
            if (isPolindrome(polindrome)) {
                polindromes.add(polindrome);
            }
        }
    }
    Collections.sort(polindromes);
    System.out.println(polindromes.get(polindromes.size() - 1));
}

public static boolean isPolindrome(final Integer num) {
    final int rer = Integer.valueOf(new StringBuilder(num.toString()).reverse().toString());
    return rer == num;
}

}

公共类最大polindrome{
静态列表polindromes=newArrayList（）；
/**
*@param args
*/
公共静态void main（最终字符串[]args）{
int polindrome=0；
对于（int i=999；i>1；i--）{
对于（int j=999；j>1；j--）{
polindrome=i*j；
if（isPolindrome（polindrome））{
polindromes.add（polindrome）；
}
}
}
集合。排序（polindromes）；
System.out.println（polindromes.get（polindromes.size（）-1））；
}
公共静态布尔isPolindrome（最终整数num）{
final int rer=Integer.valueOf（新StringBuilder（num.toString（））.reverse（）.toString（））；
返回rer==num；
}
}
你可以试试这一个。有一个函数isPallindrome。它检查一个数字是否是回文。在我的主函数中。我运行了一个for循环和一个问题的内部循环，按照问题指示得到两个小于1000的乘积。然后，我检查了，如果结果是回文，它将添加到回文数组列表中。最后，我已经从arraylist中输出了最大值

public static void main(String[] args) {
    // TODO code application logic here
    long result = 0;
    List<Long> palindrome = new ArrayList<Long>();
    for(int i = 0; i < 1000; i++){
        for(int j = 0; j < 1000; j++){
            result = i*j;
            if(isPallindrome(result)){
                palindrome.add(result);
            }
        }

    }
    long i = Collections.max(palindrome);
    System.out.println(i);
}
public static boolean isPallindrome(long n){
    long pallindrome = n;
    long reverse = 0;
    while(pallindrome!=0){
        long remainder = pallindrome % 10;
        reverse = reverse * 10 + remainder;
        pallindrome = pallindrome / 10;
    }
    if(n == reverse){
        return true;
    }
    return false;
}

publicstaticvoidmain（字符串[]args）{
//此处的TODO代码应用程序逻辑
长结果=0；
List palindrome=new ArrayList（）；
对于（int i=0；i<1000；i++）{
对于（int j=0；j<1000；j++）{
结果=i*j；
if（isPallindrome（结果））{
回文。添加（结果）；
}
}
}
long i=Collections.max（回文）；
系统输出打印LN（i）；
}
公共静态布尔值isPallindrome（长n）{
长苍白色素=n；
长反转=0；
while（pallindrome！=0）{
长余数=帕林罗马10%；
反向=反向*10+余数；
帕林罗马=帕林罗马/10；
}
如果（n==反向）{
返回true；
}
返回false；
}
+1：从最大的数字开始，而不是从最小的数字开始。；）
public class LargestPolindrome {
static List<Integer> polindromes = new ArrayList<Integer>();

/**
 * @param args
 */
public static void main(final String[] args) {
    int polindrome = 0;
    for (int i = 999; i > 1; i--) {
        for (int j = 999; j > 1; j--) {
            polindrome = i * j;
            if (isPolindrome(polindrome)) {
                polindromes.add(polindrome);
            }
        }
    }
    Collections.sort(polindromes);
    System.out.println(polindromes.get(polindromes.size() - 1));
}

public static boolean isPolindrome(final Integer num) {
    final int rer = Integer.valueOf(new StringBuilder(num.toString()).reverse().toString());
    return rer == num;
}

}

public static void main(String[] args) {
    // TODO code application logic here
    long result = 0;
    List<Long> palindrome = new ArrayList<Long>();
    for(int i = 0; i < 1000; i++){
        for(int j = 0; j < 1000; j++){
            result = i*j;
            if(isPallindrome(result)){
                palindrome.add(result);
            }
        }

    }
    long i = Collections.max(palindrome);
    System.out.println(i);
}
public static boolean isPallindrome(long n){
    long pallindrome = n;
    long reverse = 0;
    while(pallindrome!=0){
        long remainder = pallindrome % 10;
        reverse = reverse * 10 + remainder;
        pallindrome = pallindrome / 10;
    }
    if(n == reverse){
        return true;
    }
    return false;
}