¿Cómo redondear un número entero al primer centenar?

¡No lo sé, mi nomenclatura es correcta! De todos modos, estos son los enteros que tengo, por ejemplo:

76 121 9660 

Y me gustaría redondearlos a cerca de cien, como deben convertirse en:

 100 100 9700 

¿Cómo puedo hacerlo más rápido en C #? Pienso en un algoritmo, pero tal vez hay algunas utilidades en C #?

Pruebe el método Math.Round . Así es cómo:

 Math.Round(76d / 100d, 0) * 100; Math.Round(121d / 100d, 0) * 100; Math.Round(9660d / 100d, 0) * 100; 

Escribí un método de extensión simple para generalizar este tipo de redondeo hace un tiempo:

 public static class MathExtensions { public static int Round(this int i, int nearest) { if (nearest < = 0 || nearest % 10 != 0) throw new ArgumentOutOfRangeException("nearest", "Must round to a positive multiple of 10"); return (i + 5 * nearest / 10) / nearest * nearest; } } 

Aprovecha la división entera para encontrar el redondeo más cercano.

Ejemplo de uso:

 int example = 152; Console.WriteLine(example.Round(100)); // round to the nearest 100 Console.WriteLine(example.Round(10)); // round to the nearest 10 

Y en tu ejemplo:

 Console.WriteLine(76.Round(100)); // 100 Console.WriteLine(121.Round(100)); // 100 Console.WriteLine(9660.Round(100)); // 9700 

Prueba esta expresión:

 (n + 50) / 100 * 100 

Solo una adición a la respuesta aceptada de @krizzzn …

Tenga en cuenta que lo siguiente devolverá 0:

 Math.Round(50d / 100d, 0) * 100; 

Considere usar lo siguiente y haga que devuelva 100 en su lugar:

 Math.Round(50d / 100d, 0, MidpointRounding.AwayFromZero) * 100; 

Dependiendo de lo que esté haciendo, usar decimales podría ser una mejor opción (observe la m ):

 Math.Round(50m / 100m, 0, MidpointRounding.AwayFromZero) * 100m; 

Sé que es un viejo tema. Escribí un nuevo método. Espero que esto sea útil para alguien.

  public static double Round(this float value, int precision) { if (precision < -4 && precision > 15) throw new ArgumentOutOfRangeException("precision", "Must be and integer between -4 and 15"); if (precision >= 0) return Math.Round(value, precision); else { precision = (int)Math.Pow(10, Math.Abs(precision)); value = value + (5 * precision / 10); return Math.Round(value - (value % precision), 0); } } 

Ejemplo:

 float value = F6666.677777; Console.Write(value.Round(2)) // = 6666.68 Console.Write(value.Round(0)) // = 6667 Console.Write(value.Round(-2)) // = 6700 

Hola, escribo esta extensión, esta obtiene los próximos cien por cada número que pases

 ///  /// this extension gets the next hunfìdred for any number you whant ///  /// numeber to rounded /// the next hundred number ///  /// eg.: /// i = 21 gets 100 /// i = 121 gets 200 /// i = 200 gets 300 /// i = 1211 gets 1300 /// i = -108 gets -200 ///  public static int RoundToNextHundred(this int i) { return i += (100 * Math.Sign(i) - i % 100); //use this line below if you want RoundHundred not NEXT //return i % 100 == byte.MinValue? i : i += (100 * Math.Sign(i) - i % 100); } //and for answer at title point use this algoritm var closeHundred = Math.Round(number / 100D)*100; //and here the extension method if you prefer ///  /// this extension gets the close hundred for any number you whant ///  /// number to be rounded /// the close hundred number ///  /// eg.: /// number = 21 gets 0 /// number = 149 gets 100 /// number = 151 gets 200 /// number = -149 gets -100 /// number = -151 gets -200 ///  public static int RoundCloseHundred(this int number) { return (int)Math.Round(number / 100D) * 100; } 
 int num = 9660; int remainder = num % 100; Console.WriteLine(remainder < 50 ? num - remainder : num + (100 -remainder)); 

Nota: No lo he probado a fondo.

Si solo quieres redondear números enteros (como lo hizo OP en realidad), entonces puedes recurrir a esta solución:

 public static class MathExtensions { public static int RoundUpTo(this int number, int nearest) { if (nearest < 10 || nearest % 10 != 0) throw new ArgumentOutOfRangeException(nameof(nearest), $"{nameof(nearest)} must be a positive multiple of 10, but you specified {nearest}."); int modulo = number % nearest; return modulo == 0 ? number : modulo > 0 ? number + (nearest - modulo) : number - modulo; } } 

Si desea realizar un redondeo de coma flotante (o decimal), recurra a las respuestas de @krizzzn y @Jim Aho.