En programmation, l’algorithme est un ensemble d’orientations caractérisées de manière globale pour s’attaquer au problème.

Caractéristiques d’un algorithme décent

L’information et le rendement doivent être caractérisés sans équivoque.

Toute progression dans le calcul doit être claire et sans ambiguïté.

devrait être le meilleur parmi un large éventail d’approches pour traiter une question.

Un algorithme ne devrait pas avoir de code PC. Le calcul doit plutôt être écrit de telle sorte qu’il soit utilisé dans des dialectes de programmation comparables.

Exemples d’algorithmes dans la programmation

Ecrire un algorithme pour ajouter deux nombres entrés par l’utilisateur.

Étape 1 : Démarrage

Étape 2 : Déclarer les variables num1, num2 et somme.

Étape 3 : Lisez les valeurs num1 et num2.

Étape 4 : Additionnez num1 et num2 et attribuez le résultat à la somme.

        sum←num1+num2

Étape 5 : Afficher la somme

Étape 6 : Arrêt

Écrivez un algorithme pour trouver le plus grand parmi les trois nombres différents entrés par l’utilisateur.

Étape 1 : Démarrage

Étape 2 : Déclarer les variables a, b et c.

Étape 3 : Lisez les variables a, b et c.

Étape 4 : Si a>b

           Si a>c

              L’affichage a est le plus grand nombre.

           Autre

              L’affichage c est le plus grand nombre.

        Autre

           Si b>c

              L’affichage b est le plus grand nombre.

           Autre

              L’affichage c est le plus grand nombre. 

Étape 5 : Arrêt

Écrivez un algorithme pour trouver toutes les racines d’une équation quadratique ax2+bx+c=0.

Étape 1 : Démarrage

Étape 2 : Déclarer les variables a, b, c, D, x1, x2, rp et ip ;

Étape 3 : Calculer le discriminant

         D←b2-4ac

Étape 4 : Si D≥0

              r1←(-b+√D)/2a

              r2←(-b-√D)/2a

              Afficher r1 et r2 comme racines.

        Autre    

              Calculer la partie réelle et la partie imaginaire

              rp←b/2a

              ip←√(-D)/2a

              Afficher rp+j(ip) et rp-j(ip) comme racines

Ecrire un algorithme pour trouver la factorielle d’un nombre saisi par l’utilisateur.

Étape 1 : Démarrage

Étape 2 : Déclarer les variables n,factorielles et i.

Étape 3 : Initialisation des variables

          factorial←1

          i←1

Étape 4 : Lire la valeur de n

Étape 5 : Répétez les étapes jusqu’à ce que i=n

     5.1 : factorial←factorial*i

     5.2 : i←i+1

Étape 6 : Affichage factoriel

Étape 7 : Stop

Ecrire un algorithme pour vérifier si un nombre entré par l’utilisateur est premier ou non.

Étape 1 : Démarrage

Étape 2 : Déclarer les variables n,i,flag.

Étape 3 : Initialisation des variables

        flag←1

        i←2 

Étape 4 : Lire n de l’utilisateur.

Étape 5 : Répétez les étapes jusqu’à i<(n/2)

     5.1 Si le reste de n÷i est égal à 0

            flag←0

            Passez à l’étape 6

     5.2 i←i+1

Étape 6 : Si le drapeau = 0

           L’affichage n n’est pas primordial

        sinon

           L’affichage n est primordial

Étape 7 : Stop

Écrivez un algorithme pour trouver la série de Fibonacci jusqu’à term≤1000.

Étape 1 : Démarrage

Étape 2 : Déclarer les variables first_term, second_term et temp.

Étape 3 : Initialiser les variables d’abord_term←0 ensuite_term←1

Étape 4 : Afficher le premier_terme et le deuxième_terme

Étape 5 : Répétez les étapes jusqu’à la deuxième_term≤1000

     5.1 : temp←second_term

     5.2 : deuxième_term←second_term+premier terme

     5.3 : première_term←temp

     5.4 : Afficher second_term

Étape 6 : Arrêt

Pourquoi chaque programmeur devrait apprendre à optimiser les algorithmes

Que sont les algorithmes ?

Un calcul n’est qu’un avis de mesures à prendre pour régler un problème. Il s’agit essentiellement d’une réponse.

Par exemple, un calcul pour prendre en compte la question des facteurs peut ressembler à ceci :

Problème : trouver le factoriel de n

Initialise le fait = 1

Pour chaque valeur v dans la plage 1 à n :

    Multipliez le fait par v

Le fait contient le factoriel de n

Ici, l’algorithme est écrit en anglais. S’il était écrit dans un langage de programmation, nous l’appellerions plutôt code. Voici un code pour trouver la factorielle d’un nombre en C++.

int factorial(int n) {

    int fact = 1 ;

    pour (int v = 1 ; v <= n ; v++) {

        fait = fait * n ;

    }

    retour de fait ;

}

La programmation concerne les structures d’information et les calculs. Les structures d’information sont utilisées pour contenir des informations tandis que les calculs sont utilisés pour résoudre le problème en utilisant ces informations.

