Java Odwraca wartość int bez użycia tablicy

Java reverse an int value-Principles

1. Modding ( % ) wejście int przez 10 wyodrębni z prawej cyfry. przykład: (1234 % 10) = 4

2. Pomnożenie liczby całkowitej przez 10 spowoduje "przesunięcie w lewo" odsłaniając zero na prawo od tej liczby, przykład: (5 * 10) = 50

3. Podzielenie liczby całkowitej przez 10 spowoduje usunięcie najbardziej prawej cyfry. (75 / 10) = 7

Java Odwraca wartość int-Pseudocode:

A. Ekstrakt poza prawą cyfrą numeru wejściowego. (1234 % 10) = 4

B. Weź tę cyfrę (4) i dodaj ją do nowej odwrotnej liczby.

C. mnożenie przez 10 (4 * 10) = 40, to oznacza zero po prawej stronie Twojego (4).

D. podziel wejście przez 10, (usunięcie najbardziej prawej cyfry). (1234 / 10) = 123

E. powtórz w kroku a z 123

Java reverse an int value-Working code

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

Nigdy nie zrobisz czegoś takiego w prawdziwym work-world. Jednak proces, w którym można go rozwiązać bez pomocy, oddziela ludzi, którzy mogą rozwiązać problemy od tych, którzy chcą, ale nie mogą, chyba że są karmione łyżką przez miłych ludzi na blogoblagach.

Po prostu możesz użyć tego

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

Możesz użyć tej metody z podaną wartością, którą chcesz revers.

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

To jest rozwiązanie, którego użyłem do tego problemu, i działa dobrze. Więcej szczegółów:

num % 10

To stwierdzenie da ci ostatnią cyfrę z oryginalnego numeru.

num /= 10

To polecenie usunie ostatnią cyfrę z oryginalnego numeru i dlatego jesteśmy pewni, że pętla while zakończy się.

rev = rev*10 + num % 10

Tutaj rev*10 przesunie wartość o lewo, a następnie doda ostatnią cyfrę z oryginału.
Jeśli oryginalny numer to 1258, a w środku biegu czas mamy rev = 85, num = 12 więc:
num%10 = 2
rev*10 = 850
rev*10 + num%10 = 852

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

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

To zwróci odwrotną liczbę całkowitą

Tylko dodać, w nadziei, aby rozwiązanie bardziej kompletne.

Logika @ sheki podała już poprawny sposób odwrócenia liczby całkowitej w Javie. Jeśli założysz, że użyte dane wejściowe i uzyskany wynik zawsze mieszczą się w zakresie [-2147483648, 2147483647], powinieneś być bezpieczny w użyciu kodów przez @sheki. W przeciwnym razie dobrym zwyczajem będzie złapanie wyjątku.

Java 8 wprowadziła metody addExact, subtractExact , multiplyExact oraz toIntExact. Metody te rzucają ArithmeticException po przepełnieniu. Dlatego możesz użyć poniższej implementacji, aby zaimplementować czystą i nieco bezpieczniejszą metodę odwrócenia liczby całkowitej. Ogólnie rzecz biorąc, możemy użyć wymienionych metod do obliczeń matematycznych i jawnie rozwiązać problem przepełnienia, który jest zawsze zalecany, jeśli istnieje możliwość przepełnienia w rzeczywistym użyciu.

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

int aa=456;
System.out.println(Integer.parseInt(new StringBuilder(aa+"").reverse().toString()));

Rozwiązanie Java bez pętli. Szybsza reakcja.

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

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

    }

Dobrze, że napisałeś swój oryginalny kod. Mam inny sposób na zakodowanie tej koncepcji odwracania liczby całkowitej. Dopuszczam tylko do 10 cyfr. Jednak mam zamiar założyć, że użytkownik nie wejdzie zero.

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

Nawet jeśli ujemna liczba całkowita zostanie przekazana, to da ujemną liczbę całkowitą Spróbuj Tego...

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

Jest to najkrótszy kod do odwrócenia integer

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

123 mapy do 321, które można obliczyć jako 3*(10^2)+2*(10^1)+1 Do obliczenia wykorzystuje się dwie funkcje (10^N). Pierwsza funkcja oblicza wartość N. druga funkcja oblicza wartość dla dziesięciu do potęgi 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);
    }
}

Jeśli chodzi o to, aby nie używać tablic lub łańcuchów, odwrócenie liczby całkowitej musi być wykonane przez odczyt cyfr liczby od końca po kolei. Poniżej znajduje się szczegółowe wyjaśnienie, aby pomóc nowicjuszowi.

Pseudocode:

1. zacznijmy od reversed_number = 0 i pewnej wartości dla original_number, która musi zostać odwrócona.
2. the_last_digit = original_number % 10 (tzn. przypomnienie po podzieleniu przez 10)
3. original_number = original_number/10 (ponieważ masz już ostatnią cyfrę, Usuń ostatnią cyfrę z oryginalnego numeru)
4. reversed_number = reversed_number * 10 + last_digit (pomnóż reversed_number przez 10, aby dodać do niego last_digit)
5. powtórz kroki od 2 do 4, aż oryginalny numer stanie się 0. Gdy original_number = 0, reversed_number będzie miał odwrotność original_number.

