Java配列を使用せずにint値を反転

Question

配列や文字列を使用せずに整数を逆にする方法を誰にでも説明できますか？私はこのコードをオンラインから入手しましたが、なぜ+ 10％を入力し、再び分割するのか本当にわかりません。

while (input != 0) {
    reversedNum = reversedNum * 10 + input % 10;
    input = input / 10;   
}

そして、このサンプルコードを使用して奇数のみを反転する方法。例この入力12345を取得すると、奇数を反転して出力531になります。

Answer 1

私はあなたの奇数について明確ではありません。このコードの仕組みは（Java特定のアルゴリズムではありません）例えば、whileループの最初の入力= 2345 rev = 5 input = 234回目のrev = 5 * 10 + 4 = 54入力= 23回目rev = 54 * 10 + 3入力= 2回目4回目rev = 543 * 10 + 2入力= 0

したがって、逆の数は5432です。逆の数の奇数のみが必要な場合は。コードは次のとおりです。

while (input != 0) {    
    last_digit = input % 10;
    if (last_digit % 2 != 0) {     
        reversedNum = reversedNum * 10 + last_digit;

    }
    input = input / 10; 
}

Answer 2

Javaはint値を反転します-原則

1. 入力intを10で改造（％）すると、右端の数字が抽出されます。例：（1234％10）= 4

2. 整数に10を掛けると、「左に押して」、その数値の右側にゼロが表示されます。例：（5 * 10）= 50

3. 整数を10で除算すると、右端の数字が削除されます。 （75/10）= 7

Javaはint値を反転します-擬似コード：

a。入力番号の右端の数字を抽出します。 （1234％10）= 4

b。その数字（4）を取得して、新しいreverseNumに追加します。

c。 reverseNumに10（4 * 10）= 40を掛けると、（4）の右側にゼロが現れます。

d。入力を10で除算します（右端の数字を削除します）。 （1234/10）= 123

e。 123でステップaを繰り返します

Javaはint値を反転-作業コード

public int reverseInt(int input) {
    long reversedNum = 0;
    long input_long = input;

    while (input_long != 0) {
        reversedNum = reversedNum * 10 + input_long % 10;
        input_long = input_long / 10;
    }

    if (reversedNum > Integer.MAX_VALUE || reversedNum < Integer.MIN_VALUE) {
        throw new IllegalArgumentException();
    }
    return (int) reversedNum;
}

実際の仕事の世界では、このようなことは決してしません。しかし、助けを借りずに解決するために使用するプロセスは、問題を解決できる人と望んでいる人を区別するものですが、Blogoblagsでニースの人がスプーンで食べない限りできないのです。

Answer 3

単にあなたはこれを使用することができます

public int getReverseInt(int value) {
    int resultNumber = 0;
    for (int i = value; i !=0; i /= 10) {
        resultNumber = resultNumber * 10 + i % 10;
    }
    return resultNumber;        
}

このメソッドは、反転させたい値を指定して使用できます。

Answer 4

while (num != 0) {
    rev = rev * 10 + num % 10;
    num /= 10;
}

それが私がこの問題に使用した解決策であり、問​​題なく動作します。詳細：

num % 10

このステートメントは、元の番号から最後の数字を取得します。

num /= 10

このステートメントは、元の数字から最後の数字を削除するため、whileループが終了することを確信しています。

rev = rev * 10 + num % 10

ここで、rev * 10は値を左にシフトし、元の最後の数字を追加します。
元の数値が1258で、実行中にrev = 85、num = 12の場合：
num％10 = 2
rev * 10 = 850
rev * 10 + num％10 = 852

Answer 5

数字の最後の桁を取得して10で割ると、ゼロまたは最後に配置される数字が得られ、これを連続して行うと整数として整数が逆になります。

    int number=8989,last_num,sum=0;
    while(number>0){
    last_num=number%10; // this will give 8989%10=9
    number/=10;     // now we have 9 in last and now num/ by 10= 898
    sum=sum*10+last_number; //  sum=0*10+9=9;
    }
    // last_num=9.   number= 898. sum=9
    // last_num=8.   number =89.  sum=9*10+8= 98
   // last_num=9.   number=8.    sum=98*10+9=989
   // last_num=8.   number=0.    sum=989*10+8=9898
  // hence completed
   System.out.println("Reverse is"+sum);

