Java inverte un valore int senza utilizzare la matrice

Qualcuno può spiegarmi come invertire un intero senza usare array o String. Ho ricevuto questo codice da online, ma in realtà non capisco perché + input% 10 e dividi di nuovo.

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

E come usare questo codice di esempio per invertire solo il numero dispari. Esempio Ho ottenuto questo input 12345, quindi invertirà il numero dispari per l’output 531.

Non sono sicuro del tuo numero dispari. Il modo in cui funziona questo codice è (non è un algoritmo specifico di Java) Ad esempio. input = 2345 prima volta nel ciclo while giro = 5 input = 234 secondi volta giro = 5 * 10 + 4 = 54 input = 23 volta terza giro = 54 * 10 + 3 input = 2 quarto tempo giro = 543 * 10 + 2 input = 0

Quindi il numero invertito è 5432. Se vuoi solo solo i numeri dispari nel numero invertito allora. Il codice è:

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

Java inverte un valore int – Principi

  1. Modding (%) l’input int di 10 estrarrà la cifra più a destra. esempio: (1234% 10) = 4

  2. Moltiplicando un numero intero di 10 si “spinge a sinistra” esponendo uno zero alla destra di quel numero, ad esempio: (5 * 10) = 50

  3. Dividendo un numero intero di 10 si rimuoverà la cifra più a destra. (75/10) = 7

Java inverte un valore int – Pseudocodice:

un. Estrai la cifra più a destra del tuo numero di input. (1234% 10) = 4

b. Prendi quella cifra (4) e aggiungila a una nuova rovesciata.

c. Moltiplicati indietroNum per 10 (4 * 10) = 40, questo espone uno zero alla destra del tuo (4).

d. Dividere l’input per 10, (rimuovendo la cifra più a destra). (1234/10) = 123

e. Ripeti al passaggio a con 123

Java inverte un valore int – Codice di lavoro

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

Non farai mai nulla di simile nel mondo reale del lavoro. Tuttavia, il processo mediante il quale si utilizza per risolverlo senza aiuto è ciò che separa le persone che possono risolvere i problemi da quelli che vogliono, ma non possono farlo a meno che non siano alimentati da persone simpatiche sul blogblog.

Semplicemente puoi usare questo

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

Puoi usare questo metodo con un dato valore che vuoi invertire.

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

Questa è la soluzione che ho usato per questo problema e funziona perfettamente. Più dettagli:

 num % 10 

Questa affermazione ti porterà l’ultima cifra dal numero originale.

 num /= 10 

Questa affermazione eliminerà l’ultima cifra dal numero originale, e quindi siamo sicuri che il ciclo terminerà.

 rev = rev*10 + num % 10 

Qui rev * 10 sposta il valore a sinistra e quindi aggiunge l’ultima cifra dell’originale.
Se il numero originale era 1258, e nel mezzo del tempo di esecuzione abbiamo rev = 85, num = 12 quindi:
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)); } 

Ciò restituirà l’inverso del numero intero

Solo per aggiungere, nella speranza di rendere la soluzione più completa.

La logica di @sheki ha già dato il modo corretto di invertire un intero in Java. Se si assume che l’input che si utilizza e il risultato che si ottiene rientri sempre nell’intervallo [-2147483648, 2147483647] , si dovrebbe essere sicuri di utilizzare i codici da @sheki. Altrimenti, sarà una buona pratica catturare l’eccezione.

Java 8 ha introdotto i metodi addExact , sottrarreExact , multiplyExact e toIntExact . Questi metodi genereranno ArithmeticException caso di overflow. Pertanto, è ansible utilizzare l’implementazione di seguito per implementare un metodo pulito e un po ‘più sicuro per invertire un numero intero. In generale, possiamo utilizzare i metodi menzionati per eseguire calcoli matematici e gestire esplicitamente il problema dell’overflow, che è sempre consigliato se esiste una possibilità di overflow nell’utilizzo effettivo.

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

Soluzione Java senza loop. Risposta più veloce

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

È bene che tu abbia scritto il tuo codice originale. Ho un altro modo per codificare questo concetto di invertire un numero intero. Permetterò solo fino a 10 cifre. Tuttavia, supporrò che l’utente non inserisse uno 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"); 