Więcej informacji na temat kroku 4: Jeśli otrzymujesz jednocześnie cyfrę i poprosisz o dołączenie jej na końcu numeru, jak to zrobić-przesuwając oryginalny numer jeden miejsce w lewo tak, aby pomieścić nową cyfrę. Jeśli liczba 23 ma stać się 234, należy pomnożyć 23 przez 10, a następnie dodać 4.

234 = 23x10 + 4;

Kod:

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

Jest to pytanie przestarzałe, ale jako odniesienie dla innych Po pierwsze reversedNum musi być zainicjalizowane na 0;

Wejście % 10 jest używane do uzyskania ostatniej cyfry z wejścia

Input/10 służy do pozbycia się ostatniej cyfry z input, którą dodałeś do odwróconej liczby

Powiedzmy, że wejście było 135

135% 10 to 5 Ponieważ liczba odwrócona została zainicjalizowana na 0 teraz reversedNum będzie 5

Następnie pozbywamy się 5 dzieląc 135 przez 10

Teraz WEJŚCIE będzie just 13

Twój kod przechodzi przez te kroki, dopóki wszystkie cyfry nie zostaną dodane do odwróconej liczby lub innymi słowy, dopóki wejście nie stanie się 0.

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

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

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

Niech liczba będzie 168,
+ input % 10 zwraca ostatnią cyfrę jako przypomnienie tzn. 8 ale następnym razem powinno zwrócić 6, stąd liczba musi być zredukowana do 16 z 168, ponieważ dzielenie 168 przez 10 daje wynik 16 zamiast 16.8 ponieważ wejście zmiennej ma być typu integer w powyższym programie.

Jeśli chcesz odwrócić dowolną liczbę jak 1234 i chcesz odwrócić tę liczbę, aby wyglądała jak 4321. Przede wszystkim inicjalizuj 3 zmienne int org; int reverse = 0; i INT reminder ; następnie umieść swoją logikę jak

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

    }

Metoda uzyskiwania największej potęgi dziesięciu mniejszych lub równych liczbie całkowitej: (w rekurencji)

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

Metoda odwrócenia rzeczywistej liczby całkowitej:(w rekurencji)

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

Możesz użyć rekurencji, aby rozwiązać ten problem.

Najpierw uzyskaj długość liczby całkowitej, używając następującej funkcji rekurencyjnej.

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

I wtedy można po prostu pomnożyć resztę liczby przez 10^(Długość liczby całkowitej - 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;
}

Cały kod źródłowy:

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

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;

}

/ / powyższy kod będzie działał również dla liczb ujemnych

Zobacz, aby uzyskać ostatnią cyfrę dowolnej liczby dzielimy ją przez 10, więc albo osiągamy zero, albo cyfrę, która jest umieszczona na ostatniej, a gdy robimy to w sposób ciągły, otrzymujemy liczbę całkowitą jako liczbę całkowitą odwróconą.

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

Odwracanie liczby całkowitej

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

public static double reverse(int num)
{
    double num1 = num;
    double ret = 0;
    double counter = 0;

    while (num1 > 1)
    {   
        counter++;
        num1 = num1/10;
    }
    while(counter >= 0)
    {
        int lastdigit = num%10;
        ret += Math.pow(10, counter-1) * lastdigit;
        num = num/10;
        counter--;  
    }
    return ret;
}

import java.util.Scanner;

public class ReverseOfInteger {
    static Scanner input = new Scanner(System.in);

    public static void main(String[] args) {
        int x = input.nextInt();
        System.out.print(helpermethod(x));
    }

    public static String helpermethod(int x) {
        if (x == 0)
            return "";
        String a = String.valueOf(x % 10);
        return a + helpermethod(x / 10);

    }
}

Użyłem String i przekonwertowałem początkowo int na String.Potem użyłem metody odwrotnej. Znalazłem odwrotną liczbę w String, a następnie przekonwertowałem łańcuch z powrotem na int. Oto program.

import java.util.*;

public class Panathinaikos {
    public static void my_try()
    {
        Scanner input = new Scanner(System.in);
        System.out.println("Enter the number you want to be reversed");
        int number = input.nextInt();
        String sReverse = Integer.toString(number);
        String reverse = new StringBuffer(sReverse).reverse().toString();
        int Reversed = Integer.parseInt(reverse);
        System.out.print("The number " + number+ " reversed is " + Reversed);
    }
}

public static void reverse(int number) {
    while (number != 0) {
        int remainder = number % 10;
        System.out.print(remainder);
        number = number / 10;
    }

    System.out.println();
}

To co robi to, usuwa ostatnią cyfrę (w miejscu 10s) i dodaje ją do przodu, a następnie dzieli liczbę przez 10, usuwając ostatnią cyfrę.