Answer 6

import Java.util.Scanner;

public class Reverse_order_integer {
    private static Scanner scan;

    public static void main(String[] args) {
        System.out.println("\t\t\tEnter Number which you want to reverse.\n");
        scan = new Scanner(System.in);
        int number = scan.nextInt();
        int rev_number = reverse(number);
        System.out.println("\t\t\tYour reverse Number is = \"" + rev_number
                           + "\".\n");
    }

    private static int reverse(int number) {
        int backup = number;
        int count = 0;
        while (number != 0) {
            number = number / 10;
            count++;
        }
        number = backup;
        int sum = 0;
        for (int i = count; i > 0; i--) {
            int sum10 = 1;
            int last = number % 10;
            for (int j = 1; j < i; j++) {
                sum10 = sum10 * 10;
            }
            sum = sum + (last * sum10);
            number = number / 10;
        }
        return sum;
    }
}

Answer 7

int aa=456;
int rev=Integer.parseInt(new StringBuilder(aa+"").reverse());

Answer 8

public static void main(String args[]) {
    int n = 0, res = 0, n1 = 0, rev = 0;
    int sum = 0;
    Scanner scan = new Scanner(System.in);
    System.out.println("Please Enter No.: ");
    n1 = scan.nextInt(); // String s1=String.valueOf(n1);
    int len = (n1 == 0) ? 1 : (int) Math.log10(n1) + 1;
    while (n1 > 0) {
        rev = res * ((int) Math.pow(10, len));
        res = n1 % 10;
        n1 = n1 / 10;
        // sum+=res; //sum=sum+res;
        sum += rev;
        len--;
    }
    // System.out.println("sum No: " + sum);
    System.out.println("sum No: " + (sum + res));
}

これは整数の逆を返します

Answer 9

ソリューションをより完全なものにすることを期待して、追加するだけです。

@shekiによるロジックは、Javaで整数を逆にする正しい方法をすでに提供しています。使用する入力と取得する結果が常に[-2147483648, 2147483647]の範囲内にあると想定する場合、@ shekiによるコードを使用しても安全です。それ以外の場合は、例外をキャッチすることをお勧めします。

Java 8では、メソッド addExact 、 subtractExact 、 multiplyExact および toIntExact これらのメソッドは、オーバーフロー時にArithmeticExceptionをスローします。したがって、以下の実装を使用して、整数を逆にするためのクリーンで少し安全なメソッドを実装できます。通常、前述の方法を使用して数学的な計算を行い、オーバーフローの問題を明示的に処理できます。実際の使用でオーバーフローの可能性がある場合は、常に推奨されます。

public int reverse(int x) {
    int result = 0;

    while (x != 0){
        try {
            result = Math.multiplyExact(result, 10);
            result = Math.addExact(result, x % 10);
            x /= 10;
        } catch (ArithmeticException e) {
            result = 0; // Exception handling
            break;
        }
    }

    return result;
}

Answer 10

ループのないJavaソリューション。より速い応答。

int numberToReverse;//your number 
StringBuilder sb=new StringBuilder();
sb.append(numberToReverse);
sb=sb.reverse();
String intermediateString=sb.toString();
int reversedNumber=Integer.parseInt(intermediateString);

Answer 11

完全なソリューションを次に示します（数値がオーバーフローした場合は0を返します）。

public int reverse(int x) {
    boolean flag = false;

    // Helpful to check if int is within range of "int"
    long num = x;

    // if the number is negative then turn the flag on.
    if(x < 0) {
        flag = true;
        num = 0 - num;
    }

    // used for the result.
    long result = 0;

    // continue dividing till number is greater than 0
    while(num > 0) {
        result = result*10 + num%10;
        num= num/10;
    }

    if(flag) {
        result = 0 - result;
    }

    if(result > Integer.MAX_VALUE || result < Integer.MIN_VALUE) {
        return 0;
    }
    return (int) result;
}

Answer 12

public static int reverse(int x) {
    boolean negetive = false;
    if (x < 0) {
        x = Math.abs(x);
        negative = true;
    }

    int y = 0, i = 0;
    while (x > 0) {
        if (i > 0) {
            y *= 10;
        }

        y += x % 10;
        x = x / 10;
        i++;
    }
    return negative ? -y : y;
}

Answer 13

反転整数

  int n, reverse = 0;
  Scanner in = new Scanner(System.in);
  n = in.nextInt();

  while(n != 0)
  {
      reverse = reverse * 10;
      reverse = reverse + n%10;
      n = n/10;
  }

  System.out.println("Reverse of the number is " + reverse);

Answer 14

import Java.io.BufferedReader;
import Java.io.InputStreamReader;
public class intreverse
{
public static void main(String...a)throws Exception
{
    int no;
    int rev = 0;
    System.out.println("Enter The no to be reversed");
    InputStreamReader str=new InputStreamReader(System.in);
    BufferedReader br =new BufferedReader(str);
    no=Integer.parseInt(br.readLine().toString());
    while(no!=0)
    {
        rev=rev*10+no%10;
        no=no/10;

    }
    System.out.println(rev);
}
}

Answer 15

これを解決するには、再帰を使用できます。

最初に、次の再帰関数を使用して整数の長さを取得します。

int Length(int num,int count){
    if(num==0){
        return count;
    }
    else{
        count++;
        return Lenght(num/10,count);
    }
}

そして、単純に数値の剰余に10 ^（整数の長さ-1）を掛けることができます。

int ReturnReverse(int num,int Length,int reverse){
    if(Length!=0){
        reverse = reverse + ((num%10) * (int)(Math.pow(10,Length-1)));
        return ReturnReverse(num/10,Length-1,reverse);
    }
    return reverse;
}

ソースコード全体：

import Java.util.Scanner;

public class ReverseNumbers {

    int Length(int num, int count) {
        if (num == 0) {
            return count;
        } else {
            return Length(num / 10, count + 1);
        }
    }

    int ReturnReverse(int num, int Length, int reverse) {
        if (Length != 0) {
            reverse = reverse + ((num % 10) * (int) (Math.pow(10, Length - 1)));
            return ReturnReverse(num / 10, Length - 1, reverse);
        }
        return reverse;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int N = scanner.nextInt();

        ReverseNumbers reverseNumbers = new ReverseNumbers();
        reverseNumbers.ReturnReverse(N, reverseNumbers.Length(N, 0), reverseNumbers.ReturnReverse(N, reverseNumbers.Length(N, 0), 0));

        scanner.close();
    }
}

Answer 16

1234のような任意の数値を反転させたい場合、この数値を反転して4321のように見せたい場合は、まず3つの変数int orgを初期化します。 int reverse = 0;およびintリマインダー。次に、あなたのロジックを

    Scanner input = new Scanner (System.in);
    System.out.println("Enter number to reverse ");
    int org = input.nextInt();
    int getReminder;
    int r = 0;
    int count = 0;

    while (org !=0){
        getReminder = org%10;
         r = 10 * r + getReminder;
         org = org/10;



    }
        System.out.println(r);

    }

Answer 17

while (input != 0) {
  reversedNum = reversedNum * 10 + input % 10;
  input = input / 10;
}

数字を168にする
+ input％10はリマインダとして最後の数字、つまり8を返しますが、次回は6を返す必要があるため、168から16に減らす必要があります。上記のプログラムでは整数型であると想定されていました。

Answer 18

public int getReverseNumber(int number)
{
    int reminder = 0, result = 0;
    while (number !=0)
    {
        if (number >= 10 || number <= -10)
        {
            reminder = number % 10;
            result = result + reminder;
            result = result * 10;
            number = number / 10;
        }
        else
        {
            result = result + number;
            number /= 10;
        }
    }
    return result;

}

//上記のコードは負数でも機能します

Answer 19

int convert (int n)
{
        long val = 0;

        if(n==0)
            return 0;

        for(int i = 1; n > exponent(10,  (i-1)); i++)
        {
            int mod = n%( (exponent(10, i))) ;
            int index = mod / (exponent(10, i-1));

            val *= 10;
            val += index;
        }

        if (val < Integer.MIN_VALUE || val > Integer.MAX_VALUE) 
        {
            throw new IllegalArgumentException
                (val + " cannot be cast to int without changing its value.");
        }
        return (int) val;

    }


static int exponent(int m, int n)
    {
        if(n < 0) 
            return 0;
        if(0 == n) 
            return 1;

        return (m * exponent(m, n-1));

    }

Answer 20

