begin process at 2012 02 09 20:57:56
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Maths & Algorithmes

 > NOTATION POLONAISE INVERSE

NOTATION POLONAISE INVERSE


 Information sur la source

Note :
7 / 10 - par 1 personne
7,00 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10
Catégorie :Maths & Algorithmes Niveau :Débutant Date de création :09/01/2005 Vu :10 206

Auteur : bad_smi

Ecrire un message privé
Commentaire sur cette source (7)
Ajouter un commentaire et/ou une note

 Description

Ce code réalise ce qu'on appelle la notation polonaise inverse.
elle consiste à effectuer des opérations arithmétiques étant donné des opérateurs et des opérandes.les opérandes son tplacés avant les opérateurs(par exemple 5 6 +   càd  5+6) (autre exemple  5 6 + 2 3 * -
càd  (5+6)-(2*3)).Pour cela j'ai mis en oeuvre la notion de pile.SI vous executer ce programme  essayer de respecter la régle de saisie comme indiqué dans le s2 exemples précedents.
Vous verez que vous n'aurez le droit de saisir que des entiers entre 0  et 9.si vous examinez bien le code vous verez pourqoui et vous verez aussi qu'il est très facile de le modifier si vous voulez entrez des entiez positifs supérieur à 9.
Pour simplifier on utilise que des entiers positifs.  

Source

  • #include<stdio.h>
  • #include<conio.h>
  • #include<stdlib.h>
  • struct ma_pile{
  • char info;
  • struct ma_pile *suiv;
  • };
  • /****************** declaration Variables globales *****************/
  • struct ma_pile *sommet;
  • char p1;
  • char ch[20],c;
  • int i=0,code=0;
  • char tempo[2];
  • /****************** ce qui suit est des fonctions *********************/
  • struct ma_pile *Init(struct ma_pile **sommet)
  • {
  • *sommet=NULL;
  • return *sommet;
  • }
  • int char_to_int(char c)
  • {
  • if(c=='0')
  • return code==0;
  • else
  • {
  • code=c-48;
  • return code;
  • }
  • }
  • char int_to_char(int int_to_ch)
  • {
  • int_to_ch+=48;
  • c=(char)int_to_ch; // converti l'ascii int_to_char en caractere
  • return c;
  • }
  • void EMP(char x,struct ma_pile **sommet)
  • {
  • struct ma_pile *p;
  • p=(struct ma_pile *)malloc(sizeof(struct ma_pile));
  • p->info=x;
  • p->suiv=*sommet;
  • *sommet=p;
  • }
  • int DEP(struct ma_pile **sommet)
  • {
  • if(*sommet==NULL)
  • printf("E R R E U R ! LA PILE EST VIDE");
  • else
  • {
  • struct ma_pile *p=*sommet;
  • p1=p->info;
  • *sommet=p->suiv;
  • free(p);
  • printf("\nOPERATION SUCCESS\n");
  • printf("VALEUR DEPILEE :%d\n",char_to_int(p1));
  • return p1;
  • }
  • }
  • void saisie(char t[1])
  • {
  • char c;
  • int j1=0;
  • do
  • {
  • c=getch();
  • if(((c>='0')&& (c<='9')) || ((c=='*')|| (c=='-')|| (c=='+')|| (c=='/')))
  • {
  • if((c>='0')&& (c<='9'))
  • {
  • j1++; //comptabilise les caracteres entre '0' et '9'
  • if(j1>2)
  • printf("ACTION NON AUTORISEE\n");
  • else
  • {
  • t[i]=c;
  • printf("%c\n",t[i]);
  • i++;
  • }
  • }
  • if((c=='*')|| (c=='-')|| (c=='+')|| (c=='/'))
  • {
  • j1=0;
  • t[i]=c;
  • printf("%c\n",t[i]);
  • i++;
  • }
  • }
  • }
  • while(c!=13);
  • }
  • void VISU(struct ma_pile *sommet)
  • {
  • if(sommet!=NULL)
  • {
  • struct ma_pile *p=sommet;
  • while(p) {
  • printf("%c ->",p->info);
  • p=p->suiv; }
  • }
  • else
  • printf("E R R E U R ! VEUILLEZ D'ABORD REMPLIR LA PILE ");
  • }
  • void Traitement(char t[1])
  • {
  • int k,k1,code2=0,code1=0,resultat=0;
  • char c;
  • for(k=0;k<i;k++)
  • {
  • if ((t[k]>='0') &&(t[k]<='9'))
  • EMP(t[k],&sommet);
  • if((t[k]=='*')|| (t[k]=='-')|| (t[k]=='+')|| (t[k]=='/'))
  • {k1=1; //on commence … d‚piler
  • while((sommet!=NULL) && (k1>=0)) //ne depile que les 2 1ere valeurs
  • {
  • DEP(&sommet);
  • tempo[k1]=p1;
  • k1--;
  • }
  • code1=char_to_int(tempo[0]);
  • code2=char_to_int(tempo[1]);
  • switch (t[k])
  • {
  • case '+':resultat=code1+code2;printf("%d+%d=%d\n",code1,code2,resultat);
  • break;
  • case '-':resultat=code1-code2;printf("%d-%d=%d\n",code1,code2,resultat);
  • break;
  • case '*':resultat=code1*code2;printf("%d*%d=%d\n",code1,code2,resultat);
  • break;
  • case '/':resultat=code1/code2;printf("%d/%d=%d il s'agit d'une division entiŠre\n",code1,code2,resultat);
  • break;
  • }
  • EMP(int_to_char(resultat),&sommet);
  • }
  • }
  • }
  • /***********************
  • Fin des fonctions **********/
  • /***********************
  • Ceci est mon programme****/
  • void main()
  • {
  • clrscr();
  • saisie(ch);
  • Init(&sommet);
  • Traitement(ch);
  • getch();
  • }
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>


