Java inverse une valeur int sans utiliser array
Quelqu'un peut-il m'expliquer comment inverser un entier sans utiliser de tableau ou de chaîne. J'ai eu ce code en ligne, mais je ne comprends pas vraiment pourquoi + input % 10 et diviser à nouveau.
while (input != 0) {
reversedNum = reversedNum * 10 + input % 10;
input = input / 10;
}
Et comment utiliser cet exemple de code pour inverser seulement nombre impair. Exemple j'ai eu cette entrée 12345, alors il inversera le nombre impair à la sortie 531.
29 réponses
Je ne suis pas clair sur votre Nombre Impair. La façon dont ce code fonctionne est (ce n'est pas un algorithme spécifique à Java) Par exemple. entrée =2345 première fois dans la boucle while rev=5 entrée=234 deuxième fois rev=5*10+4=54 entrée=23 troisième fois rev=54*10+3 Entrée = 2 quatrième temps rev=543*10+2 entrée=0
Donc le nombre inversé est 5432. Si vous voulez juste que les nombres impairs dans le nombre inversé alors. Le code est:
while (input != 0) {
last_digit = input % 10;
if (last_digit % 2 != 0) {
reversedNum = reversedNum * 10 + last_digit;
}
input = input / 10;
}
Java inverse une valeur int - Principes
Modding ( % ) l'entrée int par 10 va extraire le chiffre le plus à droite. exemple: (1234 % 10) = 4
Multiplier un entier par 10 le "poussera à gauche" exposant un zéro à la droite de ce nombre, exemple: (5 * 10) = 50
Diviser un entier par 10 supprimera le chiffre le plus à droite. (75 / 10) = 7
Java inverse une valeur int - Pseudo-code:
A. Extrait sur le chiffre le plus à droite de votre numéro d'entrée. (1234 % 10) = 4
B. prenez ce chiffre (4) et ajoutez - le dans un nouveau reversedNum.
C. multipliez reversedNum par 10 (4 * 10) = 40, cela expose un zéro à droite de votre (4).
D. divisez l'entrée par 10 (en supprimant le chiffre le plus à droite). (1234 / 10) = 123
E. répéter à l'étape a avec 123
Java inverse un code de travail de valeur 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;
}
Vous ne ferez jamais quelque chose comme ça dans le réel travail-monde. Cependant, le processus par lequel vous utilisez pour le résoudre sans aide est ce qui sépare les gens qui peuvent résoudre des problèmes de ceux qui veulent, mais ne peuvent pas à moins qu'ils ne soient nourris à la cuillère par des gens gentils sur les blogoblags.
Vous pouvez simplement utiliser ceci
public int getReverseInt(int value) {
int resultNumber = 0;
for (int i = value; i !=0; i /= 10) {
resultNumber = resultNumber * 10 + i % 10;
}
return resultNumber;
}
Vous pouvez utiliser cette méthode avec une valeur donnée que vous voulez inverser.
while (num != 0) {
rev = rev*10 + num % 10;
num /= 10;
}
C'est la solution que j'ai utilisée pour ce problème, et cela fonctionne bien. Plus de détails:
num % 10
Cette déclaration vous donnera le dernier chiffre du numéro d'origine.
num /= 10
Cette instruction éliminera le dernier chiffre du nombre d'origine, et nous sommes donc sûrs que la boucle while se terminera.
rev = rev*10 + num % 10
Ici rev * 10 va décaler la valeur de gauche, puis ajouter le dernier chiffre de l'original.
Si le numéro d'origine était 1258, et au milieu de la course temps, nous avons rev = 85, num = 12 donc:
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));
}
Cela renverra l'inverse de l'entier
Juste pour ajouter, dans l'espoir de rendre la solution plus complète.
La logique de @sheki a déjà donné la bonne façon d'inverser un entier en Java. Si vous supposez que l'entrée que vous utilisez et le résultat que vous obtenez tombent toujours dans la plage [-2147483648, 2147483647], vous devriez être sûr d'utiliser les codes par @sheki. Sinon, ce sera une bonne pratique pour attraper l'exception.
Java 8 introduit les méthodes addExact, subtractExact, multiplyExact et toIntExact. Ces méthodes jetteront ArithmeticException en cas de débordement. Par conséquent, vous pouvez utiliser l'implémentation ci-dessous pour implémenter une méthode propre et un peu plus sûre pour inverser un entier. Généralement, nous pouvons utiliser les méthodes mentionnées pour faire des calculs mathématiques et gérer explicitement le problème de débordement, ce qui est toujours recommandé s'il y a une possibilité de débordement dans l'utilisation réelle.
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()));
Solution Java sans la boucle. Réponse plus rapide.
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));
}
C'est bien que vous ayez écrit votre code original. J'ai une autre façon de coder ce concept d'inversion d'un entier. Je vais seulement autoriser jusqu'à 10 chiffres. Cependant, je vais faire l'hypothèse que l'utilisateur n'entrera pas un zéro.
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");
Même si un entier négatif est passé, il donnera l'entier négatif Essayez Ceci...
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;
}
C'est le plus court code pour inverser un integer
int i=5263;
System.out.println(Integer.parseInt(new StringBuffer(String.valueOf(i) ).reverse().toString()));
123 cartes à 321, qui peut être calculé comme 3*(10^2)+2*(10^1)+1 Deux fonctions sont utilisées pour calculer (10^n). La première fonction calcule la valeur de N. La seconde fonction calcule la valeur de dix pour alimenter 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);
}
}
Si l'idée n'est pas d'utiliser des tableaux ou des chaînes, inverser un entier doit être fait en lisant les chiffres d'un nombre de la fin un à la fois. L'explication ci-dessous est fournie en détail pour aider le novice.
Pseudo-code :
- commençons par reversed_number = 0 et une valeur pour original_number qui doit être inversée.
- the_last_digit = original_number % 10 (c'est-à-dire le rappel après avoir divisé par 10)
- original_number = original_number / 10 (puisque nous vous avez déjà le dernier chiffre, supprimez le dernier chiffre du numéro d'origine)
- reversed_number = reversed_number * 10 + last_digit (multipliez le reversed_number par 10, de manière à y ajouter le last_digit)
- Répétez les étapes 2 à 4, jusqu'à ce que le numéro d'origine devienne 0. Lorsque original_number = 0, reversed_number aurait l'inverse du original_number.
Plus d'informations sur l'étape 4: Si vous êtes fourni avec un chiffre à la fois, et demandé de l'ajouter à la fin d'un nombre, comment le feriez-vous-en déplaçant l'endroit numéro un d'origine vers la gauche de manière à accueillir le nouveau chiffre. Si le nombre 23 doit devenir 234, vous multipliez 23 avec 10, puis ajoutez 4.
234 = 23x10 + 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;
}
C'est une question obsolète, mais comme référence pour les autres Tout d'abord reversedNum doit être initialisé à 0;
L'Entrée % 10 est utilisée pour obtenir le dernier chiffre de l'entrée
Input / 10 est utilisé pour éliminer le dernier chiffre de input, que vous avez ajouté au reversedNum
Disons que l'entrée était 135
135% 10 vaut 5 Depuis le nombre inversé a été initialisé à 0 maintenant reversedNum sera 5
Puis nous nous débarrassons de 5 en divisant 135 par 10
Maintenant l'entrée sera juste 13
Votre code parcourt ces étapes jusqu'à ce que tous les chiffres soient ajoutés au nombre inversé ou, en d'autres termes, jusqu'à ce que l'entrée devienne 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;
}
Soit un nombre 168,
+ input % 10 renvoie le dernier chiffre comme rappel,c'est-à-dire 8 mais la prochaine fois, il devrait renvoyer 6, donc le nombre doit être réduit à 16 de 168, comme diviser 168 par 10 qui se traduit par 16 au lieu de 16.8 comme entrée variable est supposée être de type entier dans le programme ci-dessus.
Si vous voulez inverser un nombre comme 1234 et que vous voulez inverser ce nombre pour qu'il ressemble à 4321. Tout d'abord, initialisez 3 variables int org; int reverse = 0; et int reminder ; ensuite, mettez votre logique comme
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);
}
Une méthode pour obtenir la plus grande puissance de dix inférieure ou égale à un entier: (en récursivité)
public static int powerOfTen(int n) {
if ( n < 10)
return 1;
else
return 10 * powerOfTen(n/10);
}
La méthode pour inverser l'entier réel: (en récursivité)
public static int reverseInteger(int i) {
if (i / 10 < 1)
return i ;
else
return i%10*powerOfTen(i) + reverseInteger(i/10);
}
Vous pouvez utiliser la récursivité pour résoudre ce problème.
Obtenez D'abord la longueur d'un nombre entier en utilisant la fonction récursive suivante.
int Length(int num,int count){
if(num==0){
return count;
}
else{
count++;
return Lenght(num/10,count);
}
}
Et puis vous pouvez simplement multiplier le reste d'un nombre par 10^(Longueur d'entier-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;
}
Le Code Source entier:
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;
}
/ / le code ci-dessus fonctionnera aussi pour les nombres négatifs
Voir pour obtenir le dernier chiffre de n'importe quel nombre, nous le divisons par 10, donc nous obtenons zéro ou un chiffre qui est placé sur le dernier et quand nous le faisons continuellement, nous obtenons le nombre entier comme un entier inversé.
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);
Inverser entier
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);
}
}
J'ai utilisé String et j'ai initialement converti le int en String.Ensuite, j'ai utilisé la méthode inverse. J'ai trouvé l'inverse du nombre dans String puis j'ai converti la chaîne en int. Voici le programme.
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();
}
Ce que cela fait est, dépouiller le dernier chiffre (dans la place 10s) et l'ajouter à l'avant, puis divise le nombre par 10, en supprimant le dernier chiffre.