import java.util.Scanner;

public class Main {
			

	public static void main(String[] args) {
		// TODO Auto-generated method stub
	
		Scanner in =new Scanner(System.in);
		int n,m;
		m=in.nextInt();
		n=in.nextInt();
		int count = 0;
		int count2 = 0;
		
		for (int i =2;count<=n;i++){
			boolean a =true;
			for (int j =2;j<=(int)Math.sqrt(i);j++)
			{
				
				if (i%j==0)
				{
					a = false;
					break;
				}
			}
			if (a)
			{
				count++;
				if(count>=m&&count<n){
					count2++;
					if(count2!=10){
						System.out.print(i+" ");
					}
					else{
						System.out.println(i);
						count2=0;
					}	
				}
				else if(count==n){
					System.out.print(i);
				}
			}
			
		}
	
	}
	
}

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
int isprime(int n)
{
    if(n==1) return 0;
    if(n==2) return 1;
    if(n%2==0) return 0;
    int i;
    for(i=3;i<=sqrt(n)+1;i+=2)//遍历到n的平凡根加1
    {
        if(n%i==0)
            return 0;
    }
    return 1;
}
int main()
{
    int N,M,index=1,j=1,count=0;
    scanf("%d%d",&M,&N);
    if(N>10000||M>10000||M>N)
        return -1;
    int array[10001]={0};
     
    while(index<=N)
    {
        if(isprime(j)==1)
        {
            array[index]=j;
            index++;
        }
        j++;
    }
     
    for(j=M;j<=N;j++)
    {
        printf("%d",array[j]);
		count++;
		if(count==10){
			printf("\n");
			count=0;
		}else if(j!=N){
		printf(" ");
		}
    }
    return 0;
}

• 数组注意下表与M,N的对应；
• 为图方便直接声明了大小为MAXSIZE的数组，array[M]存的PM，故而数组必须超过10000，否则输入为10000,10000时就会出现数组array[10000]数组访问越界的错误；
• 输出格式要注意：要求每十个数字要换行，且行末不可有空格。

#include<stdio.h>
int A[100000];
int main(){
    int k=0,i,j,flag=1;
    int m,n;
    scanf("%d %d",&m,&n);
    for(i=2;i<100000;++i){
        flag=1;//每次都重置flag
        for(j=2;j<=(int)(sqrt((double)i));++j){ //注意小于等于根号i
            if(i%j==0){
                flag=0;
                break;
            }
        }
        if(flag==1){
             A[k]=i;
             k++;
        }
    }
    for(i=m-1;i<n;++i){
        if((i-m+2)%10!=0){
            printf("%d ",A[i]);
        }
        if((i-m+2)%10==0){//每输出10个换行
            printf("%d",A[i]);
            printf("\n");
        }
    }
}

• 埃氏筛法生成素数表。

• 测试发现10万以内的素数不足1万个，所以应该查找的范围到了100万。

• 格式输出。

/*
 * app=PAT-Basic lang=c++
 * https://pintia.cn/problem-sets/994805260223102976/problems/994805309963354112
 */
#include <cstdio>
using namespace std;

const int maxn = 1000100; //测试发现10万以内的素数不足1万个，所以应该查找的范围到了100万
bool isPrime[maxn] = {};
int prime[10010] = {};
int len = 0;
void getPrime(){
    for (int i = 2; i < maxn && len < 10010; i++){
        if (!isPrime[i]){
            prime[len++] = i;
            for (int j = i + i; j < maxn; j += i){
                isPrime[j] = true;
            }
        }
    }
}
int main()
{
    getPrime();
    int N, M;
    scanf("%d%d", &M, &N);
    int cnt = 0;
    for (int i = M - 1; i < N;i++){
        printf("%d",prime[i]);
        cnt++;
        if (cnt % 10 == 0){
            printf("\n");
        }
        else if(i!=N-1){
            printf(" ");
        }
    }
    return 0;
}

