Seance #3

ex3.cpp

@@ -8,6 +8,8 @@
 #include "ex3/Division.cpp"
 #include "ex3/DivisionEuclidienne.cpp"
 #include "ex3/Trinome.cpp"
+#include "ex3/Puissance.cpp"
+#include "ex3/Racine.cpp"
 
 using namespace std;
 
@@ -29,6 +31,8 @@ int main(){
 	operations.push_back( new Division()            );
 	operations.push_back( new DivisionEuclidienne() );
 	operations.push_back( new Trinome()             );
+	operations.push_back( new Puissance()           );
+	operations.push_back( new Racine()              );
 
 
 	/* [2] Choix de l'operation a executer

ex3/Puissance.cpp

@@ -0,0 +1,24 @@
+#include "Puissance.h"
+#include <cmath>
+
+/* [0] CONSTRUCTEUR
+=========================================================*/
+Puissance::Puissance(){
+	this->init(2);
+}
+
+/* [1] Renvoie le nom du type de calcul
+=========================================================*/
+std::string Puissance::getLibelle(){
+	return "a ^ b";
+}
+
+/* [2] Effectue le calcul et renvoie le resultat
+=========================================================*/
+float* Puissance::calc(){
+	this->result = (float*) malloc(1*sizeof(float));
+
+	this->result[0] = pow(this->operands[0], this->operands[1]);
+
+	return this->result;
+}

ex3/Puissance.h

@@ -0,0 +1,9 @@
+#include "Operator.h"
+
+
+class Puissance : public Operator{
+	public:
+		Puissance();
+		std::string getLibelle();
+		float* calc();
+};

ex3/Racine.cpp

@@ -0,0 +1,24 @@
+#include "Racine.h"
+#include <cmath>
+
+/* [0] CONSTRUCTEUR
+=========================================================*/
+Racine::Racine(){
+	this->init(1);
+}
+
+/* [1] Renvoie le nom du type de calcul
+=========================================================*/
+std::string Racine::getLibelle(){
+	return "sqrt(b)";
+}
+
+/* [2] Effectue le calcul et renvoie le resultat
+=========================================================*/
+float* Racine::calc(){
+	this->result = (float*) malloc(1*sizeof(float));
+
+	this->result[0] = sqrt(this->operands[0]);
+
+	return this->result;
+}

ex3/Racine.h

@@ -0,0 +1,9 @@
+#include "Operator.h"
+
+
+class Racine : public Operator{
+	public:
+		Racine();
+		std::string getLibelle();
+		float* calc();
+};

ex3/Trinome.cpp

@@ -1,6 +1,5 @@
 #include "Trinome.h"
 
-#include <stdio.h>
 #include <cmath>
 
 using namespace std;

tp1.cpp

@@ -3,6 +3,8 @@
 #include <string>
 #include <vector>
 
+#include "tp1/wordproc.cpp"
+
 using namespace std;
 
 
@@ -21,14 +23,29 @@ int main(){
 
 	/* [1] Demande du mot
 	=========================================================*/
-	s
+	cout << "Mot secret: ";
+	cin >> word;
+	cout << endl;
 
-	/* [2] Essai de l'utilisateur
-	=========================================================*/
-	
+	// On met le mot en majuscules
+	word = toUpperCase(word);
 
-	/* [3] Resultat
+	/* [2] On melange les lettres du mot
 	=========================================================*/
+	shuffled = shuffle(word);
+
+	/* [3] JEU > utilisateur
+	=========================================================*/
+	string guessed;
+
+	do{
+		cout << "What is this world ? " << shuffled << endl;
+		cin >> guessed;
+		cout << endl;
+
+	}while( toUpperCase(guessed) != word );
+
+	cout << "Vous avez gagne!!" << endl;
 
 	return 0;
 }

tp1/wordproc.cpp

@@ -0,0 +1,62 @@
+#include "wordproc.h"
+
+int indexOf(vector<int> tab, int el){
+	for( int i = 0 ; i < tab.size() ; i++ )
+		if( tab[i] == el ) return i;
+
+	return -1;
+}
+
+
+string toUpperCase(string in){
+	// Valeur de sortie
+	string out(in);
+
+	for( int i = 0 ; i < in.length() ; i++ ){
+		char c = in.at(i);
+
+		// 
+		if( c >= 'a' && c <= 'z' )
+			out[i] = (char) (c-'a'+'A');
+	}
+
+
+	return out;
+}
+
+
+
+
+
+
+
+string shuffle(string in){
+	// Contiendra les index
+	vector<int>  indexes;
+	// Contiendra les valeurs
+	string out("");
+
+	/* [1] On prends une lettre tant qu'il en manque
+	=========================================================*/
+	srand(time(0));
+	int index(0);
+
+	while( indexes.size() < in.length() ){
+
+		// On prends un indice aleatoire
+		index = rand() % in.length();
+		cout << index << endl;
+
+		// Si index non utilise, on le reference
+		if( indexOf(indexes, index) == -1 ){
+			indexes.push_back( index );
+			out += in[index];
+		}
+
+	}
+
+	return out;
+}
+
+
+

tp1/wordproc.h

@@ -0,0 +1,16 @@
+#include <string>
+#include <vector>
+#include <cstdlib>
+#include <ctime>
+
+using namespace std;
+
+int indexOf(vector<int> tab, int el);
+
+/* [1] Met le mot en majuscules
+=========================================================*/
+string toUpperCase(string in);
+
+/* [2] Melange l'ordre des char d'un mot
+=========================================================*/
+string shuffle(string in);