C# 如何在.net中获取数字的大小？

我希望使用给定的双精度数字返回其“大小”（称为| number |，或在点后没有数字的数字），例如：

12.324654 -> 2
12 -> 2
0.99 -> 0
1.01 -> 1
901 -> 3
-0.99 -> 0
-9.999 -> 1

一定有一个我不熟悉的函数is.net，它就是这样做的

谢谢。

试试看 对数10（最大值（绝对值，0.5））+1 四舍五入

或者，在实际的C#语法中：

---

好的，这是怎么回事？

首先,， p=log10（x） 是x的基数-10；也就是说，将10提升到p次方（或1后跟p个零）等于x的值。对数基本上测量数字的长度，除了它是x的光滑函数：

（请注意，在不提供以10为底的对数函数的语言中，我们始终可以将其计算为 log10（x）=log（x）/log（10）， 其中log（）是任意基数的对数函数。）

例如，我们有

log10（1）=0.0
log10（10）=1.0
log10（100）=2.0
log10（1000）=3.0

但也包括：

log10（5）=0.69897
log10（50）=1.69897
log10（500）=2.69897
log10（5000）=3.69897

总的来说， N≤ log10（x） 查看上面的值，应该很容易看出，要获得整数中以10为底的数字，我们应该将其以10为底的对数向下舍入到最接近的整数，然后加1（因为我们希望10的长度为2，而不是1）

但是，还有一些边缘情况需要考虑：

首先，最初的提问者想知道问题的长度−x等于x的长度。对数只为正数定义，所以我们用x的绝对值替换x，使其始终为正数

其次，原始提问者还希望0到1之间的数字长度为零。但是，对数可以取任意大的负值：

log10（0.1）=−1.0
log10（0.01）=−2.0
log10（0.001）=−3.0
log10（0.0001）=−4.0

事实上， log10（0）=−∞. 为了满足这一要求，我们只需确保计算长度的数字永远不能低于0.5，方法是将其最大值和0.5作为log10（）的输入。（我们可以使用0.1到1之间的任何数字作为截止值，但0.5恰好是一个很好的圆形二进制分数。）

此外，我们必须确保在对对数进行四舍五入之前将其加上+1，这样我们四舍五入的数字总是非负的。这是因为C#中的

（int）

实际上将负数向上舍入为零。比如说, log10（0.5）和大约；−0.3, 表达式

（int）Math.Log10（0.5）+1

（加法前四舍五入）的计算结果为 0+1 = 1  而不是预期的0

((int)Math.Abs(12.324654)).ToString().Length

Math.Abs

将转换为正数（不想计算负号）

（int）

将删除小数点后的数字

ToString（）

转换为字符串==>“12”

Length

告诉您有多少个字符
有一种边缘情况，其中

（int）（某个数字）=0

，其中长度将为1——您可能不希望这样，因此请注意这种可能性

现在，您可以做的是将其作为扩展方法

public static class Utils
{
   public static int Size(this double n)
   {
     int i = (int)Math.Abs(n);
     if ( i == 0 ) return 0;
     return  i.ToString().Length;
   }
}

12.324654.Size() == 2;

---

您可以执行以下操作来解释返回零长度的

0

数字

private static int CountAbsoluteDigits(double p) {
    int absolute = (int)Math.Abs(p);
    if (0 == absolute)
        return 0;
    else
        return absolute.ToString().Length;
}

这是我用你提供的数字得到的结果

12.324654->2
12->2
0.99->0
1.01->1
901->3
-0.99->0
-9.999->1

---

窃取Quintin的格式：

private static int CountAbsoluteDigits(double p) {
    int ip = (int)p;
    int answer = 0;
    while (ip!=0) {
        answer++;
        ip/=10;
    }
    return answer;
}

在这方面不需要技巧（例如，

abs（）

，

如果

）。

Courtsey Muad'Dib

int GetLength(double value){
    return ((int)Math.Abs(value*10d)).ToString().Length - 1
}

---

仅当值在int范围内时，转换为整数并将结果转换为字符串才有效。如果需要大于20亿的值，则需要使用日志，或者将double转换为字符串

static int GetLength(double d)
{
    d = Math.Abs(d);
    if (d < 1.0) return 0;
    if (double.IsInfinity(d)) return int.MaxValue;
    if (double.IsNaN(d)) return 0;
    return (int)Math.Floor(Math.Log10(d)) + 1;
}

