Поиск числа раз в цикле число существует

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

Преобразование в строку, а затем использовать метод, описанный здесь: 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 2

Первая проблема, которую я замечаю с кодом является то, что это будет return 1, если первая цифра номера соответствует цифре, которую вы ищете. Что, если вы пройдете номер 1145? Он будет возвращать 1 вместо 2.

Хороший базовый регистр будет проверять, является ли пройденный номер действительным (если не возвращать 0), в противном случае повторять каждую цифру (рекурсивно) с помощью счетчика, чтобы подсчитать, сколько раз появляется цифра. Я заметил, что @ Jean-François Savard опубликовал для вас довольно хороший пример кода.

Answer 3

Вы можете сделать это без преобразования в строку, используя оператор mod и усекающее деление, например: // нерекурсивная оболочка для обработки вырожденного случая 0,0 ввода. Публиковать static int digitCount (int numberr, digit) { if ((nunmber == 0) & & (digit == 0)) return 1; else return 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 при вызове с номером агд, равным 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

Вы можете сделать это легко, используя modulos, который мог бы избежать затрат на создание строки.

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

Конечно, если вам не нужно использовать рекурсию это один вкладыш с использованием StringUtils

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

Я понимаю, что это не отвечает на вопрос, но вы не указали, почему вы хотите/необходимость используйте рекурсию в этом случае ... Возможно, это домашнее задание?

Answer 6

Если вы хотите использовать рекурсию, вот решение:

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 7

Ofcourse если вы не специфичны рекурсивного методологии ... Я решение, чтобы решить количество

 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 8

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