#include <iostream>
#include<cmath>
using namespace std;

int main()
{
    int M,N,count=0;
    long n=2;
    long sushu[10001];
    int x=1;//每行个数
    cin>>M>>N;
    do{
        long i;
        long m=sqrt(n);
        for(i=2;i<=m;i++)
        {
            if(n%i==0)goto loop;
        }
        if(i>m)
        {
            sushu[count]=n;
            count++;
            loop:
            n++;
        }
    }while(count<N);
    if(M==N)
    {
        cout<<sushu[M-1];
    }
    if(M<N)
    {
        for(int j=M;j<=N;j++)
        {
            if(x%10==0)
            {
                cout<<" "<<sushu[j-1]<<endl;
                x++;
            }
            else if(x%10==1)
            {
                cout<<sushu[j-1];
                x++;
            }
            else
            {
                cout<<" "<<sushu[j-1];
                x++;
            }
        }
    }
}

	

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<math.h>
using namespace std;

bool isSu(int a){
    if(a <= 1) return false;
    for(int i = 2; i <= sqrt(a); i++){
        if(a % i == 0) return false;
    }
    return true;
}

int su[100010];

int main(){
    int down, up;
    int m = 0, i = 0;
    scanf("%d %d", &down, &up);
    while(m  < up){
        if(isSu(i)) m++;
        if(isSu(i) && m >= down ){
            printf("%d", i);
            if(m != up && !((m - down + 1) % 10 == 0)) printf(" ");
            if((m - down + 1) % 10 == 0) printf("\n");
        }
        i++; 
    }
    return 0;
} 

#判断是否为素数,结合开平方法和已知的n个素数
def sss(a,b,n):
    for i in range(n):
        if b[i]<=(a/b[i]):
            if a%b[i]==0:
                return [0,n]
        else:
            break;
    return [1,(n+1)]

a = [int(n) for n in input().split()];
b=[0 for n in range(10000)];
b[0]=2;b[1]=3;
p=5;q=2;
d=0;
#只需要找指定的数量
while(q < a[1]):
    k=sss(p,b,q);
    if k[0]==1:
        b[q]=p;
        q+=1;
    p+=1;
    
'''输出结果，注意最后一个数字后面不能有空格，每10个就换行'''
for i in range(a[0]-1,a[1]):
    d+=1;
    if d%10==0:
        print(b[i])
    elif i==(a[1]-1):
        print(b[i])
    else:
        print(b[i],end=' ')          

基本思路

素数是指只能被1和自己整除的正整数，所以需要找出因子是本身和1的数，因而能被小于该数的素数整除的数一定不是素数，而小于该数的非素数一定可以被小于该数的素数整除，因而只要该数不能被小于它的所有素数整除，那么该数一定为素数，而素数序列相对于自然数序列要松散的多，故而只需要将该数对小于它的素数取余就可判断该数是否为素数。

示例代码：

#include <iostream>
using namespace std;
struct PrimeNode
{
    PrimeNode *next;
    unsigned long value;
};
int main(){
    int M, N, pIndex = 0;
    unsigned long num = 2;
    string str = "";
    PrimeNode *head = new PrimeNode {
        NULL,
        2
    };
    PrimeNode *p = head;
    cin >> M >> N;
    while(1){
        unsigned long i = 2;
        p = head;
        while(0 != num%(p->value)){
            if(NULL == p->next) break;
            p = p->next;
        }
        if(NULL == p->next) {
            pIndex++;
            p->next = new PrimeNode{NULL, num}; // 添加到素数列表
            if((pIndex >= M) && (pIndex <= N)){
                if((pIndex != M) && (0 == (pIndex - M)%10)){
                    str = "";
                    cout << endl;
                }
                cout << str << num;
                str = " ";
            } else if(pIndex > N){
                break;
            }
        }
        num++;
    }
    cout << endl;
    return 0;
}

include

include

int main()
{
int n,m,i,j,t=0,c=0;
scanf("%d%d",&n,&m);
for(i=2;c<m;i++) { t=sqrt(i); int flag=0; for(j=2;j<=t;j++) if(i%j==0) break; if(j==t+1) { c++; flag=1; } if(c>=n&&flag==1)
{
printf("%d",i);
if((c-n)%10==9)
printf("\n");
else if(c!=m)
printf(" ");
}
}
return 0;
}

#include <iostream>
using namespace std;
int num=0;
bool p[1000010]={0};
int main(){
    int n,m;
    cin>>n>>m;
    for(int i=2;num<=m;i++){
        if(p[i]==0){
            num++;
            for(int j=i;j<1000010;j+=i)  //筛除i的倍数
                p[j]=1;
            if(num>=n && num<=m){
                cout<<i;
                if(num!=n && (num-n+1)%10==0) cout<<'\n'; //换行
                else if(num!=m) cout<<" ";
            }
        }
    }    
    return 0;
}

#include "bits/stdc++.h"
using namespace std;
#define MAX 10005
int pri[MAX]= {0},pri_n=1;
bool isPrime(int num)
{
    if(num ==2||num==3)
        return 1;
    if(num %6!=1&&num %6!=5)
        return 0;
    int tmp =sqrt(num);
    for(int i=5; i<=tmp; i+=6)
        if(num%i==0||num %(i+2)==0)
            return 0;
    return 1 ;
}
void se(int t)
{
    int m=2,n=105000,i=0;
    for(i=m; i<n+1; i++)
    {
        if(isPrime(i))
        {
            pri[pri_n]=i;
            pri_n++;
        }
        if(pri_n>t)
            break;
    }
}
int  main()
{
    int m=0,n=0;
    cin>>m>>n;
    se(n);
    int i=0;
    for(i=m; i<n; i++)
    {
        if((i-m+1)%10!=0)
            cout<<pri[i]<<" ";
        else
            cout<<pri[i]<<endl;
    }
    cout<<pri[i];
}

	



	

/*不用埃拉托斯特尼筛法：
根据素数的定义，判断数n是不是素数，我们只需要从i=2开始，
判断n能不能被n整除，一直到n-1，如果可以则说明不是素数。
另一方面，一个数若是合数，则一定能写成两个因数相乘的形式，并且两个因数中较小的那个一定小于
等于sqrt(n)，否则两个因数的乘积大于n，因为i的终止条件可以设为sqrt(n)，这种方法的时间复杂度
为O（n的1.5次方）。空间复杂度为O(1)。*/

import java.util.Scanner;

import org.omg.CosNaming._NamingContextExtStub;

public class Main {

	public static void main(String[] args) {
		@SuppressWarnings("resource")
		Scanner _scanner = new Scanner(System.in);
		int M = _scanner.nextInt();
		int N = _scanner.nextInt();
		int num = 1 ;
		
		int primeCount = 0;
		
		//全体素数数表
		int[] _arrWholePrime = new int[N] ;
		//输出素数表
		int[] _arrPrime = new int[N - M + 1] ;
		
		while (true) { //遍历整个整数数表
			num ++ ;
			int count = 0;
			for (int i = 1; i <= Math.sqrt(num); i++) { //遍历从1到num的整数
				if (num % i == 0) {
					++ count; //因数计数，因数包括1和num自身，肯定>=2
				}
			}
			
			if (count == 1) {
				++ primeCount; //找到一个素数
				_arrWholePrime[primeCount - 1] = num; //素数计入数组
			} 
			
			if (primeCount == N) {
				break ;
			}
		}
		
	
		for (int j = 0; j < _arrPrime.length; j++) {
			
			_arrPrime[j] = _arrWholePrime[j + M - 1];
			
			if (((j + 1) % 10 == 0) || j == _arrPrime.length - 1) {
				System.out.println(_arrPrime[j]);
			} else {
				System.out.print(_arrPrime[j] + " ");
			}
			}

	}

}