재귀 - 역순으로 숫자

Question

정수 num을 매개 변수로 사용하고 행을 한 자릿수 역순으로 인쇄하는 재귀 적 메서드 인 printDigits를 구현해야합니다. 내가 놓친 거지 코드 한 줄이 같은 느낌

public class PrintDigits { 

    public static void main(String[] args) { 
     System.out.println("Reverse of no. is " + reversDigits(91)); 
    } 

    /* Recursive function to reverse digits of num */ 
    public static int reversDigits(int number) { 
     if (number == 0) 
      return number; 
     else { 
      return number % 10; 
     } 
    } 
} 

을,하지만 난 그것을 해결하기 위해 무엇을해야하는지 확실하지 :

이것은 내가 지금까지있는 것입니다.

Answer 1

public static void main(String[] args) { 
    reverseDigits(98198187); 
} 

/* Recursive function to reverse digits of num */ 
public static void reverseDigits(long number) { 
    if (number < 10) { 
     System.out.println(number); 
     return; 
    } 
    else { 
     System.out.println(number % 10); 
     reverseDigits(number/10); 
    } 
} 

Answer 2

public static int reversDigits(int num) { 
    if(num < 1) { 
     return 0; 
    } 

    int temp = num % 10; 
    num = (num - temp)/10; 
    System.out.println(temp); 

    return reversDigits(num); 
} 

이 역순으로 한 번에 숫자 하나를 인쇄합니다. 당신은 당신의 주된 방법으로 System.out을 할 필요가 없습니다.

Answer 3

나는 (왼쪽에) 가장 높은 자릿수를 골라야하고 가장 오른쪽 자릿수쪽으로 작업해야한다는 것을 알았습니다. 나는 재귀 적으로 오른쪽에서 왼쪽으로가는 일을 할 수 없었다.

public static int reverseItRecursive(int number) 
{ 
    if (number == 0) 
     return 0; 

    int n = number; 
    int pow = 1; 

    while (n >= 10) 
    { 
     n = n/10; 
     pow = pow * 10; 
    } 
    return (n + reverseItRecursive(number - n*pow)*10); 
} 

Answer 4

이 정확하게 질문에 대답하지 않습니다

int rev = 0; 
int reverse(int num) 
{ 
    if (num < 10) { 
     rev = rev*10 + num; 
    } 
    else { 
     rev = rev*10 + (num % 10); 
     num = reverse(num/10); 

    } 
    return rev; 
} 

Answer 5

이 작동해야하지만, 실제로 은를 계산으로 숫자를 인쇄 전체 반전 수 대신 를 계산합니다. 결과는 숫자가 역순으로있는 int입니다. 훨씬 더 강력한 하나 숫자 하나의 문자열 버전을 인쇄 이상 :

public class Reverse { 
    public static void main(String[] args) { 
     // input int parameter 
     int param = Integer.parseInt(args[0]); 
     System.out.println(reverse(param)); 
    } 

    public static int reverse(int input) { 
     return reverse(input, 0); 
    } 

    private static int reverse(int original, int reversed) { 
     // get the rightmost original digit and remove it 
     int rightmost = original % 10; 
     original -= rightmost; 
     original /= 10; 

     // add rightmost original digit to left of reversed 
     reversed += rightmost * Math.pow(10, numDigits(original)); 

     return (original == 0) 
      ? reversed 
      : reverse(original, reversed); 
    } 

    public static int numDigits(int number) { 
     number = Math.abs(number); 

     if (number >= 10) { 
      return 1 + numDigits(number /= 10); 
     } else if (number > 0) { 
      return 1; 
     } else { 
      return 0; 
     } 
    } 
} 

Answer 6

public static void reversDigits(long number) { 
    System.out.println(number % 10); 
    if (number >= 10) { 
     reversDigits(number/10); 
    } 
} 

이 지금까지 가장 짧은/간단한 버전)

Answer 7

