Les tableaux en c exercices corrigés – Langage C

Exercice N°1 sur les Tableaux en C

Ecrire un programme qui permet de compacter les éléments du tableau tab. Cette opération consiste à supprimer les valeurs nulles du tableau.

Solution

#include<stdio.h>

#define MAX 100

void main()

{

    int n,i=0,val;

    int tab[MAX];

    do{

        printf(“Donner la taille du tableau \n”);

        scanf(“%d”,&n);

    }while(n<=0);

    printf(“Donner T[0] \n”);

    scanf(“%d”,&tab[0]);

    for(i=1;i<n;i++)

    {

        printf(“Donner T[%d] \n”,i);

        scanf(“%d”,&tab[i]);

    }

    for(i=0;i<n;i++)

    {

        printf(” %d |”,tab[i]);

    }

int j=0;

i=0;

while(i<n)

{

    if(tab[i]==0)

    {

        n–;

        j=i;

        while(j<n)

        {

            tab[j]=tab[j+1];

            j++;

        }

    }

if (tab[i]!=0) {i++;}

}

printf(“\n”);

for(i=0;i<n;i++)

    {

        printf(” %d |”,tab[i]);

    }

}

Exercice N°2 sur les Tableaux en C

Ecrire un algorithme permettant de saisir au clavier un indice i, en prenant soin de vérifier que cet indice est positif et inférieur au nombre d’éléments, et d’insérer une valeur v saisie au clavier à la position i (dans le cas où le nombre d’éléments reste inférieur au max), les valeurs suivantes devront alors être décalées).

Solution

#include<stdio.h>

//#include<conio.h>

void main()

{

    int n=4,i,v,t[3];

    t[0]=1;

    t[1]=2;

    t[2]=3;

    t[3]=4;

printf(“%d %d %d %d \n”,t[0],t[1],t[2],t[3]);

do{

    printf(“Donner i \n”);

    scanf(“%d”,&i);

}while((i<0)||(i>n));

    printf(“Donner une valeur \n”);

    scanf(“%d”,&v);

int j=n;

while(j>(i+1))

{

    t[j]=t[j-1];

    j–;

}

t[i]=v;

printf(“%d %d %d %d”,t[0],t[1],t[2],t[3]);

}

Exercice N°3 sur les Tableaux en C

Ecrire un algorithme qui détermine la plus grande et la plus petite valeur dans un tableau d’entiers A. Afficher ensuite la valeur et la position du maximum et du minimum. Si le tableau contient plusieurs maxima ou minima, le programme retiendra la position du premier maximum ou minimum rencontré.

Solution

#include<stdio.h>

#define

void main()

{

    int n=5,i=0,t[n];

    t[0]=3;

    t[1]=1;

    t[2]=1;

    t[3]=5;

    t[4]=5;

    int imax=-1,imin=-1,max=t[0];

    int min=t[0];

    while(i<n)

    {

        printf(“%d | “,t[i]);

        i++;

    }

printf(“\n”);

i=0;

    while(i<n)

    {

        if (t[i]>max){ max=t[i]; imax=i;}

        if(t[i]<min) {min=t[i]; imin=i;}

        i++;

    }

printf(“le max est %d d’indice %d \n”,max,imax);

printf(“le min est %d d’indice %d \n”,min,imin);

}

Exercice N°4 sur les Tableaux en C

Ecrire un algorithme permettant de réaliser les opérations suivantes :

• Lire au clavier les n valeurs du tableau, dans un ordre croissant, c’est à dire qu’une valeur lue est acceptée seulement si elle est supérieure à la précédente.
• Lire au clavier une valeur v.
• Insérer cette valeur dans le tableau de façon à maintenir l’ordre croissant.

Solution

#include <stdio.h>

#define MAX 100

void main()

{

    int n,i=0,val;

    int tab[MAX];

    do{

        printf(“Donner la taille du tableau \n”);

        scanf(“%d”,&n);

    }while(n<=0);

    printf(“Donner T[0] \n”);

    scanf(“%d”,&tab[0]);

    for(i=1;i<n;i++)

    {

        do{printf(“Donner T[%d] \n”,i);

        scanf(“%d”,&tab[i]);

          }while(tab[i]<tab[i-1]);

    }

    for(i=0;i<n;i++)

    {

        printf(” %d |”,tab[i]);

    }

printf(“\n”);

printf(“Donner une valeur \n”);

scanf(“%d”,&val);

i=0;

int m;

int j;

int test=1;

while(i<n&&val>=tab[i])

{

    i++;

}

if(val<tab[i])

{

m=n;

while(m>i)

{

    tab[m]=tab[m-1];

    m–;

}

tab[i]=val;

n++;

}

/*while((i<n)&&(test==1))

{

    if(i==0)

    {

        if (val<tab[0])

        {

            m=n+1;

            while(m>0)

            {

                tab[m]=tab[m-1];

                m–;

            }

            tab[0]=val;

            test=0;

        }

    }

    else

    {

        if((val<tab[i])&&(val>tab[i-1]))

        {

            m=n+1;

            while(m>i)

            {

                tab[m]=tab[m-1];

                m–;

            }

            tab[i]=val;

            test=0;

        }

        else if(i==n-1)

        {

            if(val>tab[n-1])

            {

            tab[n]=val;

            test=0;

            }

        }

    }

i++;

}

n++;*/

for(i=0;i<n;i++)

{

        printf(” %d |”,tab[i]);

}

}

Exercice N°5 sur les Tableaux en C

Ecrire un algorithme qui détermine si une matrice carrée est symétrique ou non. Une matrice est symétrique si Mij = Mji pour 0<=i<n et 0<=j<n.

Solution

#include<stdio.h>

#define L 100

#define C 100

void main()

{

    int mat[L][C];

    int l,c;

    int i,j;

    int test=1;

    do{

        printf(“Donner ne nb de Ligne et de colonne \n”);

        scanf(“%d %d”,&l,&c);

    }while(l!=c);

    for(i=0;i<l;i++)

    {

        for(j=0;j<c;j++)

        {

            printf(“Donner mat[%d][%d]: “,i,j);

            scanf(“%d”,&mat[i][j]);

        }

    }

    for(i=0;i<l;i++)

    {

        for(j=0;j<c;j++)

        {

            printf(” %d |”,mat[i][j]);

        }

        printf(“\n”);

    }

i=0;

j=0;

  while((test==1)&&(i<l))

  {

      while((test==1)&&(j<c))          

      {if(mat[i][j]==mat[j][i])j++;    

      else{test=0;}                     

      }        

      i++;

  }

  if(test==1) printf(“Symétrique”);

  else

  printf(” NON Symétrique”);

}

