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

Question

我正在尝试创建一种递归方法来查找特定数字在整数中出现的次数。例如，如果数字是 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

您可以使用模数轻松做到这一点，这可以避免您制作字符串的成本。

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 4

当然，如果你不是特定的递归方法......我有解决方案来解决计数

        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 5

您可以通过使用 mod 运算符和截断除法来完成它，而无需转换为字符串，如下所示： // 用于处理 0,0 输入的退化情况的非递归包装器。 publlc 静态 int digitCount(int numberr, digit) { if ((数字==0) && (数字== 0)) 返回 1； 别的 返回 digitCountr（数字，数字）； }

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

当使用等于 0 的数字 arg 调用时，这将返回 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 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çois Savard 为您发布了一个非常好的代码示例。

Answer 8

当然，如果您不需要使用递归，它是使用StringUtils 的单行程序

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

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