내가 나보다 더 우아한 버전을 찾고 와서는 ,하지만 이것은 단지 약간의 지저분한 알고리즘을 필요로합니다. 광산 : 광산은 내가 훨씬 더 유용 단지 문자열 인쇄보다 동의 실제 정수 값을 반환

public static int reverse(int n){ 
     if(n<10)return n; 
     return n%10*(int)Math.pow(10,(int)Math.log10((double)n)) + reverse(n/10); 
    } 

그래서이 마지막 숫자를 반환, 10^현재 전력 + (재귀 호출)를 곱한 값을

여기

Answer 8

당신은 이동 :

static String reverseDigits(int n) 
{ 
    String N = ""; 
    if (n== 0) 
     return N; 
    else 
    { 
     N += n%10; 
     return N + reverseDigits(n/= 10); 
    }    
} 

이 물론이다는 문자열로 반환.

당신은 당신이해야 할 모든 int로서 원하는 경우

여기 Integer.parseInt()

Answer 9

//Reverse a number using recursion by bibhu.rank 
public class Rev_num { 
    public static int revnum(int x){ 
     int temp1=x,temp2=1; 
     if(x<10){ 
      return x; 
     } 
     while(temp1>=10){ 
      temp2*=10; 
      temp1/=10; 
     } 
     if(((x%temp2) < (temp2/10))&& x%temp2!=0){ 
      int c=temp2; 
      while(c> x%temp2){ 
       c/=10; 
      } 
      c=temp2/c; 
      temp2=x%temp2; 
      return((temp1)+(c*revnum(temp2))); 
     } 
     temp2=x%temp2; 

     return (temp1+(10*revnum(temp2))); 

    } 

    public static void main(String[] args) { 
     // TODO Auto-generated method stub 
     System.out.println("Enter a number"); 
     Scanner y=new Scanner(System.in); 
     System.out.println(revnum(y.nextInt())); 
     y.close(); 


    } 

} 

Answer 10

public class reverseIntRec{ 
     public static void main(String args[]) { 
      System.out.println(reverse(91)); 
     } 
     public static int reverse(int x) { 
     String strX = String.valueOf(x); 
      if (Math.abs(x) < 10) 
       return x; 
      else 
      return x % 10 * ((int) Math.pow(10, strX.length()-1)) + reverse(x/10); 
     } 
    } 

정수로 내 대답 리턴이 사용하여 분석이다. x을 문자열로 변환하여 0s과 곱해야하는 숫자를 확인하십시오.

예 : reverse (91)는 1 * 10 + reverse (9)를 반환하며 10 + 9 = 19를 반환합니다.

Answer 11

//Try out this, recursion with singe variable using Math class. 
public static void main(String[] args) { 
    // Let the number be 139 
    int n=139; 
    System.out.println("reverse is "+rev(n)); 
} 
static int rev(int n){ 
    if (n==0)return 0; 
    else { 
     return n%10*(int) Math.pow(10,(double) (int)Math.log10(n))+rev(n/10); 
    }  
} 

Answer 12

이 방법은 역 정수 및 문자열 수학 함수를 사용하지 않고, 그 결과를 반환하거나, 인쇄에 의해 단지

public class ReverseNumber { 

    public static void main (String[] args) { 
     ReverseNumber rNumber = new ReverseNumber(); 
     System.out.println(rNumber.reverseRecursive(1234,0)); // pass zero to initialize the reverse number 
    } 
    public int reverseRecursive(int n, int reverse) {// n - the number to reverse 
     // System.out.println(n); 

     if (n != 0){ 
      reverse = reverse * 10; 
      reverse = reverse + n %10; 
      n = n/10; 
     } else { 
       return reverse; 
     } 
    return reverseRecursive(n,reverse); 
}} 

Answer 13

public void reverse(int num){ 
     System.out.print(num %10); 
     if(num/10 == 0){ 
       return; 
     } 
     reverse(num /10); 
     return; 
    }