Question

家庭作业：我只是迷住了。我已经设置了算法，但是我不知道如何编写代码

请注意，您不需要数组或通过引用传递变量。

该项目的目的是解决问题，然后使用Top-Down_Design或便笺本方法开发算法。

问题：

检查2到10000之间的数字。如果它是Dual_Prime，则输出该数字。

我将Dual Dual Prime称为两个素数的乘积。两个素数不相等的广告。因此9不是对偶素数。 15是（3 * 5）。输出每行有10个数字。

我的算法设置

第1步：找到素数。：

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

第2步：将质数存储在数组中

第3步：将每个数组彼此相乘

void Multiply_Prime_Numbers(int Array[], int Size)
{
    for (int j = 0; j < Size- 1; j++)
    {
        Dual_Prime[] =  Arr[j] * Arr[j + 1]  
    }
}

第4步：气泡排序

void Bubble_Sort(int Array[], int Size) // Sends largest number to the right
{
    for (int i = Size - 1; i > 0; i--)
        for (int j = 0; j < i; j++)
            if (Array[j] > Array[j + 1])
            {
                int Temp = Array[j + 1];
                Array[j + 1] = Array[j];
                Array[j] = Temp;
            }
}

第5步：按10行显示新数组

void Print_Array(int Array[], int Size)
{
    for (int i = 0; i < Size; i++)
    {
        cout << Dual_Prime[i] << (((j % 10) == 9) ? '\n' : '\t');
    }
    cout << endl;
}

Answer 1

我还没有学习动态数组，

虽然动态数组和Eratosthenes筛子更为可取，但我还是尝试编写最低固定版本的代码。

首先，我们定义以下全局变量，这些全局变量在您的Multiply_Prime_Numbers的原始实现中使用。（Please check this post.）

constexpr int DP_Size_Max = 10000;
int DP_Size = 0;
int Dual_Prime[DP_Size_Max];

接下来，我们如下修复Prime_Number。原始代码中的条件number%1==0不适当：

bool Prime_Number(int number)
{
    if(number<=1){
        return false;
    }

    for (int i = 2; i*i <= number; i++)
    {
        if (number % i == 0)
            return false;
    }

    return true;
}

此外，Multiply_Prime_Numbers应该通过以下双重for循环实现：

void Multiply_Prime_Numbers(int Array[], int Size)
{    
    for (int i = 0; i < Size; ++i)
    {
        for (int j = i+1; j < Size; ++j)
        {
            Dual_Prime[DP_Size] = Array[i]*Array[j];

            if(Dual_Prime[DP_Size] >= DP_Size_Max){
                return;
            }

            ++DP_Size;
        }        
    }
}

然后这些功能的工作原理如下。 Here's a DEMO of this minimally fixed version.

int main()
{
    int prime_numbers[DP_Size_Max];
    int size = 0;

    for(int j=2; j<DP_Size_Max; ++j)
    {
        if(Prime_Number(j)){
            prime_numbers[size]=j;
            ++size;
        }
    }

    Multiply_Prime_Numbers(prime_numbers, size);
    Bubble_Sort(Dual_Prime, DP_Size);

    for(int i=0; i<DP_Size;++i){
        std::cout << Dual_Prime[i] << (((i % 10) == 9) ? '\n' : '\t');;
    }
    std::cout << std::endl;

    return 0;
}

Answer 2

Sieve of Eratosthenes是一种已知的算法，可以将所有素数的搜索速度提高到一定数量。

OP可以使用它来实现其实现的第一步，但是他们也可以对其进行调整以避免排序步骤。

给出所有素数的列表（最多为要检查的最大素数的一半）：

创建一个布尔数组，该数组与要检查的数字范围一样大。
使用两个嵌套循环将每个不同的素数相乘。
如果乘积小于10000（最大值），则将数组的对应元素设置为true。否则，请打破内循环。
完成后，遍历数组，如果值为true，则打印相应的索引。

这里有一个proof of concept（在没有OP分配限制的情况下实现）。

Answer 3

// Ex10_TwoPrimes.cpp : This file contains the 'main' function. Program execution begins and ends there.


#include "pch.h"
#include <iostream>
#include <fstream>
#include <string>

using namespace std;

void Homework_Header(string Title);
void Do_Exercise();
void Sieve_Of_Eratosthenes(int n);
void Generate_Semi_Prime();

bool Semi_Prime(int candidate);
bool prime[5000 + 1];

int main()
{
    Do_Exercise();

    cin.get();
    return 0;
}

void Do_Exercise()
{
    int n = 5000;

    Sieve_Of_Eratosthenes(n);

    cout << endl;

    Generate_Semi_Prime();
}

void Sieve_Of_Eratosthenes(int n)
{
    // Create a boolean array "prime[0..n]" and initialize 
    // all entries it as true. A value in prime[i] will 
    // finally be false if i is Not a prime, else true. 

    memset(prime, true, sizeof(prime));

    for (int p = 2; p*p <= n; p++)
    {
        // If prime[p] is not changed, then it is a prime 
        if (prime[p] == true)
        {
            // Update all multiples of p 
            for (int i = p * 2; i <= n; i += p)
                prime[i] = false;
        }
    }
}

bool Semi_Prime(int candidate)
{
    for (int index = 2; index <= candidate / 2; index++)
    {
        if (prime[index])
        {
            if (candidate % index == 0)
            {
                int q = candidate / index;
                if (prime[q] && q != index)
                    return true;
            }
        }
    }
    return false;
}

void Generate_Semi_Prime()
{
    for (int i = 2; i <= 10000; i++)
        if (Semi_Prime(i)) cout << i << "\t";
}

生成2到10,000之间的数字。打印的数字只能是2个质数的倍数

3 个答案: