Question

我正在尝试创建一个递归方法来查找特定数字在整数中出现的次数。因此，例如，如果number为13563且数字为3，则该方法应返回2，因为3在数字中出现两次。然而，我很困惑我的情况应该是什么情况。

public static int digit(int number, int digit){
if(number.indexOf(0) == digit){
    return 1;
}
else{
    return 1 + digit(number, digit);
}
}

Answer 1

如果你想使用递归，这就是解决方案：

public static int recurseCountDigits(final int number, final int digit){
    if(number < 10) {
        // if the number is less than 10, return if the digit is present, and don't recurse any deeper
        return number == digit ? 1 : 0;
    } else {
        // if the right-most digit is correct
        if(number%10 == digit) {
            // return 1 + the value from the remaining digits (recursion)
            return 1 + recurseCountDigits(number/10, digit);
        } else {
            // else just return the value from the remaining digits (recursion)
            return recurseCountDigits(number/10, digit);
        }
    }
}

此解决方案适用于非负数和非负数。其他组合可能有效，也可能无效。

Answer 2

将其转换为字符串，然后使用此处描述的方法： Simple way to count character occurrences in a string

String s = "...";
int counter = 0;
for( int i=0; i<s.length(); i++ ) {
    if( s.charAt(i) == '$' ) {
        counter++;
    }  
}

转换为字符串：

String.valueOf(number);

Answer 3

你可以通过使用mod运算符和截断除法来转换为字符串，如下所示： //非递归包装器来处理0,0输入的退化情况。 publlc static int digitCount（int numberr，digit）{ if（（nunmber == 0）＆amp;＆amp;（digit == 0））返回1; 其他 return digitCountr（number，digit）; }

public static int digitCountr(int number, int digit){

   if (number == 0)
      return 0;
   if (number % 10 == digit)
      return 1 + digitCount(number / 10, digit);
   else 
      return digitCount(number / 10, digit);
}

当使用数字arg等于0调用时，这将返回0，这可能不是你想要的 - 但它依赖于实际上为了正确计算任何实际的零位数，所以你需要放一个包装器如果你想要那种情况的不同行为。

  public static int digitCount(int number, int digit) {
        if ((number==0) && (digit == 0))
          return 1;
        else
          return digitCountr(number, digit);
        }

    public static int digitCountr(int number, int digit){

       if (number == 0)
          return 0;
       if (number % 10 == digit)
          return 1 + digitCount(number / 10, digit);
       else 
          return digitCount(number / 10, digit);
    }

除此之外，我认为这是准确的。

Answer 4

您可以使用模数轻松完成此操作，这可以避免您制作字符串的成本。

public static int digit(int number, int digit)
{
    if ( number <= 0 ) {
    return 0;
    }
    else {
    if ( number % 10 == digit ) {
        return 1 + digit (number / 10, digit);
    }
    else {
        return digit (number / 10, digit);
    }
    }
}

现在这段代码不适用于负数或空数，而且它不是尾递归的，所以我们可以做得更好。

public static int digit_aux (int number, int digit, int result)
{
    if ( number == 0 ) {
        return result;
    }
    else {
    return digit_aux (number / 10, digit,
                      result + ( ( number % 10 == digit ) ? 1 : 0) );
    }
}


public static int digit (int number, int digit)
{
  if ( number == 0 ) {
   return  (digit == 0) ? 1 : 0;
  }
  else {
   return digit_aux ( Math.abs(number), digit, 0);
  }
}

这是进行递归的好方法（即使我不确定Java是否已经开发了尾调用优化）。

Answer 5

当然，如果你没有具体的递归方法......我有解决方案来解决计数

        int i = 13563;
           Integer u = new Integer(i);

           Map<Integer, Integer> m = new HashMap<Integer, Integer>();
           String s = u.toString();
           char c []=s.toCharArray();

           for (int j=0;j<c.length;j++)
           {


               if(m.containsKey(Integer.valueOf(String.valueOf(c[j]))))
               {

                   int k = m.get(Integer.valueOf(String.valueOf(c[j])));

                   m.put(Integer.valueOf(String.valueOf(c[j])), k+1);

               }else{
                   m.put(Integer.valueOf(String.valueOf(c[j])),1);

               }


           }

           System.out.println("The index digit is 3 count is --> "+m.get(3));

Answer 6

public class code {

    public int count(int N)
    {

            int  i, j, r = 0 , count = 0;


            for(i = 1; i <= 13; i++) {
            j = i;
            while(i >= 10) {
            i = i / 10;
            r = j % 10;
            }
            if(i == 1) {
                count = count + 1;
                }
            if (r == 1)
            {
                count = count+1;
                r=0;
            }
                i = j;
                }
           return count;



                }
public static void main (String args[])
    {
        code c = new code();
    System.out.println(c.count(13));
    }
}

输出：6

Answer 7

我注意到您的代码的第一个问题是，如果数字的第一个数字与您要查找的数字匹配，它将return 1。如果你通过号码1145怎么办？它将返回1而不是2.

一个好的基本情况是检查传递的数字是否有效（如果不是0），否则使用计数器迭代每个数字（递归）计算数字出现的次数。我注意到@ Jean-FrançoisSavard为你发布了一个非常好的代码示例。

Answer 8

当然，如果您不需要使用递归，则使用StringUtils

StringUtils.countMatches(Integer.toString(number), Integer.toString(digit));

我意识到这并没有回答这个问题，但是你没有说明为什么你想要/需要在这种情况下使用递归......这可能是作业吗？

查找数字以整数形式存在的次数

8 个答案: