webentwicklung-frage-antwort-db.com.de

Java einen int-Wert ohne Verwendung eines Arrays umkehren

Kann mir jemand erklären, wie man eine Ganzzahl umkehrt, ohne Array oder String zu verwenden. Ich habe diesen Code online erhalten, verstehe aber nicht wirklich, warum +% 10 eingegeben und erneut geteilt wird.

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

Und wie dieser Beispielcode verwandt wird, um nur ungerade Zahl umzukehren. Beispiel: Ich habe diesen Eingang 12345 erhalten, dann wird die ungerade Zahl auf den Ausgang 531 umgekehrt.

33
user236501

Ihre ungerade Zahl ist mir nicht klar. Die Art und Weise, wie dieser Code funktioniert, ist (es ist kein Java= spezifischer Algorithmus) ZB Eingabe = 2345 erstes Mal in der while-Schleife rev = 5 Eingabe = 234 zweites Mal rev = 5 * 10 + 4 = 54 Eingang = 23 drittes Mal Drehzahl = 54 * 10 + 3 Eingang = 2 viertes Mal Drehzahl = 543 * 10 + 2 Eingang = 0

Die umgekehrte Zahl ist also 5432. Wenn Sie nur die ungeraden Zahlen in der umgekehrten Zahl wollen, dann. Der Code lautet:

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

    }
    input = input / 10; 
}
30
sheki

Java kehrt einen int-Wert um - Prinzipien

  1. Wenn Sie die Eingabe int um 10% ändern, wird die Ziffer ganz rechts extrahiert. Beispiel: (1234% 10) = 4

  2. Wenn Sie eine Ganzzahl mit 10 multiplizieren, wird "Push it left" angezeigt, und rechts von dieser Zahl wird eine Null angezeigt. Beispiel: (5 * 10) = 50

  3. Wenn Sie eine Ganzzahl durch 10 teilen, wird die Ziffer ganz rechts entfernt. (75/10) = 7

Java kehrt einen int-Wert um - Pseudocode:

ein. Extrahieren Sie die am weitesten rechts stehende Ziffer Ihrer Eingabenummer. (1234% 10) = 4

b. Nehmen Sie diese Ziffer (4) und fügen Sie sie in eine neue umgekehrte Zahl ein.

c. Multiplizieren Sie reversedNum mit 10 (4 * 10) = 40, um eine Null rechts von Ihrer (4) zu erhalten.

d. Teilen Sie die Eingabe durch 10 (wobei Sie die Ziffer ganz rechts entfernen). (1234/10) = 123

e. Wiederholen Sie bei Schritt a mit 123

Java kehrt einen int-Wert um - Arbeitscode

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

In der realen Arbeitswelt werden Sie so etwas niemals tun. Der Prozess, mit dem Sie es ohne Hilfe lösen, unterscheidet Menschen, die Probleme lösen können, von denen, die es wollen, kann es aber nicht, es sei denn, sie werden von netten Leuten auf den Blogoblags mit dem Löffel gefüttert.

88
Eric Leschinski

Einfach können Sie dies verwenden

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

Sie können diese Methode mit dem angegebenen Wert verwenden, den Sie rückgängig machen möchten.

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

Das ist die Lösung, die ich für dieses Problem verwendet habe, und sie funktioniert einwandfrei. Mehr Details:

num % 10

Mit dieser Anweisung erhalten Sie die letzte Ziffer der ursprünglichen Nummer.

num /= 10

Durch diese Anweisung wird die letzte Ziffer aus der ursprünglichen Nummer entfernt, und daher sind wir sicher, dass die while-Schleife endet.

rev = rev * 10 + num % 10

Hier verschiebt rev * 10 den Wert um links und fügt dann die letzte Ziffer vom Original hinzu.
Wenn die ursprüngliche Nummer 1258 war und wir in der Mitte der Laufzeit rev = 85 haben, num = 12, also:
num% 10 = 2
rev * 10 = 850
rev * 10 + num% 10 = 852

9
Ahmed Hamdy

Um die letzte Ziffer einer beliebigen Zahl zu erhalten, teilen wir sie durch 10, sodass wir entweder eine Null oder eine Ziffer erhalten, die an letzter Stelle steht, und wenn wir dies kontinuierlich tun, wird die ganze Zahl als ganze Zahl umgekehrt.

    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);
3
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;
    }
}
3
Harsh Kevadia
int aa=456;
int rev=Integer.parseInt(new StringBuilder(aa+"").reverse());
3
Abhishek Sahay
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));
}

Dies gibt die Umkehrung der Ganzzahl zurück

2
pankaj

Nur um hinzuzufügen, in der Hoffnung, die Lösung vollständiger zu machen.

Die Logik von @sheki gab bereits die richtige Art an, eine Ganzzahl in Java umzukehren. Wenn Sie die Eingabe, die Sie verwenden, und das Ergebnis annehmen, fallen Sie immer in den Bereich [-2147483648, 2147483647], Sie sollten sicher sein, die Codes von @sheki zu verwenden. Andernfalls ist es eine gute Praxis, die Ausnahme abzufangen.

In Java 8 wurden die Methoden addExact , subtractExact , multiplyExact und toIntExact . Diese Methoden werfen beim Überlauf ArithmeticException. Daher können Sie die folgende Implementierung verwenden, um eine saubere und etwas sicherere Methode zum Umkehren einer Ganzzahl zu implementieren. Im Allgemeinen können wir die genannten Methoden verwenden, um mathematische Berechnungen durchzuführen und Überlaufprobleme explizit zu behandeln. Dies wird immer dann empfohlen, wenn bei der tatsächlichen Verwendung die Möglichkeit eines Überlaufs besteht.

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;
}
2
Isaac_Zhu

Java-Lösung ohne die Schleife. Schnellere Antwort.

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

Hier ist eine vollständige Lösung (gibt 0 zurück, wenn die Nummer übergelaufen ist):

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;
}
1
Pritam Banerjee
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;
}
1
user3623719

Integer umkehren

  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);
0
Ravichandra S V
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);
}
}
0

Sie können Rekursion verwenden, um dies zu lösen.

ermitteln Sie zunächst die Länge einer Ganzzahl, indem Sie die folgende rekursive Funktion verwenden.

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

und dann können Sie einfach den Rest einer Zahl mit 10 ^ (Länge der ganzen Zahl - 1) multiplizieren.

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

Der gesamte Quellcode:

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();
    }
}
0
Jay Dangar

Wenn Sie eine beliebige Zahl wie 1234 umkehren möchten und diese Zahl umkehren möchten, so dass sie wie 4321 aussieht. Initialisieren Sie zunächst 3 Variablen int org; int reverse = 0; und int Erinnerung; dann stelle deine Logik wie

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

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

lassen sie eine zahl 168 sein,
+ Eingabe% 10 gibt die letzte Ziffer als Erinnerung zurück, dh 8, aber das nächste Mal sollte 6 zurückgegeben werden, daher muss die Zahl von 168 auf 16 reduziert werden, da das Ergebnis 168 durch 10 dividiert wird und nicht 16,8 als variable Eingabe soll im obigen Programm Integer-Typ sein.

0
Milan Malla
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;

}

// Der obige Code funktioniert auch für negative Zahlen

0
Gokul
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));

    }
0
Solbet

Wenn Sie keine Arrays oder Zeichenfolgen verwenden möchten, müssen Sie eine Ganzzahl umkehren, indem Sie die Ziffern einer Zahl nacheinander ablesen. Nachfolgend finden Sie ausführliche Erklärungen, die dem Anfänger helfen sollen.

pseudocode:

  1. beginnen wir mit reversed_number = 0 und einem Wert für original_number, der umgekehrt werden muss.
  2. the_last_digit = original_number% 10 (d. h. die Erinnerung nach dem Teilen durch 10)
  3. original_number = original_number/10 (da wir bereits die letzte Ziffer haben, entfernen Sie die letzte Ziffer aus der original_number)
  4. reverse_number = reverse_number * 10 + last_digit (multiplizieren Sie die reverse_number mit 10, um die last_digit zu addieren)
  5. wiederholen Sie die Schritte 2 bis 4, bis die ursprüngliche_Nummer 0 wird. Wenn ursprüngliche_Nummer = 0 ist, hat umgekehrte_Nummer die Umkehrung der ursprünglichen_Nummer.

Weitere Informationen zu Schritt 4: Wenn Sie jeweils eine Ziffer erhalten und aufgefordert werden, diese am Ende einer Ziffer anzuhängen, wie würden Sie dies tun, indem Sie die ursprüngliche Ziffer um eine Stelle nach links verschieben, um die anzuhängende Ziffer aufzunehmen neue Ziffer. Wenn 23 zu 234 werden muss, multiplizieren Sie 23 mit 10 und addieren dann 4.

234 = 23 × 10 + 4;

Code:

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;
    }
0
Souji

Es ist gut, dass Sie Ihren Originalcode geschrieben haben. Ich habe eine andere Möglichkeit, dieses Konzept der Umkehrung einer Ganzzahl zu codieren. Ich erlaube nur bis zu 10 Stellen. Ich gehe jedoch davon aus, dass der Benutzer keine Null eingibt.

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");
0
H2OPolo

Es ist eine veraltete Frage, aber als Referenz für andere Zunächst muss reversedNum auf 0 initialisiert werden;

eingabe% 10 wird verwendet, um die letzte Ziffer von der Eingabe abzurufen

input/10 wird verwendet, um die letzte Ziffer aus der Eingabe zu entfernen, die Sie zur umgekehrten Zahl hinzugefügt haben

Angenommen, die Eingabe war 135

135% 10 ist 5 Da die umgekehrte Nummer auf 0 initialisiert wurde, lautet die umgekehrte Nummer jetzt 5

Dann werden wir 5 los, indem wir 135 durch 10 teilen

Jetzt ist die Eingabe nur noch 13

Ihr Code durchläuft diese Schritte, bis alle Ziffern zur umgekehrten Zahl hinzugefügt wurden oder mit anderen Worten, bis die Eingabe 0 wird.

0

Eine Methode, um die größte Potenz von zehn zu erhalten, die kleiner oder gleich einer ganzen Zahl ist: (in Rekursion)

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

Die Methode zum Umkehren der tatsächlichen Ganzzahl: (in Rekursion)

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

Dies ist der kürzeste Code zum Umkehren eines integer

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

123 Karten zu 321, die als 3 * (10 ^ 2) + 2 * (10 ^ 1) +1 berechnet werden können. Zur Berechnung von (10 ^ N) werden zwei Funktionen verwendet. Die erste Funktion berechnet den Wert von N. Die zweite Funktion berechnet den Wert von zehn zur Potenz von 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);
    }
}
0
nick w.

Auch wenn eine negative Ganzzahl übergeben wird, wird die negative Ganzzahl angezeigt. 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;
}
0
Amaresh Jana