Voir aussi :

Partagez au maximum pour que tout le monde puisse en profiter

The post Tableaux en C exercices corrigés – Langage C first appeared on F2School.

L’article Tableaux en C exercices corrigés – Langage C est apparu en premier sur F2School.

Les Instructions itératives Exercices corrigés – Langage C

Exercice 1 sur les Instructions itératives

Ecrire un algorithme qui lit un réel x et un enter positif p et affiche x puissance p.

Solution

#include <stdio.h>

#include <math.h>

void main()

{

    float r;

    int n;

    printf(“Donner un reel: \n”);

    scanf(“%f”,&r);

    do

    {

        printf(“Donner un entier :\n”);

        scanf(“%d”,&n);

    }while(n<0);

    float puiss= pow(r,n);

    printf(“%f ^ %d = %f”,r,n,puiss);

}

Exercice 2 sur les Instructions itératives

Ecrire un algorithme qui lit un entier positif et affiche sa factorielle.

n! = n*(n-1)*….*3*2*1

0! = 1

Solution

#include <stdio.h>

void main()

{

int n;

     do

    {

        printf(“Donner un entier :\n”);

        scanf(“%d”,&n);

    }while(n<0);

    int i=1;

    int fact;

    if(n!=0)

    {

    fact=n;

    for(i=1;i<n;i++)

    {

    fact=fact*(n-i);

    }

    }

    else fact=1;

    printf(“Le factotiel de %d est %d”,n,fact);

}

Exercice 3 sur les Instructions itératives

Ecrire un algorithme qui lit 20 valeurs réelles et qui détermine la moyenne des valeurs strictement positives et la moyenne des valeurs strictement négatives.

Exercice 4 sur les Instructions itératives

Ecrire un algorithme qui permet d’afficher les n premiers entiers impairs dans l’ordre décroissant, n étant un entier positif saisi au clavier.

Exercice 5 sur les Instructions itératives

Ecrire un algorithme qui permet de lire pour 35 étudiants leurs notes en programmation, électronique et en anglais et d’afficher pour chaque étudiant sa moyenne et la moyenne de la classe pour chaque matière.

Exercice 6 sur les Instructions itératives

Ecrire un algorithme qui saisit un nombre et qui détermine combien de fois il est divisible par deux.

Exemples

• 11 est divisible 0 fois par 2
• 8 est divisible 3 fois par 2
• 4 est divisible 2 fois par 2

Exercice 7 sur les Instructions itératives

Ecrire un algorithme qui calcule le produit de deux entiers positifs sans utiliser l’opérateur de multiplication.

Ecrire un algorithme qui calcule le quotient de deux entiers positifs sans utiliser l’opérateur de division.

Exercice 8 sur les Instructions itératives

Ecrire un algorithme qui lit un entier positif et affiche si c’est un nombre premier ou non.

Exercice 9 sur les Instructions itératives

Ecrire l’algorithme d’Euclide qui permet de calculer le PGCD de deux nombres entiers x et y. Cet algorithme consiste à effectuer la division entière de x par y (x supposé > à y) si cette division possède un reste non nul on affecte à x la valeur de y et à y la valeur de ce reste non nul.

On répète ce processus tant que le reste n’est pas nul. Lorsque le reste est nul, le PGCD des deux nombres initiaux est le dernier nombre utilisé.

Exercice 10 sur les Instructions itératives

Ecrire un algorithme qui affiche la liste des nombres parfaits compris entre 1 et n (n étant un nombre positif saisi au clavier). Un nombre est dit parfait s’il est égal à la somme de ses diviseurs. Exemple : 6=3+2+1

Exercice 11 sur les Instructions itératives

Ecrire un algorithme qui affiche la liste des nombres d’Armstrong compris entre 1 et n (n étant un nombre positif saisi au clavier). Un nombre d’Armstrong est égal à la somme des cubes de ses chiffres.

Exercice 12 sur les Instructions_itératives

Ecrire un algorithme qui permet de saisir une suite de chiffres se terminant par 0, et qui calcule et affiche le nombre constitué des chiffres lus à l’envers.

Exemple :

Si la suite est constituée des chiffres : 5,3,8,2,0

Alors le programme devra afficher le nombre 2835

Voir aussi :

Partagez au maximum pour que tout le monde puisse en profiter

The post Les Instructions itératives Exercices corrigés – Langage C first appeared on F2School.

L’article Les Instructions itératives Exercices corrigés – Langage C est apparu en premier sur F2School.

Exercices corrigés sur les pointeurs et fonctions – Langage C

Exercices corrigés sur les pointeurs et fonctions N°1 – Langage C

Écrire une fonction qui permet de rechercher dans un tableau d’entiers tab une valeur A. void chercherVal (int tab[], int n, int A, int *pos, int *nb_occ); Dans pos, la fonction sauvegarde l’indice de la dernière apparition et -1 si la valeur n’a pas été trouvée. Dans nb_occ, elle sauvegarde le nombre d’occurence de A dans tab.

Solution

#include<stdio.h>

#define N 100

void chercherVal (int tab[], int n, int A, int *pos, int *nb_occ);

// int *tab ========== int tab[]//µµµµ*******************************

void saisie(int *ptab,int *pn); //ou int tab[]

void affiche(int tab[],int n);

void main()

{

int tab[N],n,val,nb_occ=0,pos=-1;;

saisie(tab,&n);

affiche(tab,n);

printf(“\n Donner la val a chercher \n”); // SERT LORSKE unr fction A appelle B et B appelle A

scanf(“%d”,&val);

chercherVal(tab,n,val,&pos,&nb_occ);

if(nb_occ==0 )printf(“NEXISTE PAS”);

else printf(“Existe %d fois à la position %d “,nb_occ,pos);

}

void chercherVal (int tab[], int n, int A, int *pos, int *nb_occ)

{

    int i=0;

    while(i<n)

    {

        if(tab[i]==A)

        {

            //nb_occ=*nb_occ+1;

           (*nb_occ)++;

            *pos=i;

        }

        i++;

    }

}

void saisie(int *ptab,int *pn) //ou int tab[]

{

    int i;

    do{

        printf(“Donner la taille du tableau \n”);

        scanf(“%d”,pn);

    }while(*pn<=0);

    for(i=0;i<*pn;i++)

    {

        printf(“Donner tab[%d] “,i);

        scanf(“%d”,ptab+i); // OU &tab[i]

    }

}

void affiche(int tab[],int n)

{

     int i;

     for(i=0;i<n;i++)

    {

        printf(” %d | “,tab[i]);

    }

}