static int GetLength2(double d)
{
    d = Math.Abs(d);
    if (d < 1.0) return 0;
    if (double.IsInfinity(d)) return int.MaxValue;
    if (double.IsNaN(d)) return 0;
    string s = d.ToString("E"); // returns a string in the format "1.012435E+001"
    return int.Parse(s.Substring(s.Length - 3)) + 1;
}

static void Test(double d) { Debug.WriteLine(d + " -> " + GetLength(d) + ", " + GetLength2(d)); }

static void Main(string[] args)
{
    Test(0);
    Test(0.125);
    Test(0.25);
    Test(0.5);
    Test(1);
    Test(2);
    Test(10);
    Test(10.5);
    Test(10.25);
    Test(10.1243542354235623542345234523452354);
    Test(999999);
    Test(1000000);
    Test(1000001);
    Test(999999.111);
    Test(1000000.111);
    Test(1000001.111);
    Test(double.MaxValue);
    Test(double.MinValue);
    Test(double.PositiveInfinity);
    Test(double.NegativeInfinity);
    Test(double.NaN);
    Test(double.Epsilon);
}

---

你怎么能记负数？@Daok:你不能，对不起。更正。你能给我解释一下吗。我不明白背后的逻辑,但觉得很明智,1@Ilmari：输入0如何？我不知道C#，但是min（）函数会强制它返回0吗？好的，我添加了一个解释，并将min（）修正为max（）。（谢谢，@Ziyao Wei！）通常情况下，| number |表示绝对值——显然，这不是你想要的。数字的整数部分在小数点的左边。小数部分在右边。因此，您正在寻找一种测量整数部分使用的小数位数的方法。| number |也称为组/数的大小。它连接到你正在行走的东西。非常直截了当：）+1我喜欢简单。不考虑负数。您需要绝对值，否则原始问题（-9.999->1）中的要求将不起作用。可能是（（int）（Math.Abs（12.324654））.ToString（）.Length；？否则，我喜欢这种方法的简单性。：）现在它已更新，我将删除我的答案。：）我认为需要考虑结果为0的可能性，因为OP希望0返回零长度…0.99->0也将返回1，不是吗？@hungryMind，“（int）（someDouble）”将删除小数点后的部分，因此（int）0.99==1（因为0）--更改了代码以修复此问题

int GetLength(double value){
    return ((int)Math.Abs(value*10d)).ToString().Length - 1
}

static int GetLength(double d)
{
    d = Math.Abs(d);
    if (d < 1.0) return 0;
    if (double.IsInfinity(d)) return int.MaxValue;
    if (double.IsNaN(d)) return 0;
    return (int)Math.Floor(Math.Log10(d)) + 1;
}

static int GetLength2(double d)
{
    d = Math.Abs(d);
    if (d < 1.0) return 0;
    if (double.IsInfinity(d)) return int.MaxValue;
    if (double.IsNaN(d)) return 0;
    string s = d.ToString("E"); // returns a string in the format "1.012435E+001"
    return int.Parse(s.Substring(s.Length - 3)) + 1;
}

static void Test(double d) { Debug.WriteLine(d + " -> " + GetLength(d) + ", " + GetLength2(d)); }

static void Main(string[] args)
{
    Test(0);
    Test(0.125);
    Test(0.25);
    Test(0.5);
    Test(1);
    Test(2);
    Test(10);
    Test(10.5);
    Test(10.25);
    Test(10.1243542354235623542345234523452354);
    Test(999999);
    Test(1000000);
    Test(1000001);
    Test(999999.111);
    Test(1000000.111);
    Test(1000001.111);
    Test(double.MaxValue);
    Test(double.MinValue);
    Test(double.PositiveInfinity);
    Test(double.NegativeInfinity);
    Test(double.NaN);
    Test(double.Epsilon);
}

0 -> 0, 0
0.125 -> 0, 0
0.25 -> 0, 0
0.5 -> 0, 0
1 -> 1, 1
2 -> 1, 1
10 -> 2, 2
10.5 -> 2, 2
10.25 -> 2, 2
10.1243542354236 -> 2, 2
999999 -> 6, 6
1000000 -> 7, 7
1000001 -> 7, 7
999999.111 -> 6, 6
1000000.111 -> 7, 7
1000001.111 -> 7, 7
1.79769313486232E+308 -> 309, 309
-1.79769313486232E+308 -> 309, 309
Infinity -> 2147483647, 2147483647
-Infinity -> 2147483647, 2147483647
NaN -> 0, 0
4.94065645841247E-324 -> 0, 0