配列または文字列を使用しないという考えの場合、整数を反転するには、最後から数字を一度に1つずつ読み取って行う必要があります。以下の説明は、初心者を助けるために詳細に提供されています。

擬似コード：

1. reverse_number = 0から始め、original_numberの値を元に戻す必要があります。
2. the_last_digit = original_number％10（つまり、10で割った後のリマインダー）
3. original_number = original_number/10（すでに最後の桁があるため、original_numberから最後の桁を削除します）
4. reverse_number = reverse_number * 10 + last_digit（last_digitに10を掛けて、last_digitを追加します）
5. original_numberが0になるまで、手順2〜4を繰り返します。original_number= 0の場合、reversed_numberはoriginal_numberの逆になります。

ステップ4の詳細：一度に数字が提供され、数字の最後に数字を追加するように求められた場合、元の数字を左に1桁移動して、新しい数字。 23番が234になる必要がある場合、23に10を掛けてから4を加算します。

234 = 23x10 + 4;

コード：

public static int reverseInt(int original_number) {
        int reversed_number = 0;
        while (original_number > 0) {
            int last_digit = original_number % 10;
            original_number = original_number / 10;
            reversed_number = reversed_number * 10 + last_digit;    
        }
        return reversed_number;
    }

Answer 21

元のコードを書いておくのは良いことです。整数を反転させるというこの概念をコーディングする別の方法があります。最大10桁まで許可します。ただし、ユーザーがゼロを入力しないと仮定します。

if((inputNum <= 999999999)&&(inputNum > 0 ))
{
   System.out.print("Your number reversed is: ");

   do
   {
      endInt = inputNum % 10; //to get the last digit of the number
      inputNum /= 10;
      system.out.print(endInt);
   }
   While(inputNum != 0);
 System.out.println("");

}
 else
   System.out.println("You used an incorrect number of integers.\n");

System.out.println("Program end");

Answer 22

これは時代遅れの質問ですが、他の人への参照としてまず最初にreverseNumを0に初期化する必要があります。

input％10は、入力から最後の数字を取得するために使用されます

input/10は、reverseNumに追加した入力から最後の数字を取り除くために使用されます

入力が135だったとします

135％10は5です。反転数が0に初期化されたため、反転数は5になります。

次に、135を10で割って5を取り除きます

入力はわずか13になります

コードは、すべての数字が逆数に追加されるまで、つまり入力が0になるまで、これらのステップをループします。

Answer 23

整数以下の最大の10のべき乗を取得する方法：（再帰）

public static int powerOfTen(int n) {
    if ( n < 10)
        return 1;
    else
        return 10 * powerOfTen(n/10); 
}

実際の整数を逆にする方法：（再帰）

public static int reverseInteger(int i) {
    if (i / 10 < 1)
        return i ;
    else
        return i%10*powerOfTen(i) + reverseInteger(i/10);
}

Answer 24

これは、integerを逆にする最短のコードです

int i=5263; 
System.out.println(Integer.parseInt(new StringBuffer(String.valueOf(i) ).reverse().toString()));

Answer 25

123は321にマップされ、3 *（10 ^ 2）+ 2 *（10 ^ 1）+1として計算できます。2つの関数を使用して（10 ^ N）を計算します。最初の関数はNの値を計算します。2番目の関数は10のN乗の値を計算します。

Function<Integer, Integer> powerN = x -> Double.valueOf(Math.log10(x)).intValue();
Function<Integer, Integer> ten2powerN = y -> Double.valueOf(Math.pow(10, y)).intValue();

// 123 => 321= 3*10^2 + 2*10 + 1
public int reverse(int number) {
    if (number < 10) {
        return number;
    } else {
        return (number % 10) * powerN.andThen(ten2powerN).apply(number) + reverse(number / 10);
    }
}

Answer 26

負の整数が渡された場合でも、負の整数が与えられますTry This ...

public int reverse(int result) {

    long newNum=0,old=result;
    result=(result>0) ? result:(0-result);

    while(result!=0){
        newNum*=10;
        newNum+=result%10;
        result/=10;
        if(newNum>Integer.MAX_VALUE||newNum<Integer.MIN_VALUE)
            return 0;
    }
    if(old > 0)
        return (int)newNum;
    else if(old < 0)
        return (int)(newNum*-1);
    else 
        return 0;
}