Bonjour et bienvenue.
Je souhaite fournir un démonstration une solution
à notre défi précédent qui était d'écrire un programme qui génère
des nombres premiers.
Et encore une fois, tout le point de ce programme était d'utiliser un
tableau, vous voulez tout apprendre à propos des tableaux et faites-le.
J'ai donc essayé de décrire le algorithme des nombres premiers avant.
Mais pour le mentionner à nouveau, vous pouvez vérifier si oui ou non
un nombre premier est un nombre premier.
Le nombre premier signifie que euh ce n'est pas divisible
par un autre nombre premier.
C'est donc l'algorithme de la notion que nous allons passer.
Et la raison pour laquelle c'est un nombre premier est dû au fait que tout entier non premier
peut être exprimé en tant que multiple de facteurs premiers.
Ainsi, par exemple, 20 a le facteurs premiers 2 2 et 5.
Donc en sachant cela, cela vous dit que les nombres premiers ne sont divisibles uniformément
par aucun autre nombre premier.
Cela peut donc aider à faire un très test efficace des nombres premiers.
Alors ce que tu peux faire c'est toi peut vérifier
les nombres premiers générés précédemment.
Ainsi, nous pouvons stocker notre ancien généré
des nombres premiers dans un tableau, et c'est ainsi que nous pouvez trouver ces informations.
De plus, tout entier 9 premier n doit avoir comme l'un de ses facteurs un entier
inférieur ou égal à la racine carrée de n.
Donc ça veut dire que c'est seulement nécessaire pour déterminer si un entier
donné est premier en le testant pour pair divisibilité contre tous les facteurs premiers jusqu'à
la racine carrée de l'entier.
Alors tu peux t'arrêter là et encore une fois, cela le rend plus efficace.
Cela va être perceptible dans ma boucle intérieure quand je saute
pour déterminer si je n'ont pas trouvé de nombre premier.
Je vais sauter si j'arrive à la racine carrée de l'entier, c'est essentiellement
une condition de sortie.
Alors passons en revue et le chemin que vous
pouvez vérifier c'est que vous dites simplement p divisé par des nombres premiers est supérieur au sous-I premier, et nous l'utiliserons dans la
boucle la plus interne pour tester si la valeur de p dépasse ou non
la racine carrée de I.
Alors allons-y et apportons le code blocs pour commencer à écrire du code.
Nous allons faire les bases ici, créez un projet.
Nous nommerons notre projet appelé primes.
Passons donc
au nouveau projet et passons à l'application console.
Et nous allons l'appeler premiers.
Dites ensuite, nous n'irons pas pour utiliser ce compilateur.
Je jouais avec compilateurs Je veux m'assurer d'avoir le bon
compilateur Je vais utilisez simplement le compilateur cygwin.
Donc ça génère mon principal fichier source, et il est vide.
Débarrassons-nous du printf et commencez à écrire du code.
Nous allons inclure un fichier appelé taureau standard.
Je n'ai pas encore fait cela; J'ai été créer mes booléens en tant que traits de soulignement.
Faisons juste un petit test, Je veux pouvoir faire bool.
Alors maintenant, nous pouvons utiliser des booléens.
Donc normalement dans C89, le type de données pour vrai ou faux est un booléen de soulignement.
Mais tu peux en fait avoir un type définition dans les versions ultérieures et dans le
fichier booléen standard pour utilisez simplement des booléens et vous permet
également d'utiliser true false comme valeurs.
Nous devons donc en créer variables ici en premier.
Nous allons créer notre compteur que nous allons simplement nommer p.
Ça va être notre contre pour notre boucle à partir du moment
où nous vérifions de p à 100 nombres.
Ce sera notre boucle extérieure.
Nous allons également créer un variable pour notre compteur de boucle interne.
C'est là que nous vérifions nos nombres premiers précédents.
En fait, nous ne l'initialiserons pas ici nous l'initialiserons dans la boucle.
Nous allons créer notre tableau qui va être un entier de nombres
premiers et qui va être de taille 50.
Et nous n'allons pas initialiser à tout sauf à 0 pour le moment.
Et puis nous allons créer un indice premier, et cela
nous aidera à sauter tous nos nombres pairs, et nous allons simplement mettre cela à 2.
Cette variable va en fait pour nous assurer
que nous partons du bon index car pour coder en dur les 2 premiers chiffres.
C'est ce que nous allons faire en premier.
Nous allons coder en dur nos 2 premiers nombres premiers.
C'est ainsi que nous pouvons accéder au tableau.
On sait créer un tableau en ligne 10, il vous suffit de spécifier le type
de données suivi du nom, puis dans le crochets nous spécifions la taille.
Et puis nous initialisons tout à 0, c'est un trait
C99 que nous pouvons faire.
Et pour affecter des données à un tableau, Je peux simplement dire le nom du
tableau, puis la valeur d'index.
N'oubliez pas que les tableaux sont basés sur 0.
Donc je vais dire premier sub-0.
Et le premier prime sera 2.
2 est le premier nombre premier.
Le deuxième nombre premier est va être égal à 3.
De cette façon, j'ai du prime nombres
que je peux tester auparavant pour trouver des nombres premiers supplémentaires.
Et maintenant vient notre boucle.
Nous allons avoir besoin de l'extérieur pour boucle qui parcourt tous
les nombres de 5 à 100.
On sait que 4 n'est pas un nombre premier donc je ne fais que commencer à 5.
On peut donc dire que 4 p est égal à 5, p est inférieur ou égal à 100, puis nous
allons sauter les nombres pairs.
Alors nous allons dire p est égal à p plus 2.
Nous n'avons pas besoin de regarder en chiffres, ce sera notre boucle extérieure.
Et encore une fois, tu devrais être tester au fur et à mesure.
Maintenant, nous allons également définir une variable booléenne qui nous dira si oui ou non
nous avons trouvé un nombre premier.
Alors, voici où je peux utiliser bool, et je vais simplement
créer une variable locale Boolean is prime.
Je vais avoir cela initialisé dire est vrai parce que je ne le définirai sur faux
que si j'ai parcouru toute la liste des nombres
premiers générés précédemment ou Je suis au dernier prime et je m'assure que ce n'est pas
la racine carrée.
Alors est-ce que prime va être égal à vrai pour chaque
itération de 5 à 100 saut 2.
Maintenant ma boucle intérieure va aller à travers tous nos nombres premiers que
nous avons précédemment générés.
Fais que nous ne soyons pas allés plus loin que la racine carrée du I.
Alors nous allons passer par tout les nombres jusqu'à ce que nous arrivions à la racine carrée, cela
peut être notre condition x.
On va aussi sortir si nous trouvons un nombre premier.
Alors on va dire si c'est le meilleur est vrai et nous
avons dépassé notre limite, qui va être p divisé par le premier sous-I est supérieur ou
égal aux nombres premiers sous-I.
Et puis nous allons plus plus I est notre variable de contrôle de boucle.
C'est vraiment le clé de l'algorithme.
Alors nous allons essayer de trouvez tous nos nombres
premiers de 5 à 100 en sautant des nombres pairs.
Et puis dans notre boucle intérieure, nous sommes va commencer
à 1, nous allons aller jusqu'au bout jusqu'à ce que nous définissions est premier à vrai ou nous avons atteint notre condition
de sortie, qui est le le nombre p divisé par le sous-I premier est supérieur au sous-I
premier, et c'est finissant essentiellement à faire notre lorsque nous trouvons une racine carrée parce
que c'est une autre condition de l'algorithme.
Si c'est notre boucle, à l'intérieur de notre boucle, nous allons en
fait vérifier les nombres premiers.
La façon dont un nombre est premier est-ce que vous le divisez par le nombre.
Et si vous n'avez pas de 0, alors vous êtes prêt à partir.
Donc vous pouvez juste faire un p mod premier sub-I est égal à 0.
Et si c'est vrai, alors vous n'avez
pas de nombre premier.
Ainsi, vous pouvez définir le Boolean égal à false.
Et puis c'est ce que nous faisons pour toute la boucle parce que tout ce que
nous faisons, c'est que nous allons pour définir la valeur booléenne sur false.
Et cela nous dira que nous ne l'avons pas fait trouver un nombre premier, donc nous ne
voulons pas ajouter p à notre tableau de nombres premiers.
Ok, donc la dernière chose à faire est que vérifiez si le booléen était défini sur true,
s'il était défini sur true, nous voulons remplir notre tableau.
Nous voulons l'ajouter au tableau. Étaient donc en ajoutant aux tableaux, nous trouvons prime.
Donc nous disons juste les nombres premiers et alors nous disons indice premier.
Parce que, souviens-toi, c'est celui-là qui est vraiment représenté par l'indice
où nous voulons mettre le tableau, que nous voulons commencer à l'élément 3 qui
est l'index 2.
Nous voulons donc nous assurer de le mettre le bon endroit dans le tableau, et
nous l'avons juste mis à p parce que p était le nombre premier qui nous avons trouvé parce que rappelez-vous que c'est la boucle extérieure pour.
Nous essayons de vérifier si c'est un nombre premier.
Nous commençons à 5.
On dit que si 5 va être premier, si nous pouvons aller à ces nombres à partir de 1, puis comparer
avec n'importe quel nombres premiers précédents et s'il n'est pas divisible par 0, alors
nous sommes bons et nous devons le faire pour tout.
Et puis la dernière chose que nous que nous voulons
simplement augmenter cet indice premier.
Alors la prochaine fois que nous trouvons un prime nombre, nous sommes dans le bon index.
Et c'est tout.
Et c'est le tout algorithme pour trouver des nombres premiers.
Donc tu veux sauver ça et construire assurez-vous que tout va bien.
Etait bon.
Alors j'aime ajouter le vrai faux les valeurs en incluant le booléen
standard, n'oubliez pas cela.
Et puis la dernière chose que nous nous devons simplement
imprimer les nombres premiers.
Nous pouvons donc avoir une simple boucle for.
Et nous allons les imprimer tous sur la même ligne, nous n'allons donc pas
ajouter un saut de ligne.
Donc ce que nous allons faire est nous allons ré-instancier
notre variable de contrôle de boucle à 0 I.
Nous allons aller jusqu'à notre index prime, qui sera la taille de
tout dans le tableau et imprimez-le simplement sur une seule ligne,
pour cent I ou d et premier sous-I.
Et puis à la toute fin, nous ajouterons un saut de ligne.
Quelque chose comme ça avec un point-virgule.
Mais encore une fois, les choses à remarquez dans ce programme.
Tout d'abord, remarquez l'indentation, tous les blocs sont en retrait.
Nous utilisons parfois des parenthèses lorsque nous ont plus d'une déclaration à l'intérieur
de nos blocs, parfois nous n'en avons pas.
Dans cette déclaration si en ligne 25, nous n'avons utilisé aucune parenthèse.
Les boucles car devraient devenir quelque peu une seconde nature maintenant.
Vraiment ce que vous voulez gagner cette affectation est les tableaux.
Nous créons donc un tableau appelé nombres premiers, en le réglant sur 50, en initialisant tout à 0
Et puis nous établissons le premier 2 éléments
à 2 et 3 puis tout cet algorithme de 19 à les lignes 32 déterminent
s'il est premier en regardant le tableau dans les nombres premiers précédents.
Et aussi sauter quand tu es supérieur à la racine carrée.
Et donc encore une fois, vous voyez beaucoup de crochets ici pour accéder
aux tableaux et attribuer des valeurs aux tableaux et
tout, c'est assez simple.
Alors construisons ça et voyez ce qui se passe.
Nous n'avons aucun avertissement, aucune erreur.
Si nous exécutons ceci, ce que vous voyez est sortie est tous les nombres premiers à
100 2 3 5 7 11 13 17 19 23 29 31 37 41 43 et ainsi de suite.
Ce sont tous des nombres premiers.
Et le nombre premier est quelque chose qui seulement n'était qu'un facteur en soi.
Vous ne pouvez pas diviser cela par un autre numéro et n'ont pas de reste.
Donc 97 les 2 seuls facteurs qui entrez dans ce sont 1 et 97.
Donc encore une fois un joli petit programme rapide.
Je vais fournir la solution.
Vous pouvez l'analyser.
Mais encore une fois, les points à retenir, tout à propos des tableaux et aussi du booléen
standard que j'ai utilisé, que nous a permis de créer des types
de données booléens sans la majuscule de soulignement b et vous permet également
d'utiliser de vraies fausses valeurs par opposition à 1 et 0.
J'espère que cela t'aides. Merci.