Exercices corrigés sur les pointeurs et fonctions N°2 – Langage C

On souhaite écrire une fonction qui permet de résoudre une équation du premier degré : ax+b=0. Voici le prototype de la fonction :           int resoudre1(int a, int b, float *x);

la fonction retourne le nombre de solution trouvé (0: pas de solution, 1: une solution, -1: tout x est solution). Dans le cas où l’équation a une solution, la fonction retourne la solution dans x.

Solution

#include <stdio.h>

int resoudre1(int a, int b, float *x);

int main()

{

    int a,b;

    float x;

    int res;

    printf(“Donner a et b de ax+b \n”);

    scanf(“%d %d”,&a,&b);

    res=resoudre1(a,b,&x);

    if(res==0) printf(“Pas de resultat de %d X+ %d “,a,b);

    else if(res==-1) printf(“les solutions de %d X+ %d : X appartient a R”,a,b);

    else (“Unique resultat de %d X+ %d est %.3f”,a,b,x);

    return 0;

}

int resoudre1(int a, int b, float *x)

{

    if ((a==b)&&(b!=0)) return 0;

    if((a==0)&&(b==0)) return -1;

    *x=-(float)b/a;

    return 1;

}

Exercices sans corrigés sur les pointeurs et fonctions N°1 – Langage C

Exercice 3

1. Écrire une fonction : supprimer_nul, qui permet de supprimer la première valeur nulle d’un tableau d’entier passé en paramètre.

2. Écrire une fonction : nb_occurrence, qui étant donnés un tableau T de n entiers et un entier x, détermine puis retourne le nombre d’occurence de x dans T.

3. Écrire une fonction : compacter, qui permet de compacter les éléments du tableau tab. Cette opération consiste à supprimer toutes les valeurs nulles du tableau.

Astuce: utiliser nb_occurrence pour trouver nb, nombre de répétition de zéro dans le tableau, puis appeler supprimer_nul nb fois.

Exercice 4

Écrire une fonction qui détermine les indices de la plus grande valeur dans imax et la plus petite valeur dans imin d’un tableau d’entiers.

void maxima (int tab[], int n, int *imax, int * imin);

Si le tableau contient plusieurs maxima ou minima, la fonction retiendra la position du premier maximum ou minimum rencontré.

Exercice 5

Écrire une fonction qui détermine si une matrice carrée est symétrique ou non. La fonction retourne 1 si oui et 0 si non.

Une matrice est symétrique si Mij = Mji pour 0<=i<n et 0<=j<n.

Voici le prototype de la fonction:       int estSymetrique (int M[MAX][MAX], int n);

Avec MAX est une constante.

Exercice 6

Écrire une fonction qui permet de rechercher dans un tableau d’entiers tab une valeur A.  int chercherTab (int tab[], int n, int A, int *pos);

La fonction retourne le nombre d’occurrence si A existe dans le tableau et 0 si non. Dans pos, elle retourne l’indice de la dernière apparition de la valeur dans le tableau et -1 si la valeur n’a pas été trouvée.

Exercice 7

Soit une matrice A à deux dimensions NxN. Un « point col » est un élément de la matrice qui est minimum de sa ligne et maximum de sa colonne ou inversement.

1. Ecrire une fonction estMaxLigne qui retourne 1 si une valeur M est la plus grande sur toute la ligne L.

2. Ecrire une fonction estMinColonne qui retourne 1 si une valeur M est la plus petite sur toute la colonne C.

3. Ecrire une fonction chercherPointCol qui affiche les coordonnées de tous les points cols d’une matrice A. La fonction retourne le nombre de point col trouver.

Voici les prototypes des fonctions demandées :

int estMaxLigne (int A[][], int N, int M, int L);

int estMinColonne (int A[][], int N, int M, int C);

int chercherPointCol (int A[][], int N);

Exercice 8

On souhaite écrire une fonction qui permet de résoudre une équation du second degré. Voici le prototype de la fonction:                 

  int resoudre2(int a, int b, int c, float *x1, float *x2);

la fonction retourne le nombre de solution trouvé (0: pas de solution, 1: une solution, 2: une solutions, -1: tout x est solution). Dans le cas où l’équation a une solution, la fonction retourne la solution dans x1. Dans le cas où l’équation a deux solutions, la fonction retourne les solutions dans x1 et x2.

Voir aussi :

Partagez au maximum pour que tout le monde puisse en profiter

The post Exercices corrigés sur les pointeurs et fonctions – Langage C first appeared on F2School.

L’article Exercices corrigés sur les pointeurs et fonctions – Langage C est apparu en premier sur F2School.

Exercices corrigés langage c – Instructions Simples

Exercice 1

Écrire un algorithme qui calcule et affiche le quotient et le reste de la division entière de deux nombres entiers saisis au clavier.

Solution

#include <stdio.h>

void main()

{

int a,b;

float rest,quot;

printf(“donner deux entiers: \n”);

scanf(“%d %d”,&a,&b);

rest=a%b;

quot=a/b;

printf(“le quotient de a/b est %.1f \n le reste de a/b est %.1f”,quot,rest);

}

Exercice 2

Écrire un algorithme qui calcule et affiche la résistance équivalente à trois résistances (dont les valeurs sont saisies au clavier) branchées en série et en parallèle. On rappelle que :

Rs_érie = R1+ R2 + R3                       R_parallèle= (R1+R2+R3)/(R1R2+R1R3+R2R3)

Solution

#include <stdio.h>

void main()

{

float r1,r2,r3,rs,rp;

printf(“donner trois resistances: \n”);

scanf(“%f %f %f”,&r1,&r2,&r3);

rs=r1+r2+r3;

rp=rs/((r1*r2)+(r1*r3)+(r2*r3));

printf(“Rs= %.3f \nRp= %.3f “,rs,rp);

}

Exercice 3

Écrire un algorithme qui permet d’échanger les valeurs de 3 entiers saisis au clavier (valeur de B en A, valeur de C en B, valeur de A en C).

Solution

#include <stdio.h>

void main()

{

int a,b,c,aux;

printf(“donner trois entiers: \n”);

scanf(“%d %d %d”,&a,&b,&c);

printf(“avant permutation:\n     a=%d    \n     b=%d \n     c=%d \n”,a,b,c);

aux=a;

a=c;

c=b;

b=aux;

printf(“après permutation:\n     a=%d \n     b=%d \n     c=%d “,a,b,c);

}

Exercice 4

