light gremlins - 查找范围内素数的所有乘法数

Question

我试图在 IEEEXTREME 上回答一个名为“lightgremlins”的问题。 给定一个数组数量的 gremlins 和每个选择的素数，返回在所有 gremlins 切换到素数相乘后仍然存在的范围内的数字。

给定输入：

30 3 2 3 5

输出：

15

箱子由一个 30 长的走廊和三个小精灵组成。小精灵的动作如下 如下： 第一个 gremlin 翻转开关{2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30}。所有这些 开关以前是关闭的，所以它们现在是打开的。 第二个小精灵翻转开关{3, 6, 9, 12, 15, 18, 21, 24, 27, 30}。其中，{6, 12, 18, 24, 30} 以前是开的，所以现在关了。这会导致以下开关打开：{2, 3, 4, 8, 9, 10, 14, 15, 16, 20, 21, 22, 26, 27, 28}。 第三个 gremlin 翻转开关{5, 10, 15, 20, 25, 30}。其中，{10, 15, 20} 之前已开启，所以 他们现在走了。这会导致以下开关打开：{2, 3, 4, 5, 8, 9, 14, 16, 21, 22, 25, 26, 27, 28, 30}。 因此，晚上结束时有 15 个开关打开。

现在我的代码非常简单：

testcases=int(input())
for i in range(0,testcases):
  array = input().split(' ')
  arrayofnumbers = [int(x) for x in array]
  #print(arrayofnumbers)
  onCount=0
  for j in range(1,arrayofnumbers[0]+1):
     primeCount=0
     for p in arrayofnumbers[2:len(arrayofnumbers)]:
        if j%p == 0:
            primeCount += 1
     if primeCount % 2 == 1:
         onCount += 1
print(onCount)

现在这似乎适用于小型阵列，或者我认为。我失败了一半的测试用例，我真的不明白为什么。也许这不适用于非常大的数组？也许我的整个方法都是错误的？

我已更改我的代码以使用 LCM 并计算迭代次数，但这仍然没有解决其余的测试用例几乎保持不变。这是我的代码：

from math import gcd

    testcases=int(input())
    for i in range(0,testcases):
      array = input().split(' ')
      arrayofnumbers = [int(x) for x in array]
      #print(arrayofnumbers)
      lcm = 1
      for i in arrayofnumbers[2:]:
          lcm = int(lcm * i / gcd(lcm, i))
      #print(lcm)

      if lcm >= arrayofnumbers[0]:
        onCount=0
        for j in range(1,arrayofnumbers[0]+1):
            primeCount=0
            for p in arrayofnumbers[2:len(arrayofnumbers)]:
                if j%p == 0:
                    primeCount += 1
            if primeCount % 2 == 1:
                 onCount += 1
        print(onCount)

      if lcm < arrayofnumbers[0]:
          numiters=int(arrayofnumbers[0]/lcm)
          onCount = 0
          extraonCount=0
          for j in range(1, lcm+1):
              primeCount = 0
              for p in arrayofnumbers[2:len(arrayofnumbers)]:
                  if j % p == 0:
                      primeCount += 1
              if primeCount % 2 == 1:
                  onCount += 1
          onCount = onCount * numiters

          for j in range(1, (arrayofnumbers[0]-(lcm*numiters))+1):
              primeCount = 0
              for p in arrayofnumbers[2:len(arrayofnumbers)]:
                  if j % p == 0:
                    primeCount += 1
              if primeCount % 2 == 1:
                extraonCount += 1
          onCount += extraonCount
        print(onCount)

使用不同的方法使用可整除的数字集，我没有得到任何测试用例超时，而是错误的答案和更正确的测试用例，但仍然不是完全正确的答案。 使用这个想法： click link

testcases=int(input())
for i in range(0,testcases):
  array = input().split(' ')
  arrayofnumbers = [int(x) for x in array]
  arrayOfon = []
  arrayIterate = []
  arrayPrimes = []

  for j in arrayofnumbers[2:]:
      arrayPrimes.append(j)
  arrayPrimes.sort()

  print(arrayPrimes)

  for j in arrayPrimes:
      num=0
      num = int(arrayofnumbers[0] // j)
      arrayOfon.append(num)

  print(arrayOfon)

  for j in arrayPrimes[1:]:
      arrayIterate.append(j)


  print(arrayIterate)


  for j in range(0, len(arrayIterate)):
      x = 0
      y = 0
      y = arrayOfon[0]
      x = y // arrayIterate[j]
      arrayOfon[0] = (y - x) + (arrayOfon[j+1] - x)



  print(arrayOfon[0])

Answer 1

让lcm 成为least common multiple，计数将重复每个lcm 数字，因此您不需要循环整个范围，只需计算在1..lcm 范围内打开了多少开关，然后将其乘以int(n/lcm)（即整个序列将重复多少次）并添加最后一项的计数，即从lcm*int*n/lcm)到结束。

简单示例： 如果开关的数量是 33，并且有两个 gremlins：2 和 3，lcm(2,3)=6 所以你不需要从 1 一直计数到 33，因为计数会每 6 个开关重复一次，并且会重复@ 987654328@次。所以你只需要计算从 1 到 6 的开关，然后将该计数乘以 5，然后添加范围 31...33 的计数