Déterminer les Nombres premiers en utilisant un SEUL-lors de la Boucle

J'ai écrit ce programme de par mon professeur de l'enseignement. Il s'avère qu'il voulait que nous n'utiliser qu'un SEUL-lors de la boucle. Alors que je n'ai techniquement faire... ce ne sera pas volée. Je ne peux pas comprendre comment le faire sans l'aide d'une boucle for ou au moins une autre boucle d'un autre type. Il a dit qu'il pourrait utiliser continue ou break états--mais qu'il pourrait ne pas être nécessaire.

Je vous serais reconnaissant de ne pas ré-écrire mon code--bien que ce soit pratique, je n'ai pas apprendre de bien.

J'apprécie toute aide.

int main() {

int max, x, n = 2; //init variables
//start n at 2 because 1 isn't prime ever

//asks user for max value
printf("Enter max number: ");
scanf("%i", &max);

/*prints prime numbers while the max value
is greater than the number being checked*/
do {
    x = 0; //using x as a flag
    for (int i = 2; i <= (n / 2); i++) {
        if ((n % i) == 0) {
            x = 1;
            break;
        }
    }
    if (x == 0) //if n is prime, print it!
        printf("%i\n", n);
    n++; //increase number to check for prime-ness
} while (n < max);

return 0;
}

Je ne vois pas comment cela peut être fait facilement avec une seule boucle. Cela impliquerait un algorithme O(1) pour la détermination de primalité. Pas une telle méthode est connue.
Êtes-vous autorisé à utiliser si les déclarations?
Je suppose que oui. Il n'a pas dit qu'on ne pouvait pas.
Êtes-vous sûr que le programme doit imprimer tous les nombres premiers en dessous d'une certaine limite? Peut-être l'entrée est censé être un numéro unique qui est ensuite testé? Cela pourrait être fait facilement avec une seule boucle. Mais pas l'ancien!
Je suis certain que c'est ce qu'il demande. Mon professeur est un peu ridicule quand il s'agit à notre connaissance de la C.-je trouver cette classe, plutôt facile -, mais ses trucs de ce genre qui me laisse de me gratter la tête.

InformationsquelleAutor Nxt3 | 2014-03-05

c do-while loops

3

C'est certainement faisable. Le truc est d'avoir un test variable, et à chaque itération par le biais de votre boucle while, vérifier la test variable à l'encontre de votre numéro actuel. Toujours commencer la test variable à 2 (chaque nombre naturel > 0 est divisible par 1)

Cas à considérer:
- Notre nombre est divisible par la variable de test -- nombre n'est PAS premier, augmenter le nombre actuel et de réinitialiser la variable de test.
- Notre variable de test est supérieure à la racine carrée du nombre actuel. Par définition, il NE peut pas diviser le nombre actuel, de sorte que le nombre actuel doit être le premier (nous avons essayé tous les nombres inférieurs à la racine carrée du nombre actuel et aucun d'entre eux diviser). Augmenter le nombre actuel et de réinitialiser la variable de test.
- Enfin, si l'un des cas ci-dessus n'est pas vrai, nous devons essayer de le prochain numéro plus élevé. Incrémentation de la variable de test.
Je n'ai pas fourni le code que vous avez demandé de ne pas l'avoir ré-écrit, mais peut fournir si vous le souhaitez.

MODIFIER
```
#include <stdio.h>
#include <math.h>

int main(void)
{
    int max = 20;
    int current = 4;
    int checker = 2;
    do{
        if(checker > sqrt((double)current))
        {
            checker = 2;
            printf("%d is prime\n",current);
            current++;
        }
        else if(current % checker == 0)
        {
            checker = 2;
            printf("%d is NOT prime\n",current);
            current++;
        }
        else
            checker++;
    }while(current < max);
}
```
De sortie:
```
4 is NOT prime
5 is prime
6 is NOT prime
7 is prime
8 is NOT prime
9 is NOT prime
10 is NOT prime
11 is prime
12 is NOT prime
13 is prime
14 is NOT prime
15 is NOT prime
16 is NOT prime
17 is prime
18 is NOT prime
19 is prime
```
- Il n'existe pas de deux boucles?
- Pas juste un do while, et un if, if else et else
- Si il n'est pas trop un problème, je voudrais voir le code. L'explication était assez, mais je pense qu'il serait utile dans cette situation.
- Ce serait le travail, mais ce n'est pas la meilleure façon d'écrire un programme de contrôle de flux. Si c'est ce que l'instructeur veut, il n'est pas l'enseignement des bonnes pratiques de programmation C!
- Je ne la vois pas. Votre explication n'est pas complète. Au moins de donner le pseudo-code. /curieux
- Modifié pour inclure de code et de sortie. Remarque: en Ignorant les 2 et 3 car ils sont triviaux et permettrait d'ajouter des conditions supplémentaires. Aussi ignorant d'obtenir les commentaires de l'utilisateur.
- Techniquement, c'est une seule boucle, mais la complexité est la même qu'avec deux boucles. 🙂 Vous combinez n'importe quel nombre de boucles for imbriquées en une seule, mais c'est illisible et vous avez besoin de beaucoup de drapeaux.
- d'accord. Juste en respectant les contraintes :). Je n'aurais jamais décider à écrire mon code de cette façon, moins d'y être forcé. Je ne sais pas pourquoi l'enseignement des nombres premiers sans l'aide de crible d'eratosthène.
InformationsquelleAutor C.B.
2

Je ne vais pas vous donner le code exact, mais deux pointeurs qui devrait vous aider:

Tout d'abord, une boucle for peut être écrite comme une boucle while (et vice versa)
```
for (int i=0; i< 100; ++i)
...
```
devient:
```
int i=0;
while (i < 100)
{
  ...
  ++i;
}
```
Deuxième, deux boucles imbriquées peuvent devenir un seul, dans un certain nombre de façons:
```
for (int i=0; i< 100; ++i)
  for (int j=0; j< 100; ++j)
    ...
```
Devient
```
for (int z=0; z< 100*100; ++z)
{
  i = z / 100;
  j = z % 100;
}
```
Ci-dessus montre deux boucles for, mais vous pouvez effectuer des transformations sur les autres boucles.

InformationsquelleAutor Roddy
0

Pense crible d'ératosthène. Dans cette méthode nous permet de trouver des numéros composés d'une table, de sorte qu'à la fin que les nombres premiers de rester. Pour des raisons de simplicité, la table ne contient que des nombres impairs. Vous commencez pointage à 3, qui est un nombre premier. Grève de 3*3, 3*5... Terminer votre course sur la table (c'est fini), point 5. Il n'est pas barré, ainsi un nombre premier. Grève au lieu de 15, 25... case 7, le premier, une grève de 21, 35... case 9, déjà barré, déplacer à 11...

Questions:
1. Vous avez juste vérifié un certain nombre, quel est le nombre suivant pour vérifier?
2. Comment savez-vous que vous avez manqué de numéros de vérifier?
Écrivez des réponses à ces questions, et vous avez une boucle le premier algorithme de recherche.

InformationsquelleAutor n.m.

Vous devez vous connecter pour publier un commentaire.