Evaluation d'une expression npi (notation polonaise inverse)

Commenter

Contenu du snippet

Ce code travail evec des entiers mais est facilement adaptable aux autres types numériques.
Si vous l'utilisez et que vous voulez ajouter un opérateur, n'oubliez pas de l'ajouter dans le tableau !!!

Requiert 1.5 a cause du scanner.

Source / Exemple : 


package core;
//Requier Java 1.5+
import java.util.Scanner;//Lecture d'un flux sur base d'expressions régulières
import java.util.Stack;//Une pile

public class NpiEvaluator {
	final static String[] ops={"+","-","*","/","mod","max","min"};//Liste des opérateurs
	public static void main(String[] arg){
		Scanner clavier=new Scanner(System.in);//permet la lecture d'une saisie utilisateur
		/*


    		 
  •  utilisateur = ressource qui envoie les données au porgramme via stdin 

    • 		 
  •  stdin =  entrée standard, souvent le clavier*

    • 		 
  • /

		System.out.println("Entrez une expression NPI ou \"q\" pour quitter");//Affichage d'un message sur stdout
		/*


    		 
  •  stdout = sortie standard, souvent une console ou un fichier log

    • 		 
  • /

		System.out.print(">");
		String calc=clavier.nextLine(); // Récupération de la ligne suivante sur stdin
		while(!calc.equals("q")){
			System.out.print("le résultat est : ");
			System.out.println(evaluate(calc)); // Appel à la fonction d'évaluation, fonction principale du programme !
			System.out.println("Entrez une expression NPI ou \"q\" pour quitter");
			System.out.print(">");
			calc=clavier.nextLine();
		}
		System.out.println("Au revoir :-)"); // Notifier l'utilisateur que le programme est terminé.
	}

	public static int evaluate(String calc){
		Stack<String> op=new Stack<String>(); // Une pile, elle sera utilisé comme une pile LIFO
		/*


    		 
  •  LIFO = Last In First Out, dernier entré premier sorti.

    • 		 
  •  Un bon exemple est la pile d'assiètes, on prend généralement la dernière qui à été posée (celle du dessus)

    • 		 
  •  |     |                 |    |                |    |               |    |

    • 		 
  •  |     |                 |    |                |    |               |    |

    • 		 
  •  |     |  -> Push(AA) -> |    | -> Push(BB) -> | BB | -> Pop() ->   |    | 

    • 		 
  •  |     |                 | AA |                | AA |   retourne    | AA |

    • 		 
  •  -------                 ------                ------     BB        ------

    • 		 
  • /

		String[] tabOp=calc.split(" ");//Retourne le tableau de chaine des élléments séparés par " " (espace blanc Ascii(20))
		for(int i=0;i<tabOp.length;i++){
			if(isOperande(tabOp[i])){//Si on est sur un opérateur, alors, on POP.
				int op1=Integer.parseInt(op.pop());
				int op2=Integer.parseInt(op.pop());
				op.push(doOperande(tabOp[i], op1, op2));//On effectue l'opération
			}else{
				op.push(tabOp[i]);//On est sur un opérande, on le stocke sur la pile
			}
		}
		return Integer.parseInt(op.pop());//On travail avec des chaines, il faut les convertir en entier.
	}
	public static boolean isOperande(String op){//Fonction wrap, elle permet de donner un sens à une ligne de code (Abstraction).
		return isIn(op,ops);
	}
	public static boolean isIn(String what,String[] where){//Vérifie la présence d'une chaine dans un tableau de chaine
		for(int i=0;i<where.length;i++){
			if(where[i].equals(what))return true;
		}
		return false;
	}
	public static String doOperande(String op,int op1,int op2){//Execute une opration, retourne 0 si l'opération est inconnue.(risque d'effets de bord, vous DEVEZ implémenter une exeption)
		if(op.equals("+")){
			return ""+(op1+op2);
		}else if(op.equals("-")){
			return ""+(op2-op1);
		}else if(op.equals("*")){
			return ""+op1*op2;
		}else if(op.equals("/")){
			return ""+op2/op1;
		}else if(op.equals("mod")){
			return ""+op2%op1;
		}else if(op.equals("max")){
			return ""+(op1>op2?op1:op2);
		}else if(op.equals("min")){
			return ""+(op1>op2?op2:op1);
		}
		/*


    		 
  •  Veuillez implémenter une exeption ici

    • 		 
  • /

		return "0";
	}
	
}

Conclusion :


La npi est une notation utilisée par d'anciennes calculatrices.
Elle est proche de la pensée humaine.

Ce que vous écrivez ainsi en arithmétique :
1*2+3*5
S'écrit ainsi en NPI :
1 2 * 3 5 * +
Ce qui montre bien que le + serra executé en dernier avec les résultats des multiplications...
Notez que les parenthèses n'existent pas ! Elles sont inutiles.
Donc "(1+2)*(3+4)" devient : "1 2 + 3 4 + *"

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (krissssss)