Un ouvrier est payé 3.397 DT par heure et 4.322 DT pour les heures supplémentaires. Il subit une retenue de base de 2.2% sur son salaire brut (le salaire brut est le salaire obtenu en tenant compte des heures de base et des heures supplémentaires).

Écrire un algorithme qui, connaissant le nombre d’heures de base et le nombre d’heures supplémentaires, permet de calculer le salaire final de l’ouvrier.

Solution

#include <stdio.h>

void main()

{

const int ph=2;

const int phs=2;

int nbh,nbhs;

float sbrut,sfinal;

printf(“donner nombre d’heures de base et supplementaire: \n”);

scanf(“%d %d”,&nbh,&nbhs);

int r=ph;

int rs=phs;

sbrut=(nbh*ph)+(nbhs*phs);

sfinal=(97.8*sbrut)/100;

printf(“Votre salaire finanl est %f “,sfinal);

}

Exercice 5

Écrire un algorithme qui permet de calculer la somme de 4 valeurs saisies au clavier

•  en utilisant 5 variables
• en utilisant 2 variables

Solution

#include <stdio.h>

void main()

{

int a,b,c,d,s;

printf(“donner 4 entiers \n”);

scanf(“%d %d %d %d”,&a,&b,&c,&d);

s=a+b+c+d;

printf(“somme = %d \n”,s);

// METHODE 2

int v1,v2=0;

printf(“AUTRE METHODE DE 2 VAR : \n donner 1 entiers \n”);

scanf(“%d”,&v1);

v2=v2+v1;

printf(“donner 1 entiers \n”);

scanf(“%d”,&v1);

v2=v2+v1;

printf(“donner 1 entiers \n”);

scanf(“%d”,&v1);

v2=v2+v1;

printf(“donner 1 entiers \n”);

scanf(“%d”,&v1);

v2=v2+v1;

printf(“La somme est s= %d \n”,v2);

}

Exercice 6

Dire si le nom de ces variables est valide ou non valide.

Solution

#include <stdio.h>

void main()