struct ma_pile{
	       char info;
	       struct ma_pile *suiv;
	      };

/****************** declaration Variables globales *****************/

struct ma_pile *sommet;
char p1;
char ch[20],c;
int i=0,code=0;
char tempo[2];

/****************** ce qui suit est des fonctions *********************/


struct ma_pile *Init(struct ma_pile **sommet)
{
 *sommet=NULL;
 return *sommet;
}


int char_to_int(char c)
 {
  if(c=='0')
   return code==0;
  else
   {
    code=c-48;
    return code;
   }
 }


char int_to_char(int int_to_ch)
{
 int_to_ch+=48;
 c=(char)int_to_ch;    // converti l'ascii int_to_char en caractere
 return c;
}


void EMP(char x,struct ma_pile **sommet)
{
 struct ma_pile *p;

   p=(struct ma_pile *)malloc(sizeof(struct ma_pile));
   p->info=x;
   p->suiv=*sommet;
   *sommet=p;
}


int DEP(struct ma_pile **sommet)
{
  if(*sommet==NULL)
   printf("E R R E U R ! LA PILE EST VIDE");
  else
   {
    struct ma_pile *p=*sommet;
    p1=p->info;
    *sommet=p->suiv;
    free(p);
    printf("\nOPERATION SUCCESS\n");
    printf("VALEUR DEPILEE :%d\n",char_to_int(p1));
    return p1;
   }

}


void saisie(char t[1])
{
   char c;
   int j1=0;

   do
    {
     c=getch();
     if(((c>='0')&& (c<='9')) || ((c=='*')|| (c=='-')|| (c=='+')|| (c=='/')))
      {
       if((c>='0')&& (c<='9'))
	{
	  j1++;     //comptabilise les caracteres entre '0' et '9'
	  if(j1>2)
	   printf("ACTION NON AUTORISEE\n");
	  else
	  {
	   t[i]=c;
	   printf("%c\n",t[i]);
	   i++;
	  }
	}

       if((c=='*')|| (c=='-')|| (c=='+')|| (c=='/'))
	 {
	   j1=0;
	   t[i]=c;
	   printf("%c\n",t[i]);
	   i++;

	 }
      }
    }
   while(c!=13);
}

