Bonjour et bienvenue à nouveau.
Je voulais te donner un autre défi, une autre mission.
De toute évidence, celui-ci va être tout au sujet des tableaux.
Je veux que vous vous familiarisiez avec comment pour utiliser un tableau, comment accéder à un
tableau et comment créer un tableau.
Vous devriez donc écrire un programme en c cela va trouver tous les nombres
premiers de 3 à 100.
Et nous allons faire c'est très efficace.
Nous allons donc utiliser un peu algorithme qui vous fait
utiliser un tableau, mais un programme très simple.
Il va simplement s'afficher en sortie, tous les nombres premiers de 3 à 100.
Et la raison pour laquelle vous ne faites pas 0 pour 3 est parce que vous allez les coder
en dur, c'est assez simple.
2 premiers nos 2 premiers nombres premiers sont 1 et 2 non-0.
Donc il n'y aura pas d'entrée à ce programme, sortez simplement.
Et la sortie sera chaque nombre premier séparé par un
espace sur une seule ligne.
C'est assez basique, jusqu'à 100.
Vous allez avoir besoin de créer un tableau qui stockera chaque
nombre premier au fur et à mesure de sa génération.
Vous pouvez coder en dur le premier 2 nombres premiers, qui sont 2
et 3 dans le tableau des nombres premiers.
Donc ce que j’envisage ici, c’est que vous créeriez un tableau,
vous le nommeriez premiers et vous ne feriez que codez en dur les 2 premiers là-dedans.
Et il est important de coder en dur eux aussi
parce que l'algorithme que nous allons utiliser pour trouver les nombres premiers vont se comparer pour tous
les autres nombres premiers, et Je vais vous expliquer cela dans une seconde.
Vous souhaitez utiliser les boucles pour cette affectation de trouver uniquement les nombres
premiers jusqu'à 100.
Donc dès le départ, tu devrais imaginez une boucle au moins pour afficher
les nombres premiers que vous avez trouvés.
Donc ce serait probablement la fin loop, la boucle à
la fin de votre programme qui passe simplement par le tableau nombres premiers et affiche tout
ce qui s'y trouve.
maintenant si vous trouvez tous les meilleurs nombres jusqu'à 100, vous n'aurez pas besoin de faire
la taille du tableau probablement plus de 50 parce que je ne pense pas qu'il
y ait plus de 50 prime nombres, jusqu'à 100, mais vous ne pourrez pas le définir
exactement correctement parce que vous ne savez pas combien il y a
de nombres premiers.
Donc, je dirais que lorsque vous créez le nombres premiers, faites simplement une taille de 100.
Donc, vous avez vraiment besoin d'une boucle pour les imprimer à la fin.
vous allez avoir besoin d'une autre boucle pour essayer de trouver les nombres premiers.
Et vous pouvez trouver les nombres premiers l'algorithme que vous voulez, mais ce que
j'utiliserais, c'est que j'utiliserais quelque chose comme ça car il y a plus de raisons d'utiliser un tableau si
vous utilisez cet algorithme.
Donc les critères qui peuvent être utilisés
pour identifier un nombre premier, c'est qu'un nombre est considéré comme premier s'il n'est pas divisible par
d'autres nombres premiers précédents.
Et il y a aussi plus à cet algorithme, mais c'est
le point de départ.
Vous voulez aussi seulement regarder jusqu'à un certain nombre.
Ainsi, vous pouvez utiliser ce qui suit comme un x condition dans la boucle la plus interne.
Alors encore une fois, ce dont tu vas avoir besoin pour avoir ici, vous
allez probablement avoir besoin de 2 boucles.
Nous avons déjà évoqué le troisième boucle
au bas de l'impression des données, mais vous devrez avoir 2 boucles pour cette affectation.
Et l'algorithme dont je parle voici un algorithme plus amélioré.
C'est pourquoi vous voulez le faire.
Maintenant, si vous voulez trouver des nombres premiers d'une manière différente, ce n'est pas
grave tant que vous utilisez un tableau car le
le but de l'assignation n'est pas de comprendre les nombres premiers, c'est pour comprendre comment utiliser les tableaux.
En regardant le précédent généré des nombres premiers qui vous oblige à utiliser un tableau
et vous stocker que chaque nombre premier au fur et à mesure qu'il est
généré comme je l'ai mentionné.
Et l'autre façon dont tu peux faire il est encore plus optimal que vous ne vouliez pas regarder des
nombres pairs.
Donc, si vous traversez chacun nombre de 3 à 100 et vous vérifiez
si c'est premier, vous pouvez ignorez les nombres pairs parce que les nombres pairs
ne seront jamais premiers.
Donc, dans la boucle la plus externe ou le la boucle la
plus interne, vous pouvez vérifier si le premier est divisible par le d'autres nombres premiers ou assurez-vous que ce n'est même pas vous pouvez
le vérifier et l'ignorer.
Et puis cette autre condition d'axe dans la boucle la plus interne est de
s'assurer que la valeur de p ne dépasser la racine carrée des nombres premiers, c'est une autre
partie de l'algorithme.
Donc, cela pourrait ne pas avoir de sens, mais fondamentalement, ce sont quelques-uns des critères que je
veux que vous suiviez.
Ignorez tous les chèques pour les nombres pairs, puis l'algorithme doit rechercher tous
les nombres premiers précédents qui ont été générés et aussi pour
vérifier si p ne dépasser la racine carrée des nombres premiers car c'est une
autre moyen de vérifier un nombre premier.
Alors tu vas avoir besoin d'avoir une boucle for qui va fondamentalement
de 5 à 100 et ensuite vous pouvez incrémentez cela de 2 pour ne rechercher
que les nombres impairs.
Et puis dans une boucle intérieure pour vous ayez dedans là,
vous allez vouloir passer de 1 à cet autre la valeur p divisée par le sous-I premier est supérieure à égale
au sous-I premier.
Et vous voudrez probablement aussi faire sûr que le nombre n'est pas premier.
Donc, vous ne voulez pas dépasser un certain contrôle et vous voulez également sauter hors de la boucle intérieure si
vous avez en fait trouvé un nombre premier.
Et donc la façon dont vous pouvez vérifier nombre premier si votre nombre actuel est divisible par n'importe
quel nombre premier précédent, afin que vous puissiez regarder le tableau des nombres premiers.
Et si le module pour ça est égal à 0, alors vous n'avez pas
de nombre premier.
Sinon, si vous avez fait cela tout vérifier dans toute cette
boucle et vous êtes déjà sorti de là avec le dépassement du sous-I
premier est supérieur au sous-I premier la racine carrée problème et vous n’avez pas trouvé
de nombre premier, alors cela signifie que vous pouvez ensuite ajouter ce nombre premier à votre tableau de nombres premiers, puis
imprimez simplement le tableau des nombres premiers.
Donc, l'algorithme actuel ne semble aussi déroutant que je le fais.
Encore une fois, essayez de vous donner comme beaucoup d'indices de pseudocode
que possible avec le boucle dans la boucle for intérieure.
Mais tu vas avoir besoin d'accéder
tableaux, vous allez lire des tableaux, vous allez regarder un tableau pour voir les valeurs précédentes.
Ça va t'avoir vraiment familier avec les tableaux.
Alors bonne chance, et je vous fournirai un solution dans la prochaine conférence qui aura
beaucoup plus de sens, mais ces sont les exigences et quelques hits.
Merci.