Comment inverser un nombre en tant que nombre entier et non en tant que chaîne?
Je suis tombé sur une question "Comment peut-on inverser un nombre en tant que nombre entier et non en tant que chaîne?" Quelqu'un pourrait-il m'aider à trouver la réponse, s'il vous plaît?.
Cela devrait le faire:
int n = 12345;
int left = n;
int rev = 0;
while(left>0)
{
r = left % 10;
rev = rev * 10 + r;
left = left / 10; //left = Math.floor(left / 10);
}
Console.WriteLine(rev);
Quelque chose comme ça?
public int ReverseInt(int num)
{
int result=0;
while (num>0)
{
result = result*10 + num%10;
num /= 10;
}
return result;
}
Comme un one-liner hackish (mise à jour: utilisé le commentaire de Benjamin pour le raccourcir):
num.ToString().Reverse().Aggregate(0, (b, x) => 10 * b + x - '0');
Une ligne un quart plus rapide:
public static int ReverseOneLiner(int num)
{
for (int result=0;; result = result * 10 + num % 10, num /= 10) if(num==0) return result;
return 42;
}
Ce n'est pas un one-liner parce que je devais inclure return 42;. Le compilateur C # ne m'a pas laissé compiler car il pensait qu'aucun chemin de code ne renvoyait de valeur.
P.S. Si vous écrivez un code comme celui-ci et qu'un collègue l'attrape, vous méritez tout ce qu'il vous fait. Être averti!
EDIT: Je me demandais de combien de temps le LINQ one-liner était plus lent, alors j’ai utilisé le code de référence suivant:
public static void Bench(Func<int,int> myFunc, int repeat)
{
var R = new System.Random();
var sw = System.Diagnostics.Stopwatch.StartNew();
for (int i = 0; i < repeat; i++)
{
var ignore = myFunc(R.Next());
}
sw.Stop();
Console.WriteLine("Operation took {0}ms", sw.ElapsedMilliseconds);
}
Résultat (10 ^ 6 nombres aléatoires dans la plage int32 positive):
While loop version:
Operation took 279ms
Linq aggregate:
Operation took 984ms
Yay! Une façon bling (Non, vraiment. J'espère que c'est davantage une question "Comment pourrais-je faire ..." et non pas quelque chose dont vous avez vraiment besoin dans la production)
public int Reverse(int number) {
return int.Parse(number.ToString().Reverse().Aggregate("", (s,c) => s+c));
}
using System;
public class DoWhileDemo {
public static void Main() {
int num;
int nextdigit;
num = 198;
Console.WriteLine("Number: " + num);
Console.Write("Number in reverse order: ");
do {
nextdigit = num % 10;
Console.Write(nextdigit);
num = num / 10;
} while(num > 0);
Console.WriteLine();
}
}
le multiplier par -1? précisez votre question s'il vous plaît ...
Vérifiez ci-dessous simple et facile -
public int reverseNumber(int Number)
{
int ReverseNumber = 0;
while(Number > 0)
{
ReverseNumber = (ReverseNumber * 10) + (Number % 10);
Number = Number / 10;
}
return ReverseNumber;
}
Référence: Numéro du programme inversé en c #
Tu ne peux pas. Puisque l'ordinateur pense en hexadécimal de toute façon, il est nécessaire que vous numérotiez le nombre au format arabe, qui est sémantiquement identique à la conversion en chaîne.
/// <summary>
/// Reverse a int using its sting representation.
/// </summary>
private int ReverseNumber(int value)
{
string textValue = value.ToString().TrimStart('-');
char[] valueChars = textValue.ToCharArray();
Array.Reverse(valueChars);
string reversedValue = new string(valueChars);
int reversedInt = int.Parse(reversedValue);
if (value < 0)
reversedInt *= -1;
return reversedInt;
}
J'ai regardé la solution suivante. Mais qu'en est-il lorsque n est négatif?
Disons n = -123456
Voici un Tweak que j'ai ajouté pour gérer les nombres négatifs, avec cette hypothèse, il menacera les engourdissements négatifs de la même manière.
int reverse = 0;
bool isNegative = false;
if (n < 0)
isNegative = true;
n = Math.Abs(n);
while (n > 0)
{
int rem = n % 10;
reverse = (reverse * 10) + rem;
n = n / 10;
}
if (isNegative)
reverse = reverse * (-1);
return reverse;
Vieux fil, mais je n'ai pas vu cette variation:
int rev(int n) {
string str = new String(n.ToString().Reverse().ToArray());
return int.Parse(str);
}
static void Main(string[] args)
{
Console.WriteLine("Please enter number");
int number = Convert.ToInt32(Console.ReadLine());
Console.WriteLine(ReverseLoop(number));
Console.WriteLine(ReverseRecursive(number));
Console.ReadLine();
}
public static int ReverseRecursive(int number)
{
int remainder = number % 10;
number = number / 10;
if (number < 1)
return remainder;
return ReverseRecursive(number) + remainder * Convert.ToInt32(Math.Pow(10, number.ToString().Length));
}
public static int ReverseLoop(int number)
{
int reversed = 0;
while (number > 0)
{
reversed = reversed * 10 + (number % 10);
number = number / 10;
}
return reversed;
}
public static void Main(string[] args)
{
int reversed = Reverse(-7360);
}
public static int Reverse(int number, int left = 0, int right = 0)
{
if (number == 0) return left + right;
return Reverse(number / 10, left * 10 + right * 10, number % 10);
}
Selon Pritam Karmakar comment, Oui, cela ne fonctionnera pas si un nombre donné a une fin nulle. Si vous passez le nombre à 150, il renverra 51 et non 051. J'avais donc écrit le code pour afficher le nombre dans l'ordre inverse de l'entrée utilisateur, veuillez vérifier ceci.
int reverseNum = 0, reminder, num;
Console.WriteLine("Enter Number to Reverse:");
int.TryParse(Console.ReadLine(), out num);
bool isZero = false;
int cnt=0;
while (num > 0)
{
reminder = num % 10;
reverseNum = (reverseNum * 10) + reminder;
num = num / 10;
if (reverseNum == 0)
isZero = true;
cnt++;
}
if (isZero)
{
Console.WriteLine(reverseNum.ToString().PadLeft(cnt, '0'));
}
else
{
Console.WriteLine(reverseNum);
}
Console.ReadKey();
la solution la plus courte:
int reverse=0;
int number = 21;
while (number > 0)
{
reverse = number % 10;
Console.Write(reverse);
number = number / 10;
}