Java inverte um valor int sem usar matriz

Alguém pode me explicar como inverter um número inteiro sem usar matriz ou String. Eu tenho esse código on-line, mas não entendo porque + input% 10 e divido novamente.

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

E como usar esse código de exemplo para reverter apenas o número ímpar. Exemplo eu tenho essa input 12345, então ele irá inverter o número ímpar para a saída 531.

Não estou claro sobre o seu número ímpar. A maneira como este código funciona é (não é um algoritmo específico de Java). input = 2345 primeira vez no ciclo while rev = 5 input = 234 segundo tempo rev = 5 * 10 + 4 = 54 input = 23 terceira vez rev = 54 * 10 + 3 input = 2 quarta vez rev = 543 * 10 + 2 input = 0

Portanto, o número invertido é 5432. Se você quiser apenas os números ímpares no número invertido, então. O código é:

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

Java inverte um valor int – Princípios

  1. Modding (%) a input int por 10 extrairá o dígito mais à direita. exemplo: (1234% 10) = 4

  2. Multiplicar um número inteiro por 10 “empurrará para a esquerda”, expondo um zero à direita desse número, por exemplo: (5 * 10) = 50

  3. Dividir um inteiro por 10 removerá o dígito mais à direita. (75/10) = 7

Java inverte um valor int – Pseudocódigo:

uma. Extraia o dígito mais à direita do seu número de input. (1234% 10) = 4

b. Pegue esse dígito (4) e adicione-o em um novo Núm invertido.

c. Multiplique o valor invertido por 10 (4 * 10) = 40, isso expõe um zero à direita do seu (4).

d. Divida a input por 10, (removendo o dígito mais à direita). (1234/10) = 123

e. Repita no passo a com 123

Java inverte um valor int – Código de trabalho

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

Você nunca fará nada assim no mundo do trabalho real. No entanto, o processo pelo qual você usa para resolvê-lo sem ajuda é o que separa as pessoas que podem resolver os problemas daqueles que querem, mas não podem, a menos que sejam alimentadas por pessoas legais nos blogoblags.

Simplesmente você pode usar isso

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

Você pode usar esse método com determinado valor que deseja inverter.

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

Essa é a solução que usei para esse problema e funciona bem. Mais detalhes:

 num % 10 

Esta declaração vai te dar o último dígito do número original.

 num /= 10 

Essa declaração eliminará o último dígito do número original e, portanto, temos certeza de que o loop while terminará.

 rev = rev*10 + num % 10 

Aqui, rev * 10 mudará o valor à esquerda e depois adicionará o último dígito do original.
Se o número original for 1258 e no meio do tempo de execução, temos rev = 85, num = 12, então:
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)); } 

Isso retornará reverso de inteiro

Apenas para adicionar, na esperança de tornar a solução mais completa.

A lógica de @sheki já dava a maneira correta de reverter um inteiro em Java. Se você assumir que a input que você usa e o resultado que você obtém sempre ficam dentro do intervalo [-2147483648, 2147483647] , você deve estar seguro de usar os códigos por @sheki. Caso contrário, será uma boa prática pegar a exceção.

O Java 8 introduziu os methods addExact , subtractExact , multiplyExact e toIntExact . Estes methods irão lançar ArithmeticException após estouro. Portanto, você pode usar a implementação abaixo para implementar um método limpo e um pouco mais seguro para inverter um número inteiro. Geralmente, podemos usar os methods mencionados para fazer cálculos matemáticos e tratar explicitamente o problema de estouro, o que é sempre recomendado se houver possibilidade de estouro no uso real.

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

Solução Java sem o loop. Resposta mais rápida

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

É bom que você tenha escrito seu código original. Eu tenho outra maneira de codificar esse conceito de reverter um inteiro. Eu só vou permitir até 10 dígitos. No entanto, vou supor que o usuário não entrará em 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"); 

Mesmo se o número inteiro negativo for passado, ele dará o inteiro negativo 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 0) return (int)newNum; else if(old < 0) return (int)(newNum*-1); else return 0; } 

Este é o código mais curto para inverter um integer

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

123 mapeia para 321, que podem ser calculados como 3 * (10 ^ 2) + 2 * (10 ^ 1) +1 Duas funções são usadas para calcular (10 ^ N). A primeira function calcula o valor de N. A segunda function calcula o valor de dez para poder N.

 Function powerN = x -> Double.valueOf(Math.log10(x)).intValue(); Function 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); } } 

Se a ideia não é usar matrizes ou cadeias de caracteres, a reversão de um número inteiro deve ser feita lendo os dígitos de um número do final, um de cada vez. Abaixo explicação é fornecida em detalhes para ajudar o principiante.

pseudo-código :

  1. Vamos começar com reverseed_number = 0 e algum valor para original_number que precisa ser revertido.
  2. the_last_digit = original_number% 10 (ou seja, o lembrete após dividir por 10)
  3. original_number = original_number / 10 (como já temos o último dígito, remova o último dígito do original_number)
  4. reverseed_number = reversed_number * 10 + last_digit (multiplique o número invertido por 10 para adicionar o last_digit a ele)
  5. repita as etapas 2 a 4, até que o original_number se torne 0. Quando original_number = 0, reversed_number terá o reverso do original_number.

Mais informações sobre o passo 4: Se lhe for fornecido um dígito de cada vez, e solicitado a anexá-lo no final de um número, como o faria – movendo o número original um lugar para a esquerda de forma a acomodar o número novo dígito. Se o número 23 tiver que se tornar 234, multiplique 23 por 10 e, em seguida, adicione 4.

234 = 23×10 + 4;

Código:

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

É uma questão desatualizada, mas como uma referência para os outros. Antes de mais nada, inverte-se. Num deve ser inicializado como 0;

input% 10 é usada para obter o último dígito da input

input / 10 é usado para se livrar do último dígito da input, que você adicionou ao reversedNum

Digamos que a input tenha sido de 135

135% 10 é 5 Como o número invertido foi inicializado para 0, agora o valor invertido será 5

Então nos livramos de 5 dividindo 135 por 10

Agora a input será apenas 13

Seu código percorre essas etapas até que todos os dígitos sejam adicionados ao número invertido ou, em outras palavras, até que a input se torne 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; } 

deixe um número ser 168,
+ input% 10 retorna último dígito como lembrete ie 8 mas da próxima vez deve retornar 6, portanto o número deve ser reduzido para 16 de 168, como dividir 168 por 10 que resulta em 16 em vez de 16.8 como input variável é suposto ser tipo inteiro no programa acima.

Se você quer reverter qualquer número como 1234 e você quer reverter este número para deixá-lo parecido com 4321. Primeiro de tudo, inicialize 3 variables ​​int org; int reverso = 0; e int lembrete; em seguida, coloque sua lógica como

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

Um método para obter a maior potência de dez menor ou igual a um inteiro: (em recursion)

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

O método para inverter o número inteiro real: (em recursion)

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

Você pode usar a recursion para resolver isso.

primeiro obtenha o comprimento de um número inteiro usando a seguinte function recursiva.

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

e então você pode simplesmente multiplicar o restante de um número por 10 ^ (Length of integer – 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; } 

Todo o Código Fonte:

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

// O código acima funcionará para números negativos também

Veja para obter o último dígito de qualquer número que dividimos por 10 para que possamos atingir zero ou um dígito que é colocado no último e quando fazemos isso continuamente, obtemos o número inteiro como um inteiro invertido.

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

Eu usei String e converti inicialmente o int para String Então eu usei o método reverso. Eu encontrei o reverso do número em String e depois converti a string de volta para int . Aqui está o programa.

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

O que isto faz é tirar o último dígito (dentro do 10s) e adicioná-lo à frente e depois dividir o número por 10, removendo o último dígito.