Round any n-digit number to (n-1) zero-digits

Sorry hard to formulate.

I need to round like this:

12 -> 10
152 -> 200
1538 -> 2000
25000 -> 30000
etc. 

Twisting my head, but can't see how to make this. Must work for any n number of digits. Anyone got an elegant method for it?

c# or开发者_运维百科 vb.net

---

How about this:

        double num = 152;

        int pow = (int)Math.Log10(num);

        int factor = (int)Math.Pow(10, pow);

        double temp = num / factor;

        double result = Math.Round(temp) * factor;

---

I think you should try with something like this:

public int Round( int number)
{
    int power = number.ToString().Length - 1;
    int sz = Math.Pow(10, power);

    int rounded = (int)Math.Round( number / sz );

    return rounded * sz;
}

The idea is to get the size of the nearest 10 power, available by the length of the number expressed as a string. Then divide the number by that power, leaving it like 1,2 and then round it using the Math.Round method and restore the size by remultiplying it to the power.

Much like the previous answer...

---

I would do it this way:

double d = 25000;
int power = d.ToString().Length - 1;
double multipler = Math.Pow(10,power);
d = Math.Round(d / multipler) * multipler;
Console.WriteLine(d);

---

One of the way could be

1. Convert the number to Decimal
2. Divide it by 10^(n-1) (where n is number of digits)
3. Now use round function (Decimal.Round)
4. Multiply again by 10^(n-1)

---

Divide the number by 10n and round the result, then multiply the result back with 10n;

int MyRound(int num)
{
    double divisor = Math.Pow(10, num.ToString().Length - 1);
    return (int)(Math.Round(num / divisor, MidpointRounding.AwayFromZero) * divisor);
}

Note that we should use MidpointRounding.AwayFromZero when rounding because of the default banker's rounding.

---

int MakeOneSigFig(int value)
{
    int neg = 1;
    if(value <= 10 && value >= -10) { return value; }
    if(value == int.MinValue) { value = int.MaxValue; neg = -1; }
    if(value < 0) { value = -value; neg = -1; }

    int mult = 10; // start at 10 because we've got 'firstDigit = value / 10' below
    while(value > 99) { value /= 10; mult *= 10; }
    int firstDigit = value / 10;
    if(value % 10 >= 5) firstDigit++;
    return neg * firstDigit * mult;
}

This is equivalent to MidpointRounding.AwayFromZero. This method doesn't do any double math or string conversions. If you didn't want to loop, you could replace that with the if block below. That would be more efficient, but more code and not quite as easy to read.

if(value < 100) { mult = 10; }
else if(value < 1000) { mult = 100; value /= 10; }
else if(value < 10000) { mult = 1000; value /= 100; }
else if(value < 100000) { mult = 10000; value /= 1000; }
// etc.