指数大于 2 的偶数个数

Question

假设我给了一个数字 n。我想找出所有小于 n 的偶数，并且其素数分解中 2 的指数大于 n 的素数分解中 2 的指数。

如果 n=18 答案是 4，即 4,8,12,16。

使用从 i=2 到小于 n 的 for 循环并检查每个 i 将在代码中显示超出时间限制。

我的方法是计算我将继续除以 2 的次数。但 n=10^18 的限制。所以，我认为它是一个 O (1) 操作。谁能帮我找到任何公式或算法以尽快找到答案？

Answer 1

首先假设 n 是奇数。显然，每个小于 n 的偶数在其因式分解中也有一个更大的指数 2，因此答案将等于 (n−1) / 2。

现在假设 n 等于某个奇数 p 的 2 倍。有 (p-1) / 2 个偶数小于 p，因此也有 (p-1) / 2 个小于 n 且至少可被 2² 整除的数。

一般来说，给定任意数 n 等于 2^k 乘以某个奇数 q，将有 (q−1) / 2 个小于 n 并且具有更大指数 2 (> 2^k) 在他们的因式分解中。

所以这样的功能应该可以工作：

def count_smaller_numbers_with_greater_power_of_2_as_a_factor(n):
    assert n > 0
    while n % 2 == 0:
        n >>= 1
    return (n-1) // 2

---

示例 1 (n = 18)

1. 因为 n 是偶数，所以继续除以 2 直到得到奇数。这只需要一步（因为 n / 2 = 9）
2. 计算小于 9 的偶数个数。这等于 (9−1) / 2 = 4

示例 2 (n = 10¹⁸)

1. 在这种情况下，n = 2¹⁸ × 5¹⁸。因此，如果我们继续将 n 减半直到得到一个奇数，结果将是 5¹⁸。
2. 小于5¹⁸的偶数个数等于(5¹⁸-1) / 2 = 1907348632812

Answer 2

您的除法受限于常数 64（对于 10^18~2^64）和复杂性理论中的 O(64)=O(1)。

值分解中的二进制数等于该值二进制表示中的尾随零位数，因此您可以使用位运算（如& 1 和右移shr, >>）来加速代码或应用一些bit tricks

Answer 3

首先，假设n = 2^k * something。求知k：

long k = 0;
while(n % 2 == 0) { n >>= 1; k++; }
n <<= k;

既然您知道k 是谁，请将2^k 乘以2 得到大于2^k 的2 的第一次幂：

long next_power = 1 << (k + 1);  // same as 2^(k + 1)

最后，检查n 是否为奇数。如果不是，打印next_power的所有倍数：

if(k == 0){  //equivalent to testing n % 2 == 0
    for(long i = next_power; i < n; i += next_power) cout<<i<<endl;
}

---

示例：n = 18

k 将是 1，因为 18 = 2^1 * 9 并且 while 将在那里完成。

next_power 将是 4 (= 1 << (k + 1) = 2 ^ (k + 1))。

for(long i = next_power; i < n; i += next_power) cout<<i<<endl; 将打印 4、8、12 和 16。

Answer 4

使用我发现的 gcd 技巧很容易做到这一点：

You can find the count by //4. So 10^18 has 
  In [298]: pow(10,18)//4                                                                                                                                                                            
  Out[298]: 250000000000000000

You can find the count of 18 by //4 which is 4

Fan any numbers that meet your criteria. You can check by using my 
algorithm here, and taking the len of the array and conpare with the 
number div//4 to see that that is the answer your looking for: an exact 
match. You'll notice that it's every four numbers that don't have an 
exponent of 2. So the count of numbers can be found with //4. 

import math

def lars_last_modulus_powers_of_two(hm):
   return math.gcd(hm, 1<<hm.bit_length())

def findevennumberswithexponentgreaterthan2lessthannum(hm):
    if hm %2 != 0:
      return "only for use of even numbers"
    vv = []
    for x in range(hm,1,-2):
       if  lars_last_modulus_powers_of_two(x) != 2:
          vv.append(x)
    return vv

结果：

In [3132]: findevennumberswithexponentgreaterthan2lessthannum(18)                                                                                                      
Out[3132]: [16, 12, 8, 4]

这是最快的方法，因为您可以跳过模组以获取答案。使用 lars_last_modulus_powers_of_two(num) 立即获得您需要的数字，每个数字一次操作。

这里有一些例子表明答案是正确的：

In [302]: len(findevennumberswithexponentgreaterthan2lessthannum(100))                                                                                                                             
Out[302]: 25

In [303]: 100//4                                                                                                                                                                                    
Out[303]: 25

In [304]: len(findevennumberswithexponentgreaterthan2lessthannum(1000))                                                                                                                            
Out[304]: 250

In [305]: 1000//4                                                                                                                                                                                  
Out[305]: 250

In [306]: len(findevennumberswithexponentgreaterthan2lessthannum(23424))                                                                                                                           
Out[306]: 5856

In [307]: 23424//4                                                                                                                                                                                 
Out[307]: 5856