Anche se viene passato un intero negativo, questo darà il numero intero negativo Prova questo …

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

Questo è il codice più breve per invertire un integer

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

123 mappe a 321, che possono essere calcolate come 3 * (10 ^ 2) + 2 * (10 ^ 1) +1 Due funzioni sono utilizzate per calcolare (10 ^ N). La prima funzione calcola il valore di N. La seconda funzione calcola il valore di dieci per alimentare 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 l’idea non è quella di utilizzare matrici o stringhe, l’inversione di un intero deve essere effettuata leggendo le cifre di un numero dalla fine uno alla volta. Di seguito la spiegazione è fornita in dettaglio per aiutare il principiante.

pseudocodice:

  1. Iniziamo con reversed_number = 0 e qualche valore per original_number che deve essere invertito.
  2. the_last_digit = original_number% 10 (cioè, il promemoria dopo aver diviso per 10)
  3. original_number = original_number / 10 (poiché abbiamo già l’ultima cifra, rimuovere l’ultima cifra dal numero_originale)
  4. reversed_number = numero_invertito * 10 + last_digit (moltiplica il numero inverso con 10, in modo da aggiungere l’ultima cifra a esso)
  5. ripetere i passaggi da 2 a 4, finché il numero_originale diventa 0. Quando numero_originale = 0, il numero_inverso avrebbe il contrario del numero_originale.

Maggiori informazioni sul punto 4: Se ti viene fornita una cifra alla volta e ti viene chiesto di aggiungerla alla fine di un numero, come faresti, spostando il numero originale di un posto a sinistra in modo da nuova cifra Se il numero 23 deve diventare 234, moltiplichi 23 con 10 e poi aggiungi 4.

234 = 23×10 + 4;

Codice:

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

È una domanda obsoleta, ma come riferimento per gli altri. Prima di tutto, reverseNum deve essere inizializzato su 0;

l’input% 10 viene utilizzato per ottenere l’ultima cifra dall’input

input / 10 viene utilizzato per eliminare l’ultima cifra dall’input, che è stata aggiunta a reversedNum

Diciamo che l’input era 135

135% 10 è 5 Poiché il numero invertito è stato inizializzato a 0 ora invertitoNum sarà 5

Quindi ci sbarazziamo di 5 dividendo 135 per 10

Ora l’input sarà solo 13

Il codice scorre attraverso questi passaggi fino a quando tutte le cifre vengono aggiunte al numero invertito o in altre parole finché l’input diventa 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; } 

lascia che un numero sia 168,
+ input% 10 restituisce l’ultima cifra come promemoria, ad esempio 8 ma la prossima volta dovrebbe restituire 6, quindi il numero deve essere ridotto a 16 da 168, come dividere 168 per 10 che risulta 16 anziché 16.8 come input variabile dovrebbe essere di tipo intero nel programma di cui sopra.

Se vuoi invertire qualsiasi numero come 1234 e vuoi ribaltare questo numero per farlo sembrare 4321. Prima di tutto, inizializza 3 variabili int org; int reverse = 0; e int promemoria; quindi metti la tua logica come

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

Un metodo per ottenere il massimo potere di dieci più piccolo o uguale a un intero: (in ricorsione)

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

Il metodo per invertire l'intero effettivo: (in ricorsione)

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

Puoi usare la ricorsione per risolvere questo problema.

per prima cosa prendi la lunghezza di un numero intero usando la funzione ricorsiva successiva.

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

e quindi puoi semplicemente moltiplicare il resto di un numero per 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; } 

L’intero codice sorgente:

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

// Il codice sopra funzionerà anche per i numeri negativi

Si veda per ottenere l’ultima cifra di qualsiasi numero divisa per 10 in modo da ottenere zero o una cifra che è posta all’ultimo e quando lo facciamo continuamente otteniamo l’intero numero come numero intero invertito.

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

Ho usato String e ho convertito inizialmente l’ int in String Poi ho usato il metodo inverso. Ho trovato il contrario del numero in String e poi ho riconvertito la stringa in int . Ecco il programma.

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

Quello che fa è, striscia l’ultima cifra (entro la posizione dei 10 secondi) e aggiungila davanti e poi divide il numero per 10, rimuovendo l’ultima cifra.