{

int prod_a;

int $total;

int Newbal;

int moyenne;

//int 9ab6; faux

int _c3;

int c123;

//int new bal; faux

//int sum.of; faux

int grade1;

int Abcd;

//int 1234; faux

Exercice 7

Écrire un algorithme qui calcule la surface d’un cercle sachant que son rayon est 2.59. Surface = rayon2 * 3.14

Solution

#include <stdio.h>

#include <math.h>

#define pi 3.14

void main()

{

const float r=2.59;

float s=pow(r,2)*pi;

//sqrt(x) racine carré

//pow(a,b) puisssance de a^b

printf(“%.3f”,s);

}

Exercice 8

Écrire un algorithme qui calcule le volume d’un cylindre sachant que son rayon est 5.2 et sa profondeur est de 2.8. Volume = rayon2 * 3.14 * profondeur.

Solution

#include <stdio.h>

#include <math.h>

#define pi 3.14

void main()

{

const float r=5.2;

const float h=2.8;

float v=pow(r,2)*pi*h;

//sqrt(x) racine carré

//pow(a,b) puisssance de a^b

printf(“%.3f”,v);

}

Exercice 9

Écrire un algorithme qui convertit une température en degré Fahrenheit en une température degré celsius. Sachant que la température en degré Fahrenheit est égale à 41.  temp _cal = 5/9×(temp_far-32)

Solution

#include <stdio.h>

void main()

{

const float tmpf=62;

float tmpc;

tmpc=(5.0/9.0)*(tmpf-32);

printf(“%f”,tmpc);

}

Télécharger les Exercices corrigés langage c – Instructions Simples Format word

Partagez au maximum pour que tout le monde puisse en profiter

The post Exercices corrigés langage c – Instructions Simples first appeared on F2School.

L’article Exercices corrigés langage c – Instructions Simples est apparu en premier sur F2School.

Architecture et programmation des Microcontrôleurs

Les PICs sont des microcontrôleurs à architecture RISC (Reduced Instructions Set Computer), ou encore composant à jeu d’instructions réduit. L’avantage est que plus on réduit le nombre d’instructions,  plus leur décodage sera rapide ce qui augmente la vitesse de fonctionnement du microcontrôleur.

Les PICs sont subdivisés en 3 grandes familles :

•  La famille Base-Line, qui utilise des mots d’instructions de 12 bits,
• La famille Mid-Range, qui utilise des mots de 14 bits (et dont font partie les 16F8xx),
• La famille High-End, qui utilise des mots de 16 bits (les PIC 18Fxxx).

On trouve aussi des familles de dsPIC pour le traitement du signal et d’autres microcontrôleurs spécialisés.

Les éléments essentiels du PIC 16F877 sont :

• Une mémoire programme de type EEPROM flash de 8K mots de 14 bits,
• Une RAM donnée de 368 octets,
• Une mémoire EEPROM de 256 octets,
• 5 ports d’entrée sortie, A (6 bits), B (8 bits), C (8 bits), D (8 bits) et E (3 bits)
• Convertisseur Analogique numérique 10 bits à 8 entrées sélectionnables,
• USART, Port série universel, mode asynchrone (RS232) et mode synchrone
• SSP, Port série synchrone supportant I2C
• 3 TIMERS avec leurs Prescalers, TMR0, TMR1, TMR2
• 2 modules de comparaison et Capture CCP1 et CCP2
• 15 sources d’interruption,

Les différents constituants d’un microprocesseur peuvent être regroupés dans deux blocs principaux, l’unité de calcul et l’unité de contrôle.

1- L’unité de calcul

Elle est constituée de l’unité Arithmétique et logique UAL et d’un certain nombre de registres

• ALU : Unité arithmétique et logique
• Les registres : Ce sont des mémoires élémentaires pouvant contenir chacun un opérande. Les registres peuvent être de 8, 16 ou 32 bits.

2-  L’unité de contrôle

C’est l’unité de contrôle qui supervise le déroulement de toutes les opérations au sein du microprocesseur. Elle est constituée principalement de :

• Horloge : C’est l’horloge qui génère les signaux qui permettent le cadencement et la synchronisation de toutes les opérations.
• Le compteur programme PC : (Program Counter) contient l’adresse de la case mémoire où est stockée la prochaine instruction à charger. Au début de l’exécution d’un programme, le PC est initialisé à l’adresse mémoire où est stockée la première instruction du programme. Le compteur programme est incrémenté chaque fois qu’une instruction est chargée dans le microprocesseur.
•  Le registre d’instruction RI : C’est là où le microprocesseur stocke l’instruction en cours d’exécution.
• Le décodeur : C’est lui qui va “décoder” l’instruction contenue dans RI et générer les signaux logiques correspondants et les communiquer au séquenceur.
• Le séquenceur : Il gère le séquencement des opérations et génère :
  • les signaux du bus de commande (RD, WR, etc.),
  • les signaux internes aux microprocesseurs (gestion des registres, de l’A.L.U., aiguillages des bus internes, etc.).

Le séquenceur est réalisé avec une structure qui comprend une mémoire ROM intégrée. Celle-ci contient des micro-instructions (à ne pas confondre avec les instructions contenues dans la mémoire programme). La mémoire des micro-instructions n’est pas accessible à l’utilisateur. Chacune des instructions du microprocesseur nécessite plusieurs micro-instructions et donc plusieurs cycles horloge.

• Le registre d’état : Le registre d’état est formé de plusieurs bits appelés drapeaux ou indicateurs (Flags) qui sont positionnés par l’ALU après chaque opération. On dispose d’un jeu d’instructions conditionnées par l’état de différents drapeaux. Par exemple l’indicateur Z indique, quand il est positionné, que le résultat de l’opération est égal à Zéro. L’indicateur C indique que l’opération a généré une retenue. Le bit N indique que le résultat est négatif …

Type d’architecture d’un microprocesseur

1- Architecture CISC (Complex Instruction Set Computer)

C’est une architecture avec un grand nombre d’instructions. Le processeur doit exécuter des taches complexes par instruction unique. Donc, pour une tache donnée, une machine CISC exécute un petit nombre d’instructions mais chacun nécessite un plus grand nombre de cycles horloge (Intel 8086, Pentium…, Motorola 68000, PowerPC). Actuellement les deux technologies convergent : les processeurs CISC (Pentium par exemple) utilisent des instructions de plus en plus simples et exécutent parfois plusieurs instructions en un cycle horloge.

2- Architecture RISC (Reduced Instruction Set Computer)

Architecture dans laquelle les instructions sont en nombre réduit (chargement, branchement, appel sous-programme) et elles sont fréquemment utilisées. Le but est d’éliminer les instructions rarement employées et de consacrer les ressources matérielles à exécuter les instructions relativement simples en un cycle d‘horloge et à émuler les autres instructions à l’aide de séquences basées sur les instructions élémentaires. On trouve donc une meilleure performance à une vitesse donnée (le gain en performance envisageable est important mais dépend de la qualité du compilateur). Processeurs RISC : PowerRISC (IBM/Motorola), SPARC (SUN), PA-RISC (HP).

Cours sur l’Architecture et programmation des Microcontrôleurs

Voir aussi :

Partagez au maximum pour que tout le monde puisse en profiter

The post Architecture et programmation des Microcontrôleurs first appeared on F2School.

L’article Architecture et programmation des Microcontrôleurs est apparu en premier sur F2School.

Langage JAVA : Cours et exercices corrigés – Méthodes numériques appliquées

Le langage Java a été développe afin de pouvoir générer des applications qui soient indépendantes des machines et de leur système d’exploitation. Une des autres caractéristiques du langage est de pouvoir écrire des applications structurellement distribuées sur des réseaux. Il appartient, par ailleurs, à la famille des langages objets purs ou rien ne peut exister en dehors des classes.

Le langage Java est un langage compile et interprété. Cette définition contradictoire s’explique par le fait que le code source est transformé dans un byte-code universel exécutable par une machine virtuelle. Cette machine virtuelle peut être installée à partir d’une distribution du langage comme le Java Development Kit (JDK) de SUN. Elle peut être également intégrée sous une forme compactée dans un navigateur afin qu’il puisse exécuter des applets Java.

Ces caractéristiques confèrent au langage des propriétés de portabilité sans précédents, mais ont aussi un cout correspondant au fonctionnement de la machine virtuelle qui réduit les performances d’exécution du programme. Afin de résoudre ce problème, un effort important est consenti pour développer des compilateurs à la volée en code machine qui fonctionnent lors de l’exécution du programme (compilateurs identifies sous la dénomination de JIT – Just In Time).

Plan du cours  Langage JAVA 

1- Introduction à Java

• Présentation de Java
• Types primitifs et structures de contrôle
• Classes et objets en Java
• Organisation des fichiers sources d’un programme Java
• Héritage
• Exceptions
• Entrées/Sorties

2- Résolution des équations non linéaires dans R

3- Résolution des systèmes linéaires

4- Graphisme scientifique avec Java

5- Interpolation Polynomiale

6- Approximation par moindres carres

7- Intégration Numérique

8- Résolution Numérique des équations différentielles

Voir aussi :

The post Langage JAVA : Cours et exercices corrigés first appeared on F2School.

L’article Langage JAVA : Cours et exercices corrigés est apparu en premier sur F2School.

Structures de données en c : Type enregistrement

Un enregistrement, appelé structure En langage C, est une variable complexe qui permet de désigner sous un seul nom un ensemble de valeurs pouvant être de type différent

La définition d’une variable structurée est une opération qui consiste à créer une variable ayant comme type celui d’une structure que l’on a précédemment déclaré, c’est-à-dire la nommer et lui réserver un emplacement en mémoire.

Chaque variable de type structure possède des champs repérés avec des noms uniques. Toutefois le nom des champs ne suffit pas pour y accéder étant donné qu’ils n’ont de contexte qu’au sein de la variable structurée…

Pour accéder aux champs d’une structure on utilise l’opérateur de champ (un simple point) placé entre le nom de la variable structurée et le nom du champ.

Initialisation d’une structure

Lors de sa déclaration on peut initialiser une structure en indiquant entre {} la liste des valeurs séparées par des virgules. Chaque valeur étant une constante ayant le type du champ correspondant.

 Exemples:

struct Etudiant {

 int niveau;

 float moyenne;

};

struct Etudiant E1 = {2, 10.9};

struct Etudiant E2 = {2, 12.5};

Tableaux de structures :

Étant donné qu’une structure est composée d’éléments de taille fixes,il est possible de créer un tableau ne contenant que des éléments du type d’une structure donnée.

Il suffit de créer un tableau dont le type est celui de la structure et de le repérer par un nom de variable.

Cours sur les Structures de données en c : Type enregistrement

Télécharger ICI

Voir aussi :

Partagez au maximum pour que tout le monde puisse en profiter

The post Structures de données en c : Type enregistrement first appeared on F2School.

L’article Structures de données en c : Type enregistrement est apparu en premier sur F2School.

Les tableaux en langage C – Cours – Programmation en C

Un tableau est une structure de donnée permettant de stocker des données de même type.

Chacune des valeurs est repérée par un indice indiquant la position de la donnée dans le tableau.

Un tableau est caractérisé par :

• Son nom ;
• Sa taille ;
• Sa dimension ;
• Le type de ses éléments.

Un tableau uni-dimensionnel (vecteur) est une manière de ranger des éléments ou des valeurs de même type. Il regroupe ces éléments dans une structure fixe et permet d’accéder à chaque élément par l’intermédiaire de son rang ou indice.

Tableau Multidimensionnel est un tableau unidimensionnel de N-1 dimensions. Un tableau A à 2 dimensions est à interpréter comme un tableau (unidimensionnel) de taille L dont chaque composante est un tableau (unidimensionnel) de taille C.

Déclaration

En langage C, la déclaration d’un tableau à une dimension est définie comme suit :

<TypeSimple> <NomTableau> [<Taille>];

Initialisation

Lors de la déclaration d’un tableau, on peut initialiser les composantes du tableau en indiquant la liste des valeurs respectivement entre {}

Exemples:

short A [5] = {1, 10, 9, 4, 5} ; Réservation de (2 x 5) octets

char Lettres [26] = {‘ A ’, ‘ B ’}; Les autres composantes initialisées à 0

float B [ ] = {2.4, 1.6, 3.33}; Réservation automatique de (4×3) octets (la dimension n ’est pas indiquée explicitement)

short A [4] = {1, 10, 9, 4, 5} ; Erreur !

Cours sur Les tableaux en langage C :

Télécharger ICI

Voir aussi :

Partagez au maximum pour que tout le monde puisse en profiter

The post Les tableaux en langage C – Cours – Programmation en C first appeared on F2School.

L’article Les tableaux en langage C – Cours – Programmation en C est apparu en premier sur F2School.

Structures conditionnelles en langage C

La résolution de certains problèmes algorithmique ne peut se faire que sous condition et pour chaque condition un traitement spécifique sera déclenché et exclura les traitements des autres conditions

 Exemple:

On veut afficher le résultat d’un étudiant (Echec, Succès) à partir de sa moyenne.

Donc on a Besoin d’une structure qui évalue la condition de sa réussite !

Formes de structures conditionnelles :

On distingue plusieurs formes de structures conditionnelles :

 Structure conditionnelle à un seul choix : Il s’agit d’un traitement qui ne peut s’exécuter que si une condition logique est satisfaite ; dans le cas contraire, rien ne devrait se passer

Structure conditionnelle à deux choix : Il s’agit d’un traitement qui ne peut s’exécuter que si une condition logique est satisfaite ; dans le cas contraire, un autre traitement sera exécuté.

Structure conditionnelle imbriquée : Il s’agit d’un traitement qui ne peut s’exécuter que si une condition logique est satisfaite ; dans le cas contraire, un autre traitement sera exécuté. Les différents traitements ne comportent plus uniquement des actions simples mais on peut leur imbriquer des structures conditionnelles

Structure conditionnelle à choix multiple : Une structure à choix multiple est une structure qui à partir d’un choix va se positionner sur le bon traitement sans passer par les autres

Télécharger le cours sur les Structures conditionnelles en langage C

Télécharger ICI

Voir aussi :

Partagez au maximum pour que tout le monde puisse en profiter

The post Structures conditionnelles en langage C first appeared on F2School.

L’article Structures conditionnelles en langage C est apparu en premier sur F2School.

Les listes chaînées en langage C

Une liste chaînée est une structure comportant des champs contenant des données et un pointeur vers une structure de même type.

Une liste chaînée est une suite finie d’éléments de même type repérés selon leur rang dans la liste.

Pour créer une liste chaînée en langage C, il s’agit dans un premier temps de définir la structure de données, ainsi qu’un pointeur vers une structure du type de celle définie précédemment, afin de pointer vers la tête de la liste, c’est-à-dire le premier élément

Quelques Principes des listes chaînées:

• Une liste chaînée est utilisée pour stocker des données qui doivent être traitées de manière séquentielle
• Les éléments de la liste appelés cellule, nœuds ou maillons, ne sont pas rangés les uns à côté des autres
• On a besoin de connaître, pour chaque élément, la position (l’adresse) de l’élément qui le suit
• On dispose d’un pointeur de tête qui contient l’adresse du premier élément de la liste
• Le dernier nœud ne pointe vers rien, il est nécessaire de renseigner son pointeur avec la valeur NULL.

Télécharger les cours sur les listes chaînées en langage C

Télécharger ICI

Télécharger ICI

Voir aussi :

Partagez au maximum pour que tout le monde puisse en profiter

The post Les listes chaînées en langage C – Programmation C first appeared on F2School.

L’article Les listes chaînées en langage C – Programmation C est apparu en premier sur F2School.

Structures répétitives en C – langage C

On distingue deux types de structures répétitives :

– L’itération : quand on sait le nombre de fois que l’on va répéter un traitement :

1. La structure répétitive FOR ()

– La répétition conditionnelle : quand la poursuite d’une répétition dépend d’une condition :

2. La structure répétitive WHILE

3. La structure répétitive DO WHILE

La structure répétitive FOR est une structure répétitive qui itère le même traitement pour une plage de valeurs entières comprises entre une borne inférieure et une borne supérieure. L’arrêt du traitement se réalise lorsqu’on dépasse l’une des bornes.

La structure répétitive “WHILE” ou “TantQue… Faire” permet de répéter un traitement tant qu’une expression conditionnelle est vraie. Si d’emblée, la condition n’est pas vraie, le traitement ne sera pas exécuté.

La structure répétitive “DO WHILE” ou “Répéter…Jusqu’à “ permet de répéter un traitement jusqu’à ce qu’une condition soit vraie. Le traitement est exécuté, puis la condition est vérifiée.

Télécharger le cours sur les Structures répétitives en C

Télécharger ICI

Voir aussi :

Partagez au maximum pour que tout le monde puisse en profiter

The post Structures répétitives en C – langage C first appeared on F2School.

L’article Structures répétitives en C – langage C est apparu en premier sur F2School.

Les fonctions en langage C

Une fonction est un sous-programme permettant de calculer et de “retourner” (avec return) un seul résultat de type simple (float, char et int) à partir d’une liste de paramètres (des données).

Le langage C permet de découper un programme en plusieurs parties appelées modules.

Un module est un ensemble de données et d’instructions qui fournissent une solution à une petite partie d’un problème plus complexe.

Quelques avantages de la modularité :

• Meilleure lisibilité
• Diminution du risque d’erreurs
• Possibilité de tests sélectifs
• Réutilisation de modules déjà existants
• Simplicité d’entretien

En langage C, la structuration des programmes en modules se fait à l’aide des fonctions et main() est une de ces fonctions.

Télécharger les cours des fonctions en langage C

Télécharger ICI

Télécharger ICI

Télécharger ICI

Voir aussi :

Partagez au maximum pour que tout le monde puisse en profiter

The post Les fonctions en langage C – Programmation en C first appeared on F2School.

L’article Les fonctions en langage C – Programmation en C est apparu en premier sur F2School.

Lecture et écriture en C – Programmation en C

L’instruction de lecture permet de fournir des informations (données) à notre programme par l’intermédiaire d’un périphérique (clavier).

L’instruction d’écriture permet à un programme de communiquer des informations (résultats) par l’intermédiaire d’un périphérique (écran).

La bibliothèque standard <stdio> contient un ensemble de fonctions permettant la communication de l’ordinateur avec le monde extérieur.

Les principales fonctions de lecture et d’écriture en langage C sont scanf et printf. Ces deux fonctions font parties de la bibliothèque standard <stdio>

La fonction printf permet de transférer du texte, des valeurs de variables ou des résultats d’expressions vers l’écran. Elle exige l’utilisation de formats de sortie.

La fonction scanf permet de lire à partir du clavier des données.

Syntaxe d’écriture des données en langage C

printf (“<format> “, <expr1>, <expr2>, …);

• <format>: texte, séquence d’échappement, spécificateur de format
• Autant de spécificateurs de formats que d’expressions
• Spécificateur de format avec : %caractère_du_ type (%d, %f, … )

Syntaxe de lecture des données en langage C

scanf (“<format> “, <Adrv1>, <Adrv2>, …);

• <format>: format de lecture des données
• Autant de format que de données à lire
• <Adrv>: &NomVariable

– La chaîne de format détermine comment les données reçues doivent être interprétées.

– Les données reçues correctement sont mémorisées successivement aux adresses indiquées par <AdrV1>,… .

– L’adresse d’une variable est indiquée par le nom de la variable précédé du signe &.

Spécificateurs de format :

Voici quelques Spécificateurs de format :

%d : entier

%c : caractère

%f : rationnel en notation décimale

%s : chaîne de caractère

Télécharger les cours sur la Lecture et écriture en C – Programmation en C

Télécharger ICI

Télécharger ICI

Voir aussi: 

Partagez au maximum pour que tout le monde puisse en profiter

The post Lecture et écriture en C – Programmation en C first appeared on F2School.

L’article Lecture et écriture en C – Programmation en C est apparu en premier sur F2School.

Notions de base en langage C – Programmation en C

En langage C le programme principal et les sous programmes sont définies comme des fonctions. La fonction particulière nommée main() est la fonction principale d’un programme C.

Notion de variable en langage C

L’exécution d’un programme doit impliquer les données qui sont liées à ce programme. Ces données se trouvent à ce moment au niveau de la mémoire centrale et chacune occupe une case mémoire.

Une variable est donc un espace mémoire qui va contenir des données au fur et à mesure que le programme avance dans son exécution. Cependant, à un instant donné, une variable ne peut contenir qu’une seule donnée (valeur)

Comme son nom l’indique une variable est quelque chose qui varie, elle peut être considérée comme une boîte dans laquelle on met des données que l’on peut lire ou écrire.

Les variables permettent de représenter les données d’un programme. Chaque variable est matérialisée par un emplacement mémoire identifié par un nom ou un identificateur.

Les variables contiennent les valeurs qui sont utilisées pendant l’exécution du programme.

Chaque variable possède :

•  un nom
• un type
• une valeur

Le type nous indique de quel sorte de variable il s’agit : entier, décimal, caractère, …

Les commentaires sont utilisés pour des raisons de lisibilité et de compréhension du programme. Un commentaire est une chaîne de caractères comprise entre /* et */. Cette chaîne est ignorée par le compilateur C et peut déborder sur plusieurs lignes.

Le langage C distingue les minuscules, des majuscules. Les mots réservés (exemples : for, while, return, struct …) du langage C doivent être écrits en minuscules.

Affectation des variables en langage C

L’affectation est une instruction qui permet de placer une valeur dans une variable qui doit être préalablement déclarée.

Syntaxe:

<nom_variable> = <expression> ;

Exemple:

« Affecter le nombre 5 à la variable A » est équivalent à « Ranger dans la zone mémoire A l’entier 5 » s’écrit en C : A=5;

On distingue plusieurs types d’affectations :

• Affectation avec des valeurs constantes : placement d’une valeur dans une variable. Exemple : Montant = 6;
• Affectation avec des valeurs de variables : la valeur à placer dans une variable eut provenir d’une autre variable. Exemple : A = 2; B = A;
• Affectation avec des valeurs d’expressions : On peut ranger dans une variable le résultat d’un calcul. Exemple : A = 2; B = A + 2;

Les opérateurs en langage C

En langage C, on distingue plusieurs types d’opérateurs.

• Opérateurs arithmétiques  :

+ : Addition

– : Soustraction

* : Multiplication

/ : Division (entière et rationnelle)

• Opérateurs logiques : (1: vrai et 0: faux)

&& : Et logique (AND)

|| : ou logique (OR)

! : Négation (NOT)

• Opérateurs de comparaison : (1: vrai et 0: faux)

== : égale à

!= : différent de

<, <=, >, >= : plus petit, plus petit ou égal, …

• Les opérateurs d’affectation:

Pour la plupart des expressions de la forme : expr1 = (expr1) op (expr2)

Il existe une formulation équivalente qui utilise un opérateur d’affectation :

expr1 op= expr2

Exemple:

i = i + 2 ; devient i += 2 ;

Liste des opérateurs d’affectation :

+= : Ajouter à

-= : diminuer de

*= : multiplier par

/= : diviser par

%= : modulo

• Les opérateurs d’incrémentation et de décrémentation:

Les affectations les plus fréquentes sont du type : i = i + 1; et i = i – 1;

Les opérateurs ++ et — sont employés pour les cas suivants :

• Incrémenter ou bien décrémenter de 1 une variable i++; et ++i; ou bien i–; et –i;
• Incrémenter ou bien décrémenter de 1 une variable et en même temps affecter sa valeur à une autre variable
  • x = i++; passe la valeur de i à x et incrémente après i
  • x=i–; passe la valeur de i à x et décrémente après i
  • x=++i; incrémente d’abord i et passe la valeur à x
  • x=–i; décrémente d’abord i et passe la valeur à x

Exemple :

i = 5; a = ++i ; /* i = 6 et a = 6 */

i = 5; a = i++ ; /* i = 6 et a = 5 */

La priorité des opérateurs en Langage C

• Les constantes et les variables sont des expressions. Les expressions peuvent être combinées entre elles par des opérateurs et former ainsi des expressions plus complexes.
• L’ordre d’évaluation des différentes parties d’une expression est en principe le même qu’en mathématiques.

Télécharger les cours sur les notions de base en langage C

Télécharger ICI

Télécharger ICI

Voir aussi :

Partagez au maximum pour que tout le monde puisse en profiter

The post Notions de base en langage C – Programmation en C first appeared on F2School.

L’article Notions de base en langage C – Programmation en C est apparu en premier sur F2School.

Guide des Organigrammes – Algorithme : Cours et Exercices

Avant de se lancer dans la programmation, il serait intéressant d’avoir une idée claire sur la structure du programme.

Pour cela, nous pouvons représenter le programme avec un algorithme ou un organigramme.

Le premier se présente dans une structure linéaire comme un programme et le deuxième permet d’avoir une représentation graphique qui facilite encore mieux la compréhension.

Faire un organigramme peut s’avérer très utile par exemple dans le travail en groupe. Dans ces conditions plusieurs intervenants participent à la programmation et la modification du code. Ces modifications peuvent être représentées plus rapidement et facilement à l’aide d’organigrammes. Les organigrammes permettent même d’éclairer le concepteur lui-même sur des idées qu’il avait eu. La réalisation d’un organigramme est tout aussi importante que de mettre des commentaires dans le programme. Il est donc important de savoir cette méthodologie de représentation.

Algorithme : Un algorithme est un énoncé d’une suite d’opérations permettant de donner la réponse à un problème.

Organigramme : C’est une représentation graphique de l’algorithme. Pour le construire, on utilise des symboles normalisés.

Plan du Guide des Organigrammes

• Introduction
• Définitions
  • Algorithme
  • Organigramme
• La norme ISO 5807
  • Symboles
  • Exemple
• Les structures alternatives
  • SI.. ALORS…[IF… THEN…]
  • SI.. ALORS… SINON…[IF… THEN… ELSE…]
• Les structures itératives ou répétitives
  • TANTQUE.. FAIRE…[WHILE… DO…]
  • FAIRE.. JUSQU’A…[DO… UNTIL…]
  • POUR.. FAIRE…[FOR… DO…]
• Exercices
  • Exercise1
  • Exercise 2

Télécharger le Guide des Organigrammes PDF

Télécharger ICI

Voir aussi :

Partagez au maximum pour que tout le monde puisse en profiter

The post Guide des Organigrammes – Algorithme : Cours et Exercices first appeared on F2School.

L’article Guide des Organigrammes – Algorithme : Cours et Exercices est apparu en premier sur F2School.

Algorithme : cours, Résumés et exercices corrigés

Un algorithme est une suite ordonnée d’instructions qui indique la démarche à suivre pour résoudre une série de problèmes équivalents.

Algorithme : Description en langage naturel de la suite des actions effectuées par un programme structuré. Un algorithme est écrit en utilisant un langage de description d’algorithme (LDA). L’algorithme ne doit pas être confondu avec le programme proprement dit (tel que Pascal, C, ..)

L’algorithmique s’intéresse à l’art de construire des algorithmes ainsi qu’à caractériser leur validité, leur robustesse, leur réutilisabilité, leur complexité ou leur efficacité.

La validité d’un algorithme est son aptitude à réaliser exactement la tâche pour laquelle il a été conçu

La réutilisabilité d’un algorithme est son aptitude à être réutilisé pour résoudre des taches équivalentes à celle pour laquelle il a été conçu.

La complexité d’un algorithme est le nombre d’instructions élémentaires à exécuter pour réaliser la tâche pour laquelle il a été conçu.

L’efficacité d’un algorithme est son aptitude à utiliser de manière optimale les ressources du matériel qui l’exécute.

Objectifs d’algorithme

Un algorithme sert à transmettre un savoir faire. Il décrit les étapes à suivre pour réaliser un travail.

Il permet d’expliciter clairement les idées de solution d’un problème indépendamment d’un langage de programmation.

L’utilisateur d’un algorithme n’aura qu’à suivre toutes les instructions, dans l’ordre pour arriver au résultat que doit donner l’algorithme.

Les variables

Une variable est une entité qui contient une information, elle possède :

• un nom, on parle d’identifiant
• une valeur
• un type qui caractérise l’ensemble des valeurs que peut prendre la variable

L’ensemble des variables est stocké dans la mémoire de l’ordinateur

Type de variable

• Entier : Il s’agit des variables destinées à contenir un nombre entier positif ou négatif
• Réel : Il s’agit des variables numériques qui ne sont pas des entiers, c’est à dire qui comporte des décimales. Généralement un nombre réel est codé sur 4 octets
• booléen : Il est souvent nécessaire lorsque l’on écrit un programme d’introduire des variables qui prennent les valeurs VRAI ou FAUX ou les valeurs OUI ou NON.
• caractère : Les variables de type caractères contiennent des caractères alphanumériques ou numériques
• chaîne : pour manipuler des chaînes de caractères permettant de représenter des mots ou des phrases.

Opérateur

Un opérateur est un symbole d’opération qui permet d’agir sur des variables ou de faire des “calculs”

Un opérateur peut être unaire ou binaire :

• Unaire s’il n’admet qu’un seul opérande, par exemple l’opérateur non
• Binaire s’il admet deux opérandes, par exemple l’opérateur +

Un opérateur est associé à un type de donnée et ne peut être utilisé qu’avec des variables, des constantes, ou des expressions de ce type Par exemple l’opérateur + ne peut être utilisé qu’avec les types arithmétiques (naturel, entier et réel) ou (exclusif) le type chaîne de caractères

Une opérande est une entité (variable, constante ou expression) utilisée par un opérateur

Une expression est une combinaison d’opérateur(s) et d’opérande(s), elle est évaluée durant l’exécution de l’algorithme, et possède une valeur (son interprétation) et un type.

La structure répétitive

Un programme a presque toujours pour rôle de répéter une même action un certain nombre de fois. Pour ce faire on utilise une structure permettant de dire « Exécute telles actions jusqu’à ce que telle condition soit remplie ».

Liens de téléchargement des cours d’Algorithme

Liens de téléchargement des résumés et exercices corrigés d’Algorithme

Voir aussi :

Partagez au maximum pour que tout le monde puisse en profiter

The post Algorithme : cours, Résumés et exercices corrigés first appeared on F2School.

L’article Algorithme : cours, Résumés et exercices corrigés est apparu en premier sur F2School.