L’étude des structures et des calculs de l’information (DSA) permet d’obtenir des réponses détaillées à des questions standard et vous fait prendre conscience du fait qu’il est très productif d’utiliser chacune d’entre elles. Il vous montre également l’étude de l’évaluation de la productivité d’un calcul. Cela vous permet de choisir la meilleure des différentes décisions.

L’utilisation de structures de données et d’algorithmes rend votre code évolutif

Le temps est précieux.

Supposons qu’Alice et Bob tentent de régler un problème de base, à savoir trouver le total des 1011 nombres normaux initiaux. Alors que Bob était en train de composer le calcul, Alice l’a réalisé en démontrant qu’il est aussi fondamental que de condamner Donald Trump.

Algorithme (par Bob)

Initialiser la somme = 0

pour chaque nombre naturel n compris entre 1 et 1011 (inclus) :

    ajouter n à la somme

la somme est votre réponse

Code (par Alice)

int findSum() {

int somme = 0 ;

pour (int v = 1 ; <= 100000000000 ; v++) {

somme += v ;

}

somme de retour ;

}

Alice et Bob sont euphoriques à l’idée qu’ils pourraient fabriquer quelque chose de leur cru en quelques secondes. Et si nous nous faufilions dans leur espace de travail et que nous écoutions leur discussion.

Alice : Lançons ce code et découvrons le tout.

Sway : J’ai lancé ce code il y a quelques instants, mais il n’indique toujours pas le rendement. Que se passe-t-il ?

Oh non, quelque chose a mal tourné ! Un PC est la machine la plus déterministe. Retourner et essayer de le faire fonctionner à nouveau n’aidera pas. Donc nous devrions disséquer ce qui se passe avec ce code simple.

Deux des atouts les plus importants d’un programme pour PC sont le temps et la mémoire.

Le temps pris par le PC pour exécuter un code est :

Code de temps d’exécution = nombre d’instructions * temps d’exécution de chaque instruction

La quantité de directions dépend du code que vous avez utilisé, et le temps nécessaire pour exécuter chaque code dépend de votre machine et de votre compilateur.

Pour cette situation, le nombre total de lignes directrices exécutées (supposons que x) sera x = 1 + (1011 + 1) + (1011) + 1, soit x = 2 * 1011 + 3

Donnez-nous une chance d’accepter qu’un PC puisse exécuter y = 108 directives en une seule seconde (il peut fluctuer en fonction de la disposition de la machine). Le temps nécessaire pour exécuter le code ci-dessus est

Temps nécessaire pour exécuter le code = x/y (plus remarquable que 16 minutes)

Est-il envisageable d’améliorer le calcul dans le but qu’Alice et Bob n’aient pas besoin de s’accrocher pendant 16 minutes à chaque fois qu’ils exécutent ce code ?

Je suis certain que vous avez déjà spéculé sur la technique correcte. L’ensemble des N premiers nombres caractéristiques est donné par la recette :

Entité = N * (N + 1)/2

La conversion en code ressemblera à ceci :

int sum(int N) {

renvoyer N * (N + 1)/2 ;

}

Ce code s’exécute en une seule fois et complète la mission, quelle que soit sa valeur. Donnez-lui une chance d’être plus remarquable que le nombre total de particules connues de l’humanité. Il découvrira le résultat en un clin d’œil.

Dans ce cas, le nombre total d’instructions exécutées (disons x) est x = 1 + (1011 + 1) + (1011) + 1, soit x = 2 * 1011 + 3

Supposons qu’un ordinateur puisse exécuter y = 108

Donnez-nous une chance d’accepter qu’un PC puisse exécuter y = 108 directives en une seule seconde (il peut fluctuer exposé à la configuration de la machine). Le temps nécessaire pour exécuter le code ci-dessus est :

Temps nécessaire pour exécuter le code = x/y (plus remarquable que 16 minutes)

Est-il envisageable d’améliorer le calcul dans le but qu’Alice et Bob n’aient pas besoin de s’accrocher pendant 16 minutes à chaque fois qu’ils exécutent ce code ?

Je suis certain que vous avez déjà spéculé sur la technique correcte. L’ensemble des N premiers nombres normaux est donné par l’équation :

Entier = N * (N + 1)/2

La conversion en code ressemblera à ceci :

int sum(int N) {

renvoyer N * (N + 1)/2 ;

}

Ce code s’exécute en une seule fois et complète la mission, quelle que soit sa valeur. Donnez-lui une chance d’être plus important que le nombre total de molécules connues de l’humanité. Il découvrira le résultat en quelques instants.

Le temps nécessaire pour s’attaquer à ce problème est de 1/an (soit 10 nanosecondes). Par coïncidence, la réponse combinée d’une bombe nucléaire prend 40-50 ns, ce qui implique que votre programme se terminera efficacement, que quelqu’un lance une bombe nucléaire sur votre PC ou non, et que vous ayez ou non exécuté votre code. 🙂

Note : Les ordinateurs prennent quelques lignes directrices (et non 1) pour calculer l’augmentation et la division. J’ai dit 1 seulement pour la simplicité.