Question

我只是想在C语言中使用递归来查找回文数。但是，我犯了一个错误，而那个错误我不知道。每次给我结果0。

这是源代码：

#include<stdio.h>
#include<conio.h>

int pal(int num);

void main()
{
    int num=625,res=0;
    res=pal(num);
    printf("%d",res);
    getch();
}

int pal(int num)
{
    int ans=0,rem=0,index=0;
    index=log10(num);
    if(index==0)
    {
        return ;
    }

    index--;

    rem=num%10;
    ans=ans*10+rem;
   return pal(index--);   
}

请给我最简单的查找方法。我需要一个易于理解的程序。

Answer 1

您到底想做什么？

1。检查数字是否为回文。

2。寻找下一个最小/更大的回文。

3。找到数字的反面。

注意：回文数是从两端读取相同的数字。

例如：

         12321 -> palindrome number
         23143 -> not palindrome number
         7     -> palindrome number

要检查某个数字是否为回文数，请先查找该数字的反数（如果反向数等于该数字，则该数字为回文数，否则不是）。

Answer 2

许多问题：

您正在用pal而不是index递归调用num;
如果index为0，则需要返回一个值-该值应该是什么？
main返回int，而不是void；
您对代码要执行的操作的描述不清楚-您是否要反转数字，确定它是否是回文，什么？

假设您要反转数字，那么递归算法将类似于：

int reverse( int num )
{
  /**
   * Account for negative inputs by preserving the sign and 
   * converting the input to positive for processing.
   */
  int sign = 1;
  if ( num < 0 )
  {
    sign = -1;
    num = -num;
  }

  /**
   * If the input is a single digit, then there's
   * nothing to reverse and we return the original
   * input value.
   */
  if ( num < 10 )
    return sign * num;

  /**
   * Otherwise, find and preserve the least significant digit.
   */
  int remainder = num % 10; 

  /**
   * Recursively call reverse on the higher-order digits.
   */
  int rev = reverse( num / 10 ); 

  /**
   * Determine the order of magnitude of the reversed
   * value, multiply the remainder by that magnitude
   * to make it the new most significant digit.
   */
  for ( int tmp = rev; tmp; tmp /= 10 )
    remainder *= 10;

  /**
   * PARENTHESES MATTER HERE
   */
  return sign * (remainder + rev);
}

编辑

我添加了一些文档，希望可以使代码更加清晰。我还更改了乘以remainder的方式，因此它不依赖于pow函数。

Answer 3

int pal(int num){
  int n=0;
  while (num != 0){
    n = n * 10;
    n = n + num%10;
    num = num/10;
  }
  return num;
}

此函数将返回一个反向数字，您可以将其与输入和if(input == pal(input))进行比较，否则它是回文，否则就不是。希望对您有帮助。

Answer 4

完全反转数字以将其与原始数字进行比较似乎是检验数字是否为回文式的错误方法。一旦数字左右两端的数字不匹配，就可以完成操作，而无需继续反转数字。解决方案在过程中，而不是结果中。

这是一个简单的递归回文数谓词功能：

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

bool is_palindrome(unsigned long long number)
{
    unsigned int logarithm = log10(number);

    if (logarithm == 0)
    {
        return true;  // single digit numbers are palindromes
    }

    unsigned long long power = pow(10, logarithm);

    unsigned int left = number / power;
    unsigned int right = number % 10;

    if (left == right)
    {
        // ends match, so toss 'em and test what's left recursively
        return is_palindrome((number - left * power) / 10);
    }

    return false;  // ends don't match, so not a palindrome
}

int main(int argc, const char *argv[])
{
    printf("%s\n", is_palindrome(atoll(argv[1])) ? "Yes" : "No");

    return 1;
}

测试案例

% ./a.out 6
Yes
% ./a.out 66
Yes
% ./a.out 666
Yes
% ./a.out 625
No
% ./a.out 12345678987654321
Yes
% ./a.out 31415
No

在C中使用递归的回文数

4 个答案: