Java inverser une valeur int sans utiliser de tableau
Quelqu'un peut-il m'expliquer comment inverser un entier sans utiliser de tableau ou de chaîne. J'ai obtenu ce code en ligne, mais je ne comprends pas vraiment pourquoi + entrez% 10 et divisez à nouveau.
while (input != 0) {
reversedNum = reversedNum * 10 + input % 10;
input = input / 10;
}
Et comment utiliser cet exemple de code pour inverser uniquement les nombres impairs. Exemple J'ai obtenu cette entrée 12345, puis elle inversera le nombre impair pour produire 531.
Je ne suis pas sûr de votre nombre impair. Le fonctionnement de ce code est (ce n'est pas un Java) Par exemple: entrée = 2345 première fois dans la boucle while rev = 5 entrée = 234 seconde fois rev = 5 * 10 + 4 = 54 entrée = 23 troisième tour de temps = 54 * 10 + 3 entrée = 2 quatrième temps de tour = 543 * 10 + 2 entrée = 0
Donc, le nombre inversé est 5432. Si vous ne voulez 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 extraira le chiffre le plus à droite. exemple: (1234% 10) = 4
La multiplication d'un entier par 10 "poussera vers la gauche" exposant un zéro à droite de ce nombre, exemple: (5 * 10) = 50
La division d'un entier par 10 supprimera le chiffre le plus à droite. (75/10) = 7
Java inverse une valeur int - Pseudocode:
une. Extrayez 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 numéro inversé.
c. Multipliez Num inversé par 10 (4 * 10) = 40, cela expose un zéro à droite de votre (4).
ré. Divisez l'entrée par 10 (en supprimant le chiffre le plus à droite). (1234/10) = 123
e. Répétez à l'étape a avec 123
Java inverse une valeur int - Code de travail
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 rien de tel dans le monde du travail réel. Cependant, le processus par lequel vous utilisez pour le résoudre sans aide est ce qui sépare les personnes qui peuvent résoudre les problèmes de celles qui le souhaitent, mais ne peuvent pas sauf si elles sont nourries à la cuillère par des Nice 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 souhaitez 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 très bien. Plus de détails:
num % 10
Cette déclaration vous obtiendra le dernier chiffre du numéro d'origine.
num /= 10
Cette instruction éliminera le dernier chiffre du numéro d'origine, et donc nous sommes sûrs que la boucle while se terminera.
rev = rev * 10 + num % 10
Ici, rev * 10 décale la valeur vers la gauche, puis ajoute le dernier chiffre de l'original.
Si le nombre d'origine était 1258, et au milieu du temps d'exécution, nous avons rev = 85, num = 12 donc:
num% 10 = 2
rev * 10 = 850
rev * 10 + num% 10 = 852
Voir pour obtenir le dernier chiffre de n'importe quel nombre, nous le divisons par 10, donc nous atteignons zéro ou un chiffre qui est placé sur le dernier et lorsque nous le faisons en continu, nous obtenons le nombre entier sous forme d'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);
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;
}
}
int aa=456;
int rev=Integer.parseInt(new StringBuilder(aa+"").reverse());
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 se situent toujours dans la plage [-2147483648, 2147483647], vous devriez être sûr d'utiliser les codes de @sheki. Sinon, ce sera une bonne pratique pour attraper l'exception.
Java 8 a introduit les méthodes addExact , subtractExact , multiplyExact et toIntExact . Ces méthodes lanceront 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. En règle générale, nous pouvons utiliser les méthodes mentionnées pour effectuer des calculs mathématiques et gérer explicitement le problème de débordement, ce qui est toujours recommandé s'il existe un risque 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;
}
Solution Java sans 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);
Voici une solution complète (retourne 0 si le nombre est survolé):
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;
}
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;
}
Entier inversé
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);
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);
}
}
Vous pouvez utiliser la récursivité pour résoudre ce problème.
obtenir 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);
}
}
puis vous pouvez simplement multiplier le reste d'un nombre par 10 ^ (Longueur de l'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();
}
}
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 inverse = 0; et rappel int; puis 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);
}
while (input != 0) {
reversedNum = reversedNum * 10 + input % 10;
input = input / 10;
}
qu'un nombre soit 168,
+ l'entrée% 10 renvoie le dernier chiffre comme rappel, c.-à-d. 8 mais la prochaine fois il devrait retourner 6, par conséquent le nombre doit être réduit à 16 de 168, comme diviser 168 par 10 qui donne 16 au lieu de 16,8 car l'entrée variable est censé être de type entier dans le programme ci-dessus.
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 également pour les nombres négatifs
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));
}
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.
pseudocode:
- permet de commencer avec reverse_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 la division par 10)
- original_number = original_number/10 (puisque nous avons déjà le dernier chiffre, supprimez le dernier chiffre de l'original_number)
- numéro_inversé = numéro_inversé * 10 + dernier_chiffre (multipliez le numéro_inversé par 10, de manière à y ajouter le dernier_digit)
- répétez les étapes 2 à 4, jusqu'à ce que le numéro d'origine devienne 0. Lorsque numéro_original = 0, le numéro_inversé aurait le contraire du numéro_original.
Plus d'informations sur l'étape 4: si vous recevez un chiffre à la fois et que vous êtes invité à l'ajouter à la fin d'un numéro, comment feriez-vous - en déplaçant le numéro d'origine à la première place vers la gauche afin de nouveau chiffre. Si le nombre 23 doit devenir 234, vous multipliez 23 par 10, puis ajoutez 4.
234 = 23 x 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;
}
C'est bien que vous ayez écrit votre code d'origine. J'ai une autre façon de coder ce concept d'inversion d'un entier. Je vais autoriser jusqu'à 10 chiffres. Cependant, je vais faire l'hypothèse que l'utilisateur n'entrera pas de 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");
C'est une question obsolète, mais comme référence pour les autres Tout d'abord, inverséNum 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 supprimer le dernier chiffre de l'entrée, que vous avez ajouté au Num inversé
Disons que l'entrée était de 135
135% 10 est 5 Puisque le nombre inversé a été initialisé à 0 maintenant inversé, le nombre sera 5
On se débarrasse ensuite de 5 en divisant 135 par 10
Maintenant, l'entrée ne sera que de 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.
Une méthode pour obtenir la plus grande puissance de dix plus petite 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);
}
C'est le code le plus court pour inverser un integer
int i=5263;
System.out.println(Integer.parseInt(new StringBuffer(String.valueOf(i) ).reverse().toString()));
123 correspond à 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 deuxième 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);
}
}
Même si un entier négatif est passé, cela 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;
}