void VISU(struct ma_pile *sommet)
{
  if(sommet!=NULL)
   {
    struct ma_pile *p=sommet;

    while(p) {
    printf("%c ->",p->info);
    p=p->suiv; }
   }
  else
   printf("E R R E U R ! VEUILLEZ D'ABORD REMPLIR LA PILE ");
}


void Traitement(char t[1])
{
  int k,k1,code2=0,code1=0,resultat=0;

  char c;
   for(k=0;k<i;k++)
     {
      if ((t[k]>='0') &&(t[k]<='9'))
       EMP(t[k],&sommet);

      if((t[k]=='*')|| (t[k]=='-')|| (t[k]=='+')|| (t[k]=='/'))
       {k1=1;      //on commence … d‚piler

	while((sommet!=NULL) && (k1>=0))  //ne depile que les 2 1ere valeurs
	 {
	  DEP(&sommet);
	  tempo[k1]=p1;
	  k1--;
	 }
	code1=char_to_int(tempo[0]);
	code2=char_to_int(tempo[1]);

       switch (t[k])
	{
	 case '+':resultat=code1+code2;printf("%d+%d=%d\n",code1,code2,resultat);
		  break;
	 case '-':resultat=code1-code2;printf("%d-%d=%d\n",code1,code2,resultat);
		  break;
	 case '*':resultat=code1*code2;printf("%d*%d=%d\n",code1,code2,resultat);
		  break;
	 case '/':resultat=code1/code2;printf("%d/%d=%d   il s'agit d'une division entiŠre\n",code1,code2,resultat);
		  break;
	}

	 EMP(int_to_char(resultat),&sommet);

       }

     }

}




/***********************
Fin des fonctions **********/


/*********************** 
Ceci est mon programme****/

void main()
{
 clrscr();
 saisie(ch);
 Init(&sommet);
 Traitement(ch);
 getch();
}

 Conclusion

pour toutes suggestions ou remarques,veuillez me contactez


 Sources du même auteur

Source avec Zip MANIPULATION SIMPLE DES TABLES RELATIONNELLES :GENRE SGBDR
SOMME DE 2 POLYNÔMES

 Sources de la même categorie

Source avec Zip UN EXAMPLE D'APPLICATION EN CUDA DE L'ALGORITHME DE SCAN POU... par oguzaras
Source avec Zip Source avec une capture CHIFFREMENT DE VIGENERE par lajouad
Source avec Zip Source avec une capture ANALYSE SYNTAXIQUE par lajouad
Source avec Zip Source avec une capture STRUCTURE D'UNE MATRICE PAR LES LISTE LINÉAIRE (NON CONTUGUS... par benzarabel
Source avec Zip Source avec une capture DESSINER UNE ARBRE BINAIRE( MODE CONSOLE): par benzarabel

Commentaires et avis

Commentaire de Joky le 09/01/2005 17:04:52

Et pk on apelle ça Notation Polonaise ???

Commentaire de Kirua le 10/01/2005 17:46:37

je sais pas pq polonaise (pê que c'est une notation privilégiée par les polonais ^^), mais on appelle souvent la notation polonaise inverse la "postfix" et la notation "naturelle" (pour nous) la infix (en anglais, parce qu'en français on dit suffixé et infixé)

Commentaire de Stepharcher le 27/01/2005 22:07:26

quelle culture ! :p

Commentaire de freddy1787 le 25/10/2007 17:57:05

Parceque c'est un polonais qui l'a invente !!

Commentaire de ennajih05 le 18/12/2008 02:32:02

bsr
j'arrive pas à executer le programme si dessus alors si quelqu'un peut m'aider et merci d'avance

Commentaire de bad_smi le 22/12/2008 12:01:52

Peux-tu mettre un printscreen de ce que tu as comme erreur ..
est ce une erreur de compilation ou d'exécution ?

Commentaire de Scheb le 26/10/2010 09:48:42

Notion de polonaise inverse ? Pourquoi pas le théorème du petit suisse unijambiste ? >.<

 Ajouter un commentaire




Nos sponsors


Sondage...

Comparez les prix

CalendriCode

Février 2012
LMMJVSD
  12345
6789101112
13141516171819
20212223242526
272829    

Consulter la suite du CalendriCode

Photothèque

 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 2,730 sec (4)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales