Arrays 查找质数范围内的最大出现位数

给定两个数a和b（1doa，找到0、106范围内的所有素数。这可以很快完成（在一台普通机器上，不到1秒）。使用10个辅助数组-每个数字一个，大小为106的每个数组。如果一个数字不是素数，则将所有10个数组存储为0。如果一个数字是素数，则在每个数组中存储给定数字在该数字中出现的次数。在每个数组上循环一次后，累积给定数字的出现次数。这可以很容易地在线性时间内完成。对于数字3：

for (int i = 1; i < n; ++i) {
   a3[i] += a3[i-1];
}

for（int i=1；i

使用这些数组，您可以在固定时间内计算指定间隔内每个数字的出现次数。即间隔

[x，y]

中3的出现次数是

a3[y]-a3[x-1]

（注意x为0时的特殊情况）

该算法的计算复杂度与预计算的Eratosthenes筛选和每个查询的常量计算复杂度相同。内存复杂度是线性的。您可以通过只在辅助数组中存储素数的值来提高内存开销，从而使它们的大小等于素数numb如果需要的话，可以将其设置为106。但是，这会使实现稍微复杂一些。

执行一个操作，以查找0、106范围内的所有素数。这可以非常快地完成（在普通机器上，不到1秒）。使用10个辅助数组-每个数字一个，大小为106的每个数组。如果一个数字不是素数，则将所有10个数组存储为0。如果一个数字是素数，则在每个数组中存储给定数字在该数字中出现的次数。在每个数组上循环一次后，累积给定数字的出现次数。这可以很容易地在线性时间内完成。对于数字3：

for (int i = 1; i < n; ++i) {
   a3[i] += a3[i-1];
}

function writeOutput(left, right) {

let digitCount = new Array(10);
digitCount.fill(0)


for(let num = left ; num <= right; num++){
    if(isPrime(num)){
        let copyNum = num;
        while (copyNum > 0){
            let d = copyNum % 10;
            digitCount[d]++;
            copyNum = copyNum / 10;
        }
    }
}


 let maxCount = 0;

 let maxNum = 0;

 for (let j = 0; j < digitCount.length; j++){
   if(digitCount[j] > maxCount){
    maxCount = digitCount[j];
    maxNum = j;
   }
 }
if(maxCount == 1){
    for(let k = digitCount.length - 1; k > 0; k--){
      if(digitCount[k] > 0){
        maxNum = k;
        break;
       }
    }
  } else if( maxCount > 1){
    return maxNum;
 } else {
    maxNum = -1;
 }

 return maxNum

 }
   function isPrime(n){
      for(let i = 2; i * i <= n; i++){
         if(n % i == 0){
           return false
         }
     }
     return true
  }

for（int i=1；i

使用这些数组，您可以在固定时间内计算指定间隔内每个数字的出现次数。即间隔

[x，y]

中3的出现次数是

a3[y]-a3[x-1]

（注意x为0时的特殊情况）

该算法的计算复杂度与预计算的Eratosthenes筛选和每个查询的常量计算复杂度相同。内存复杂度是线性的。您可以通过只在辅助数组中存储素数的值来提高内存开销，从而使它们的大小等于素数numb如果需要，ers最多可达106。但是这会使实现稍微复杂一些。

函数writeOutput（左、右）{
function writeOutput(left, right) {

let digitCount = new Array(10);
digitCount.fill(0)


for(let num = left ; num <= right; num++){
    if(isPrime(num)){
        let copyNum = num;
        while (copyNum > 0){
            let d = copyNum % 10;
            digitCount[d]++;
            copyNum = copyNum / 10;
        }
    }
}


 let maxCount = 0;

 let maxNum = 0;

 for (let j = 0; j < digitCount.length; j++){
   if(digitCount[j] > maxCount){
    maxCount = digitCount[j];
    maxNum = j;
   }
 }
if(maxCount == 1){
    for(let k = digitCount.length - 1; k > 0; k--){
      if(digitCount[k] > 0){
        maxNum = k;
        break;
       }
    }
  } else if( maxCount > 1){
    return maxNum;
 } else {
    maxNum = -1;
 }

 return maxNum

 }
   function isPrime(n){
      for(let i = 2; i * i <= n; i++){
         if(n % i == 0){
           return false
         }
     }
     return true
  }

设digitCount=新数组（10）；
数字计数。填充（0）
for（设num=left；num 0）{
设d=copyNum%10；
数字计数[d]++；
copyNum=copyNum/10；
}
}
}
设maxCount=0；
设maxNum=0；
for（设j=0；jmaxCount）{
maxCount=digitCount[j]；
maxNum=j；
}
}
如果（maxCount==1）{
for（设k=digitCount.length-1；k>0；k--）{
如果（数字计数[k]>0）{
maxNum=k；
打破
}
}
}否则如果（最大计数>1）{
返回maxNum；
}否则{
maxNum=-1；
}
返回最大值
}
函数isPrime（n）{
for（设i=2；i*i
函数写输出（左、右）{
设digitCount=新数组（10）；
数字计数。填充（0）
for（设num=left；num 0）{
设d=copyNum%10；
数字计数[d]++；
copyNum=copyNum/10；
}
}
}
设maxCount=0；
设maxNum=0；
for（设j=0；jmaxCount）{
maxCount=digitCount[j]；
maxNum=j；
}
}
如果（maxCount==1）{
for（设k=digitCount.length-1；k>0；k--）{
如果（数字计数[k]>0）{
maxNum=k；
打破
}
}
}否则如果（最大计数>1）{
返回maxNum；
}否则{
maxNum=-1；
}
返回最大值
}
函数isPrime（n）{
对于（让i=2；i*i，我不认为你能做得更好。@Henry不是一个查询。但是，如果有多个这样的查询，可以通过预计算来改进这种幼稚的方法。从什么意义上说，你的基本方法是“低效的”？我不认为你能做得更好。@Henry一个查询也不行。但是，如果有多个这样的查询，可以通过预计算来改进这种幼稚的方法。从什么意义上说，你的基本方法是“低效的”？我不认为有10个长度为10**6的数组有什么意义。只需要将一个长度为10的数组初始化为全零，每个条目表示该数字出现的次数。然后一次遍历所有素数就足以计算计数。我不认为有10个长度为10**6的数组有什么意义。只需要有一个长度为10**6的数组长度10初始化为全零，每个条目表示该数字出现的次数。然后一次遍历所有素数就足以计算计数。虽然代码可能会帮助作者，但推荐您的解决方案是一个好做法。您的意思是什么？通过代码推荐您的解决方案是一个好做法我可以告诉作者你是什么意思？