有没有快速的方法可以找到比给定数字小10的最大功率？
我现在正在使用这个算法，但是当我看到它时，我内心的某些东西就会消失：
10**( int( math.log10(x) ) ) # python
pow( 10, (int) log10(x) ) // C
我可以为我的问题实现简单的log10和pow函数，每个循环一次，但我仍然想知道十进制数字是否有点神奇。
答案 0 :(得分：6)
另一种算法是：
i = 1;
while((i * 10) < x)
i *= 10;
答案 1 :(得分：5)
日志和电源是昂贵的操作。如果你想要快速，你可能想要在表中查找IEEE二进制指数以获得大约10的幂，然后检查尾数是否强制改变+1。这应该是3或4个整数机器指令（或者O（1）具有非常小的常量）。
给出表格：
int IEEE_exponent_to_power_of_ten[2048]; // needs to be 2*max(IEEE_exponent)
double next_power_of_ten[600]; // needs to be 2*log10(pow(2,1024)]
// you can compute these tables offline if needed
for (p=-1023;p>1023;p++) // bounds are rough, see actual IEEE exponent ranges
{ IEEE_exponent_to_power_of_ten[p+1024]=log10(pow(2,p)); // you might have to worry about roundoff errors here
next_power_of_ten[log10(pow(2,p))+1024]=pow(10,IEEE_exponent_to_power_of_ten[p+1024]);
}
然后你的计算应该是：
power_of_ten=IEEE_exponent_to_power_of_10[IEEE_Exponent(x)+1023];
if (x>=next_power_of_ten[power_of_ten]) power_of_ten++;
answer=next_power_of_ten[power_of_ten];
[你可能真的需要把它写成汇编程序来挤出每个最后一个时钟。] [此代码未经过测试。]
但是，如果你坚持在python中执行此操作，解释器开销可能会淹没日志/ exp时间，这可能无关紧要。
那么，你想要快速，还是想要短写？
编辑12/23：OP现在告诉我们他的“x”是不可或缺的。假设它是64（或32）位整数，我的提议仍然有效，但显然没有“IEEE_Exponent”。大多数处理器都有一个“查找第一个”指令，它会告诉你左边（最重要）部分值的0位数，例如前导零;你很可能这实际上是64（或32）减去值的2的幂。给定exponent = 64 - leadingzeros，你有两个指数的幂，并且算法的其余部分大部分基本不变（修改留给读者）。
如果处理器没有find-first-one指令，那么最好的选择是平衡判别树来确定10的幂。对于64位，这样的树最多需要18个比较来确定指数（10 ^ 18~2 ^ 64）。
答案 2 :(得分：4)
创建一个10的幂数组。在其中搜索小于x的最大值。
如果x相当小，您可能会发现线性搜索比二分搜索提供更好的性能，部分原因是分支误预测更少。
答案 3 :(得分：3)
据我所知，渐近最快的方法是重复平方。
func LogFloor(int value, int base) as int
//iterates values of the form (value: base^(2^i), power: 2^i)
val superPowers = iterator
var p = 1
var c = base
while c <= value
yield (c, p)
c *= c
p += p
endwhile
enditerator
//binary search for the correct power
var p = 0
var c = 1
for val ci, pi in superPowers.Reverse()
if c*ci <= value
c *= ci
p += pi
endif
endfor
return p
算法采用N中的对数时间和空间，这与N的表示大小呈线性关系。 [时间限制可能有点糟糕，因为我乐观地简化了]
请注意，我假设任意大整数（注意溢出！），因为在处理只有32位整数时，天真时间10-until-over算法可能足够快。
答案 4 :(得分：1)
鉴于这是与语言无关的，如果你可以得到这个数字很重要的2的幂，例如y在x * 2 ^ y（这是数字存储的方式，虽然我不确定我我已经看到了一种简单的方法来访问我用过的任何语言中的y），如果
z = int(y/(ln(10)/ln(2)))
（一个浮点除法）
10 ^ z或10 ^（z + 1）将是你的答案，尽管10 ^ z仍然不是那么简单（请求纠正）。
答案 5 :(得分：1)
我认为最快的方法是O（log（log（n））^ 2），while循环取O（log（log（n））并且它可以是递归调用有限时间（我们可以说O（c） ）其中see是常量），第一次递归调用是采用log（log（sqrt（n）））time time ...以及sqrt的sqrt（sqrt（sqrt ....（n））＆lt; 10是log（log（n））和常量，因机器限制。
static long findPow10(long n)
{
if (n == 0)
return 0;
long i = 10;
long prevI = 10;
int count = 1;
while (i < n)
{
prevI = i;
i *= i;
count*=2;
}
if (i == n)
return count;
return count / 2 + findPow10(n / prevI);
}
答案 6 :(得分：1)
在Python中：
10 **（LEN（STR（INT（X））） - 1）
答案 7 :(得分：0)
我使用C ++中的以下变体为方法计时，a值为size_t类型（内联提高了性能但不改变相对排序）。
尝试1：乘以找到数字。
size_t try1( size_t a )
{
size_t scalar = 1ul;
while( scalar * 10 < a ) scalar *= 10;
return scalar;
}
尝试2：Multiway if（也可以使用查找表编程）。
size_t try2( size_t a )
{
return ( a < 10ul ? 1ul :
( a < 100ul ? 10ul :
( a < 1000ul ? 100ul :
( a < 10000ul ? 1000ul :
( a < 100000ul ? 10000ul :
( a < 1000000ul ? 100000ul :
( a < 10000000ul ? 1000000ul :
( a < 100000000ul ? 10000000ul :
( a < 1000000000ul ? 100000000ul :
( a < 10000000000ul ? 1000000000ul :
( a < 100000000000ul ? 10000000000ul :
( a < 1000000000000ul ? 100000000000ul :
( a < 10000000000000ul ? 1000000000000ul :
( a < 100000000000000ul ? 10000000000000ul :
( a < 1000000000000000ul ? 100000000000000ul :
( a < 10000000000000000ul ? 1000000000000000ul :
( a < 100000000000000000ul ? 10000000000000000ul :
( a < 1000000000000000000ul ? 100000000000000000ul :
( a < 10000000000000000000ul ? 1000000000000000000ul :
10000000000000000000ul )))))))))))))))))));
}
尝试3：从@Saaed Amiri的findPow10修改，它使用平方来更快地找到比Try 1更大的力量。
size_t try3( size_t a )
{
if (a == 0)
return 0;
size_t i, j = 1;
size_t prev = 1;
while( j != 100 )
{
i = prev;
j = 10;
while (i <= a)
{
prev = i;
i *= j;
j *= j;
}
}
return prev;
}
尝试4：根据@Ira Baxter使用count前导零指令索引查找表。
static const std::array<size_t,64> ltable2{
1ul, 1ul, 1ul, 1ul, 1ul, 10ul, 10ul, 10ul,
100ul, 100ul, 100ul, 1000ul, 1000ul, 1000ul,
1000ul, 10000ul, 10000ul, 10000ul, 100000ul,
100000ul, 100000ul, 1000000ul, 1000000ul,
1000000ul, 1000000ul, 10000000ul, 10000000ul,
10000000ul, 100000000ul, 100000000ul,
100000000ul, 1000000000ul, 1000000000ul,
1000000000ul, 1000000000ul, 10000000000ul,
10000000000ul, 10000000000ul, 100000000000ul,
100000000000ul, 100000000000ul, 1000000000000ul,
1000000000000ul, 1000000000000ul, 1000000000000ul,
10000000000000ul, 10000000000000ul, 10000000000000ul,
100000000000000ul, 100000000000000ul, 100000000000000ul,
1000000000000000ul, 1000000000000000ul, 1000000000000000ul,
1000000000000000ul, 10000000000000000ul, 10000000000000000ul,
10000000000000000ul, 100000000000000000ul, 100000000000000000ul,
100000000000000000ul, 100000000000000000ul, 1000000000000000000ul,
1000000000000000000ul };
size_t try4( size_t a )
{
if( a == 0 ) return 0;
size_t scalar = ltable2[ 64 - __builtin_clzl(a) ];
return (scalar * 10 > a ? scalar : scalar * 10 );
}
时间如下（gcc 4.8）
for( size_t i = 0; i != 1000000000; ++i) try1(i) 6.6
for( size_t i = 0; i != 1000000000; ++i) try2(i) 0.3
for( size_t i = 0; i != 1000000000; ++i) try3(i) 6.5
for( size_t i = 0; i != 1000000000; ++i) try4(i) 0.3
for( size_t i = 0; i != 1000000000; ++i) pow(10,size_t(log10((double)i)))
98.1
查找/多路 - 如果击败C ++中的所有东西，但要求我们知道整数是有限的大小。对于较大的try3次节拍try1，对于较小的循环结束值，try3在此测试中慢于try1。在python中，事情变得困难，因为整数不受限制，所以我将try2和try3结合起来，快速处理数字达到固定限制，然后处理可能非常大的数字。
在python中，我认为使用列表推导的查找可能比multiway-if更快。
# where we previously define lookuptable = ( 1, 10, 100, ..... )
scalar = [i for i in lookuptable if i < a][-1]