Kan iemand mij uitleggen hoe ik een geheel getal kan omkeren zonder array of string te gebruiken. Ik heb deze code van online gekregen, maar begrijp niet echt waarom + % 10 invoeren en opnieuw delen.
while (input != 0) {
reversedNum = reversedNum * 10 + input % 10;
input = input / 10;
}
En hoe u deze voorbeeldcode kunt gebruiken om alleen oneven getallen om te keren. Voorbeeld Ik heb deze invoer 12345 gekregen, dan keert het het oneven getal om naar uitvoer 531.
Antwoord 1, autoriteit 100%
Het is mij niet duidelijk wat uw oneven nummer is.
De manier waarop deze code werkt is (het is geen Java-specifiek algoritme)
bijv.
invoer =2345
eerste keer in de while-lus
rev=5 invoer=234
tweede keer
rev=5*10+4=54 invoer=23
derde keer
rev=54*10+3 invoer=2
vierde keer
rev=543*10+2 invoer=0
Dus het omgekeerde nummer is 5432.
Als u alleen de oneven nummers in het omgekeerde nummer wilt, dan.
De code is:
while (input != 0) {
last_digit = input % 10;
if (last_digit % 2 != 0) {
reversedNum = reversedNum * 10 + last_digit;
}
input = input / 10;
}
Antwoord 2, autoriteit 99%
Java keert een int-waarde om – Principes
-
Moding (%) van de invoer int met 10 zal het meest rechtse cijfer extraheren. voorbeeld: (1234 % 10) = 4
-
Als u een geheel getal met 10 vermenigvuldigt, wordt het “naar links geduwd” en wordt een nul rechts van dat getal weergegeven, bijvoorbeeld: (5 * 10) = 50
-
Als je een geheel getal deelt door 10, wordt het meest rechtse cijfer verwijderd. (75 / 10) = 7
Java keert een int-waarde om – Pseudocode:
a. Extraheer het meest rechtse cijfer van uw invoernummer. (1234 % 10) = 4
b. Neem dat cijfer (4) en voeg deze toe aan een nieuwe omkering.
c. Vermenigvuldig omkeerednum met 10 (4 * 10) = 40, dit legt een nul rechts van uw (4) bloot.
d. Verdeel de ingang met 10, (het meest rechtse cijfer verwijderen). (1234/10) = 123
e. Herhaal bij stap A met 123
Java omgekeerd een INT-waarde – Werkcode
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;
}
Je zult nooit zoiets doen in de echte werkwereld. Het proces dat u echter gebruikt om het zonder hulp op te lossen, is wat mensen scheidt die problemen kunnen oplossen van degenen die willen, maar niet, tenzij ze lepel worden gevoed door leuke mensen op de blogoblowags.
Antwoord 3, Autoriteit 40%
simpelweg u kunt dit gebruiken
public int getReverseInt(int value) {
int resultNumber = 0;
for (int i = value; i !=0; i /= 10) {
resultNumber = resultNumber * 10 + i % 10;
}
return resultNumber;
}
U kunt deze methode gebruiken met de gegeven waarde die u wilt omkeren.
Antwoord 4, Autoriteit 29%
while (num != 0) {
rev = rev * 10 + num % 10;
num /= 10;
}
Dat is de oplossing die ik voor dit probleem heb gebruikt, en het werkt prima.
Meer details:
num % 10
Met deze verklaring krijgt u het laatste cijfer van het oorspronkelijke nummer.
num /= 10
Deze instructie verwijdert het laatste cijfer van het oorspronkelijke nummer, en daarom zijn we er zeker van dat de while-lus wordt beëindigd.
rev = rev * 10 + num % 10
Hier zal rev*10 de waarde naar links verschuiven en vervolgens het laatste cijfer van het origineel toevoegen.
Als het oorspronkelijke nummer 1258 was, en in het midden van de looptijd hebben we rev = 85, num = 12 dus:
aantal%10 = 2
rev*10 = 850
rev*10 + aantal%10 = 852
Antwoord 5, autoriteit 11%
int aa=456;
int rev=Integer.parseInt(new StringBuilder(aa+"").reverse());
Antwoord 6, autoriteit 9%
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;
}
}
Antwoord 7, autoriteit 9%
Kijk om het laatste cijfer van een willekeurig getal te krijgen, we delen het door 10, zodat we ofwel nul bereiken of een cijfer dat als laatste wordt geplaatst en als we dit continu doen, krijgen we het hele getal als een geheel getal omgekeerd.
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);
Antwoord 8, autoriteit 6%
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));
}
Hiermee wordt het omgekeerde van geheel getal geretourneerd
Antwoord 9, autoriteit 6%
Gewoon om toe te voegen, in de hoop om de oplossing vollediger te maken.
De logica door @sheki gaf al de juiste manier om een geheel getal in Java te achterhalen. Als u aanneemt dat de invoer die u gebruikt en het resultaat dat u wordt gebruikt altijd binnen het bereik [-2147483648, 2147483647], moet u veilig zijn om de codes door @Sheki te gebruiken. Anders zal het een goede gewoonte zijn om de uitzondering te vangen.
Java 8 introduceerde de methoden addexact , aftrekkenExact , Vermenigvuldigen en Tointexact . Deze methoden gooien ArithmeticExceptionbij overflow. Daarom kunt u de onderstaande implementatie gebruiken om een schone en een beetje veiliger methode te implementeren om een geheel getal om te keren. Over het algemeen kunnen we de genoemde methoden gebruiken om wiskundige berekening te doen en expliciet omgaan met overloopprobleem, wat altijd wordt aanbevolen als er een mogelijkheid is van overloop in het eigenlijke gebruik.
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;
}
Antwoord 10, Autoriteit 6%
Java-oplossing zonder de lus. Snellere reactie.
int numberToReverse;//your number
StringBuilder sb=new StringBuilder();
sb.append(numberToReverse);
sb=sb.reverse();
String intermediateString=sb.toString();
int reversedNumber=Integer.parseInt(intermediateString);
Antwoord 11, autoriteit 3%
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);
}
}
Antwoord 12, autoriteit 3%
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;
}
Antwoord 13, autoriteit 3%
Hier is een complete oplossing (retourneert 0 als nummer is overgevlogen):
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;
}
Antwoord 14
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));
}
Antwoord 15
Het is goed dat je je originele code hebt uitgeschreven. Ik heb een andere manier om dit concept van het omkeren van een geheel getal te coderen. Ik laat maximaal 10 cijfers toe. Ik ga er echter van uit dat de gebruiker geen nul zal invoeren.
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");
Antwoord 16
Zelfs als een negatief geheel getal wordt doorgegeven, geeft het een negatief geheel getal
Probeer dit…
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;
}
Antwoord 17
Dit is de kortste code om een integer
om te keren
int i=5263;
System.out.println(Integer.parseInt(new StringBuffer(String.valueOf(i) ).reverse().toString()));
Antwoord 18
123 verwijst naar 321, wat kan worden berekend als 3*(10^2)+2*(10^1)+1
Er worden twee functies gebruikt om te berekenen (10^N). De eerste functie berekent de waarde van N. De tweede functie berekent de waarde voor tien tot macht 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);
}
}
Antwoord 19
Als het de bedoeling is om geen arrays of strings te gebruiken, moet het omkeren van een geheel getal worden gedaan door de cijfers van een getal vanaf het einde een voor een te lezen. Onderstaande uitleg wordt in detail gegeven om de beginner te helpen.
pseudocode :
- laten we beginnen met reversed_number = 0 en een waarde voor original_number die moet worden teruggedraaid.
- the_last_digit = original_number % 10 (d.w.z. de herinnering na delen door 10)
- original_number = original_number/10 (aangezien we het laatste cijfer al hebben, verwijder het laatste cijfer van het originele_nummer)
- reversed_number = reversed_number * 10 + last_digit (vermenigvuldig het reversed_number met 10, om het laatste_cijfer eraan toe te voegen)
- herhaal stap 2 t/m 4, totdat het originele_nummer 0 wordt. Als original_number = 0, zou reversed_number het omgekeerde van het originele_nummer hebben.
Meer informatie over stap 4: Als u een cijfer per keer krijgt en u wordt gevraagd dit aan het einde van een cijfer toe te voegen, hoe zou u dat dan doen – door het oorspronkelijke cijfer één plaats naar links te verplaatsen, zodat om het nieuwe cijfer op te nemen. Als getal 23 234 moet worden, vermenigvuldig je 23 met 10 en tel je er 4 bij op.
234 = 23×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;
}
Antwoord 20
Het is een achterhaalde vraag, maar als referentie voor anderen
Allereerst moet reversedNum worden geïnitialiseerd op 0;
invoer%10 wordt gebruikt om het laatste cijfer van invoer te krijgen
input/10 wordt gebruikt om het laatste cijfer van de invoer te verwijderen, dat u hebt toegevoegd aan het reversedNum
Laten we zeggen dat de invoer 135 was
135 % 10 is 5
Aangezien het omgekeerde nummer is geïnitialiseerd op 0
nu omgekeerdNum wordt 5
Dan komen we van 5 af door 135 te delen door 10
Nu is de invoer slechts 13
Uw code doorloopt deze stappen totdat alle cijfers zijn toegevoegd aan het omgekeerde nummer of met andere woorden totdat de invoer 0 wordt.
Antwoord 21
while (input != 0) {
reversedNum = reversedNum * 10 + input % 10;
input = input / 10;
}
laat een getal 168 zijn,
+ invoer % 10 retourneert het laatste cijfer als herinnering, dwz 8 maar de volgende keer zou het 6 moeten retourneren, daarom moet het getal worden teruggebracht tot 16 van 168, als 168 door 10 wordt gedeeld, resulteert dit in 16 in plaats van 16,8 omdat variabele invoer geacht wordt een geheel getal te zijn in bovenstaand programma.
Antwoord 22
Als je een getal zoals 1234 wilt omkeren en je wilt dit getal terugdraaien zodat het eruitziet als 4321. Initialiseer allereerst 3 variabelen int org ; int omgekeerd = 0; en int herinnering;
zet dan je logica zoals
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);
}
Antwoord 23
Een methode om de grootste macht van tien kleiner of gelijk aan een geheel getal te krijgen: (in recursie)
public static int powerOfTen(int n) {
if ( n < 10)
return 1;
else
return 10 * powerOfTen(n/10);
}
De methode om het werkelijke gehele getal om te keren:(in recursie)
public static int reverseInteger(int i) {
if (i / 10 < 1)
return i ;
else
return i%10*powerOfTen(i) + reverseInteger(i/10);
}
Antwoord 24
Je kunt recursie gebruiken om dit op te lossen.
Verkrijg eerst de lengte van een geheel getal door de volgende recursieve functie te gebruiken.
int Length(int num,int count){
if(num==0){
return count;
}
else{
count++;
return Lenght(num/10,count);
}
}
en dan kun je de rest van een getal eenvoudig vermenigvuldigen met 10^(Lengte van geheel getal – 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;
}
De hele broncode:
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();
}
}
Antwoord 25
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;
}
// De bovenstaande code werkt ook voor negatieve nummers
Antwoord 26
Integer omkeren
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);
Antwoord 27
public static int reverseInt(int i) {
int reservedInt = 0;
try{
String s = String.valueOf(i);
String reversed = reverseWithStringBuilder(s);
reservedInt = Integer.parseInt(reversed);
}catch (NumberFormatException e){
System.out.println("exception caught was " + e.getMessage());
}
return reservedInt;
}
public static String reverseWithStringBuilder(String str) {
System.out.println(str);
StringBuilder sb = new StringBuilder(str);
StringBuilder reversed = sb.reverse();
return reversed.toString();
}
Antwoord 28
public static int reverse(int x) {
int tmp = x;
int oct = 0;
int res = 0;
while (true) {
oct = tmp % 10;
tmp = tmp / 10;
res = (res+oct)*10;
if ((tmp/10) == 0) {
res = res+tmp;
return res;
}
}
}
Antwoord 29
Scanner input = new Scanner(System.in);
System.out.print("Enter number :");
int num = input.nextInt();
System.out.print("Reverse number :");
int value;
while( num > 0){
value = num % 10;
num /= 10;
System.out.print(value); //value = Reverse
}
Antwoord 30
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;
}