Dahili algoritma En yakın 10 aralığa yuvarlamak için .Net algoritması

Question

C# cinsinden herhangi bir değer 10 aralığa nasıl ayarlanır? Ben 11 varsa Örneğin, ben 136 varsa, o zaman ben el

return ((int)(number/10)) * 10; 

tarafından bunu kolayca yapabilirsiniz 140.

dönmek istiyorum, bu 10 dönmek istiyorum Ama arıyorum Bu işi yapmak için bir yerleşik algoritma için Math.Round() gibi bir şey. El ile yapmak istemememin sebebi, yukarıdaki gibi basit bir şey için bile projelerimin her yerinde aynı veya benzer bir kod yazmak istemem.

Answer 1

Sınıf kütüphanesinde bunu yapacak yerleşik bir işlev yok. En yakın olanı System.Math.Round() olup, yalnızca Ondalık ve Çift tür sayıları en yakın tamsayı değerine yuvarlamak içindir. Ancak, .NET 3.5 ile çalışıyorsanız, deyiminizi çok daha temiz bir şekilde kullanmanıza olanak tanıyan bir uzantı yöntemiyle tamamlayabilirsiniz.

public static class ExtensionMethods 
{ 
    public static int RoundOff (this int i) 
    { 
     return ((int)Math.Round(i/10.0)) * 10; 
    } 
} 

int roundedNumber = 236.RoundOff(); // returns 240 
int roundedNumber2 = 11.RoundOff(); // returns 10 

.NET framework eski bir sürümünü karşı programlama yapıyorsanız, sadece "bu" den roundoff işlevini kaldırmak ve böylece gibi işlevini çağırır:

int roundedNumber = ExtensionMethods.RoundOff(236); // returns 240 
int roundedNumber2 = ExtensionMethods.RoundOff(11); // returns 10 

Answer 2

Bir tamsayıya bir tamsayıya yuvarlama (x) (x + 0,5) 'e benzer şekilde, sadece x' in dökümüne karşıt olarak - eğer 10'un katlarını istiyorsanız, bunu kolayca ayarlayabilirsiniz.

Sadece tamsayı matematik yapmak ve onu on yuvarlamak istiyorsanız, (x + 10/2)/10 * 10'u deneyin.

Düzeltme: Bu yanıtın, özgün yazarın isteğini karşılamadığını ve ayrıca tercih etmemeyi tercih ettiğim bir yuvarlama biçiminde olduğunu fark ettim. Bununla birlikte, kabul edilen başka bir yanıt zaten Math.round(), çok daha iyi bir çözüm belirtmiştir.

Answer 3

Her zaman yuvarlamak için Math.Ceiling'i kullanın.

int number = 236; 
number = (int)(Math.Ceiling(number/10.0d) * 10); 

Katsayı (%) Alacağınız bu yüzden, kalan alır:

// number = 236 + 10 - 6 

bir uzantısı yöntemiyle düzenlenmiş yukarıda

public static int roundupbyten(this int i){ 
    // return i + (10 - i % 10); <-- logic error. Oops! 
    return (int)(Math.Ceiling(i/10.0d)*10); // fixed 
} 

// call like so: 
int number = 236.roundupbyten(); 

içine koy: Benim ilk gitmeliydim MathCeiling

I blogged about this when calculating UPC check digits'u kullanma içgüdüsü.

Answer 4

Bu olabilir ... çok geç ama bu gün iyi yardımcı olabileceğini tahmin küçük

Bunu denedim:

public int RoundOff(int number, int interval){ 
    int remainder = number % interval; 
    number += (remainder < interval/2) ? -remainder : (interval - remainder); 
    return number; 
} 

kullanmak için:

int number = 11; 
int roundednumber = RoundOff(number, 10); 

Bu şekilde, aralığın yarısı yuvarlanır veya aşağı yuvarlanır eğer olsun seçeneği vardır.=)

Answer 5

Math kitaplığını getirmeme veya kayan noktaya gitmemeyi tercih ediyorum, bu nedenle öneri sadece 1K'ye kadar yuvarladığım tamsayı aritmetiğidir. Tekrarlamak istemiyorsanız, bir yöntem veya lambda snippet'ine veya bir şeye sarın.

int MyRoundedUp1024Int = ((lSomeInteger + 1023)/1024) * 1024; 

bu vs diğer yolları hakkında performans testleri değil ama bu belki değişimini ve bunun bitleri versiyonunun dönen kurtarmak yapmak için en hızlı yoldur bahse girerim.

Answer 6

Eski soru, ancak burada sorulan şeyi yapmanın bir yolu ve istediğin sayının sayısının herhangi bir sayısının sayılabilmesi için uzattım.

private double Rounding(double d, int digits) 
    { 
     int neg = 1; 
     if (d < 0) 
     { 
      d = d * (-1); 
      neg = -1; 
     } 

     int n = 0; 
     if (d > 1) 
     { 
      while (d > 1) 
      { 
       d = d/10; 
       n++; 
      } 
      d = Math.Round(d * Math.Pow(10, digits)); 
      d = d * Math.Pow(10, n - digits); 
     } 
     else 
     { 
      while (d < 0.1) 
      { 
       d = d * 10; 
       n++; 
      } 
      d = Math.Round(d * Math.Pow(10, digits)); 
      d = d/Math.Pow(10, n + digits); 
     } 

     return d*neg; 
    } 


    private void testing() 
    { 
     double a = Rounding(1230435.34553,3); 
     double b = Rounding(0.004567023523,4); 
     double c = Rounding(-89032.5325,2); 
     double d = Rounding(-0.123409,4); 
     double e = Rounding(0.503522,1); 
     Console.Write(a.ToString() + "\n" + b.ToString() + "\n" + 
      c.ToString() + "\n" + d.ToString() + "\n" + e.ToString() + "\n"); 
    }