C/C++

Clair on continue ! Britman on attend ton solveur de sudoku !

Message personnel :

GOULIP, ENCULE Evil or Very Mad

MON PROF Y M'A PAS AIDE AU CONTRAIRE Y M'A ENGUEULE PARCE QUE J'AI PAS UTILISE LE MEME ALGORYTHME QUE LUI. ET JE TE RAPPELLE QUE J'AI AUSSI FAIT UN SOLVEUR DE SUDOKU ET LA TU ME DIRAS PAS QU'ON M'A AIDE ! Twisted Evil

(voilà c'était le quart d'heure du geek en colère)

_________________
Le floodeur fou a encore frappé. D'ailleurs :

Phelma Phelma Phelma Phelma Phelma Phelma Phelma

OK. attention j'envoie le paté

_________________
Et paf l'évier !

Phelma c'est bien... ou pas ?

P h e l m a

"fonctions.h"

bool Oulogique(bool *list,int N){
/* RÃ©alise la fonction logique list[0] || list[1] ... || list[2] */
bool temporaire=false;
for (int i=0;i<N;i++){
temporaire=temporaire||list[i];
}
return temporaire;
}
bool parcourir(Pls_cases aparcourir,int n){
/* renvoie true si il n'y a pas deux cases ou plus avec la mÃªme valeur dans le mÃªme groupe */
int tot=0;
for (int k=0;k<9>Valeur==n) {tot++;}
}
return (tot==1 || tot==0);
}

bool parcourir2(Pls_cases aparcourir,int n){
/* renvoie true si il existe une case et une seule avec la valeur n dans le groupe */
int tot=0;
for (int k=0;k<9>Valeur==n) {tot++;}
}
return (tot==1);
}
void definir_pasposs(Pls_cases &adefinir,int n,bool &test){
/* dÃ©finit la valeur n comme impossible pour toutes les cases du groupe */
for (int p=0;p<9>possibles[n]) test=true;
adefinir.cases[p]->possibles[n]=false;
}
}
bool Ouexclusif(bool *booleens,int N){
/* renvoie true si un et un seul des boolÃ©ens vaut true */
int Nt=0,Nf=0;
for (int i=0;i<N;i++){
if (booleens[i]) Nt++;
if (!booleens[i]) Nf++;
}
return (Nt==1);
}
void charger_depuisfichier(Sudoku &grille){
/* demande oÃ¹ charger le fichier (avec la bonne structure de fichier), et le charge dans la grille donnÃ© en paramÃ¨tre */
char nomfichier[256];
cout <<nom>grille).cases[i][j].Valeur=hypotheses[z];
Sudoku grille_temporaire=((rac.Successeurs[z])->grille).copie();
//rÃ©duction sans hypothÃ¨ses du noeud enfant nÂ°z
grille_temporaire.reduire_sans_hyp(0);
(rac.Successeurs[z])->grille=grille_temporaire.copie();
bool valid=(rac.Successeurs[z])->valider(0);
bool nonfini=!((rac.Successeurs[z])->grille).finie();
if ( nonfini && valid){
//auto-appel sur le noeud enfant nÂ°z s'il est valide non fini
creation_arbre_hypotheses(*rac.Successeurs[z]);
}
}
}
void Barre(char Car, int nbCar) {
/* Ã©crit nbCar fois le caractÃ¨re Car */
for(int i=0; i<nbCar; i++) {
cout << Car;
}
}

_________________
Et paf l'évier !

Phelma c'est bien... ou pas ?

P h e l m a

"classes.h"

#include <iostream>
#include <fstream>

const int L[9]={0,0,0,1,1,1,2,2,2};
const int C[9]={0,1,2,0,1,2,0,1,2};

//mÃ©thodes de la classe Case
Case::Case(void){
/* constructeur qui effectue les initialisations nÃ©cessaires */
Valeur=0;
for(int i=1;i<10;i++){
possibles[i]=true;
};
}
int Case::nombrepossibles(){
/* retourne le nombre de possibilitÃ©s pour cette case */
int N=0;
for (int k=1;k<10;k++){
if (possibles[k]) N++;
}
return N;
}
void Case::reduire(){
/* si la case n'a qu'une seule possibilitÃ©s, affecte cette valeur Ã la case. sinon... c'est DTC */
if (nombrepossibles()==1){
for (int j=1;j<10;j++) { if (possibles[j]) Valeur=j; }
}else{
cout <<"rÃ©duction d'une case irrÃ©ductible, t'es couillon ou quoi ?"<<endl;
}
}

//mÃ©thodes de la classe Pls_cases
Pls_cases::Pls_cases(void){
/* constructeur, effectue les initialisations nÃ©cessaires */
for(int k=0;k<9;k++){
cases[k]=NULL;
}
Num=0;
}
void Pls_cases::reduire(bool &test){
/* recherche une case seule solution pour un chiffre dans le groupe, et l'affecte alors Ã la case trouvÃ©e. sinon... c'est DTC */
test=false;
int p=0;
do{
p=0;
for (int n=1;n<10;n++){
;
int N=0,K=0;
for(int k=0;k<9>possibles[n]) {
N++;K=k;
}
}
if (N==1){
p++;
cases[K]->Valeur=n;
sudoku->definirpossibles();
test=true;
}
}

}while(p!=0);
}
void Pls_cases::reduire_doublettes(bool &test){
/* doublette: n.f non dÃ©rivÃ© du film double impact, qui signifie que dans une zone donnÃ©e une sÃ©rie du genre (2,3) apparaÃ®t dans deux cases diffÃ©rentes, et deux seulement, on peut donc enlever toutes les autres possibilitÃ©s de ces cases */
test=false;
for (int i=1;i<10;i++){
for (int j=i+1;j<10>i quel pervers!
int N=0;
int N1=0;
int N2=0;
int C[2]={0,0};

for (int k=0;k<9>possibles[i] && cases[k]-> possibles[j]) {
if (N<1>possibles[i]) N1++;
if (cases[k]->possibles[j]) N2++;
}
// N: nombre de cases avec la doublette
// N1: nombre de cases avec le premier chiffre de la doublette
// N2: nombre de cases avec le deuxiÃ¨me chiffre de la doublette
// si doublette il y a alors N=2, N1=2, N2=2 strictement
if (N==2 && N1==2 && N2==2){
for (int p=1;p<10>possibles[p])&&cases[C[1]]->possibles[p];
cases[C[0]]->possibles[p]=false;
cases[C[1]]->possibles[p]=false;
}
}
}
}
}
}
void Pls_cases::affichage(){
/* mÃ©thode d'affichage d'un groupe non Ã§a ne marche pas pour les partouzes*/
if (Type==1){
for(int k=0;k<9;k++){
cout <<cases>Valeur << " " ;
if (k==2 || k==5){
cout << "|" ;
}
}
cout <<endl;
}
if (Type==2){
for(int k=0;k<9;k++){
cout <<cases>Valeur;
if (k==2 || k==5){
cout << endl << "-";
}
cout <<endl;
}
}
if (Type==3){
for(int k=0;k<9;k++){
cout <<cases>Valeur;
if (k==2 || k==5){
cout << endl;
}
}
cout << endl;
}
}
//mÃ©thodes de la classe Sudoku
Sudoku::Sudoku(void){
//Construit la grille, initialise les lignes, colonnes, cases, zones
for (int i=0;i<9;i++){
for (int j=0;j<9;j++){
cases[i][j].Valeur=0;
for (int k=1; k<10;k++) cases[i][j].possibles[k]=true;
}
}
for (int k=0;k<9;k++){ //initialise les groupes
lignes[k].Num=k;
colonnes[k].Num=k;
zones[k].Num=k;
for (int i=0;i<9> ce qui serait bien Ã faire: surcharger l'opÃ©rateur= avec cette fonction */
Sudoku St;
for (int i=0;i<9;i++){
for (int j=0;j<9;j++){
St.cases[i][j]=cases[i][j];
}
}
return St;
//les pointeurs des cases des lignes et des colonnes sont dÃ©jÃ bien dirigÃ©s (par le constructeur) vers les cases du sudoku parent
}
void Sudoku::affichage(bool possibles){
/* mÃ©thode d'affichage du sudoku :
si possibles vaut true, alors on n'affiche que la grille des possibilitÃ©s
si possibles vaut false, alors on n'affiche que la grille des valeurs
si il vaut DTC c'est que tu t'es gourÃ© qque part */
if (!possibles){
for (int i=0;i<9;i++){

if (i==0 || i==3 || i==6 || i==9){
cout << "----------------------"<<endl;
}

for (int j=0;j<10;j++){
if (i<=8 && (j==0 || j==3 || j==6 || j==9)){
cout << "|";
}//charabia incomprÃ©hensible n'est-ce pas ?
if(i<=8 && j<= Cool

{
cout << cases[i][j].Valeur << " ";
}
}
cout << endl;
}
cout << "----------------------"<<endl;
}else{
cout << "-------------------------------------------------------------------------------------------"<<endl;
for (int i=0;i<9;i++){
cout << "|" ;
for (int j=0;j<9>0 && j!=3 && j!=6) cout << ",";
for (int k=1;k<10;k++) {
if (cases[i][j].possibles[k]) cout << k; else cout << " ";
}// de pire en pire
if (j==2 || j==5) cout << "|";
}
cout <<"|" << endl;

if (i==2 || i==5) cout << "-------------------------------------------------------------------------------------------"<<endl;
}
cout << "-------------------------------------------------------------------------------------------"<<endl;
}
}
bool Sudoku::valider(bool verbose){
/* renvoie true si la grille est valide c'est-Ã -dire si
aucune case n'a de valeurs <0>9
aucun groupe n'a deux cases avec la mÃªme valeur
*/
if (verbose) cout << "validation..." <<endl;
bool result=true;;
for (int i=0;i<9;i++){
for (int j=0;j<9>9 || cases[i][j].Valeur<0) result=false;
}
}

if (verbose) cout << "cases_result=" << result <<endl;

for (int k=0;k<9;k++){
for (int i=1;i<10;i++){
result = result && parcourir(colonnes[k],i);
result = result && parcourir(lignes[k],i);
result = result && parcourir(zones[k],i);
}
}

if (verbose) cout << "lignes-colonnes-zones_result=" << result <<endl> modification de la grille des possibilitÃ©s en consÃ©quence
*/
bool test_cr=false;
test=false;
int N=1;
do{
if (verbose) cout << " passe " << N << " : ";
N++;
for (int f=0;f<9;f++){ //boucle sur les zones
for (int n=1;n<10;n++){ // boucle sur les chiffres

// nl[i] vrai si il existe une case possible sur la ligne i; idem nc[3]
bool nl[3]={false,false,false};
bool nc[3]={false,false,false};
for (int g=0;g<9>possibles[n]) {
nl[L[g]]=true;
nc[C[g]]=true;
}
}
//Ã©tude de nl et nc
int Sl=0,Sc=0,c=0,l=0;
for (int d=0;d<3> ligne nÂ° l+3*L[nÂ°zone] de la grille
test_cr=false;
for (int k=0;k<9;k++){
if (k<3>=3*C[f]+3){
if ((lignes[l+3*L[f]].cases[k])->possibles[n]) { test_cr=true;test=true;}
(lignes[l+3*L[f]].cases[k])->possibles[n]=false;
}

}
if (test_cr){
if (verbose) cout << "{l" << (1+l+3*L[f]) << "," << n << "}";
}
}
if (Sc==1 && Sl!=1){
// la colonne c doit Ãªtre traitÃ©e sans OGM j'espÃ¨re!
// colonne c(0,1,2) de la zone --> colonne nÂ° c+3*C[nÂ°zone] de la grille
test_cr=false;
for (int z=0;z<9;z++){
if (z<3>=3*L[f]+3) {
if ((colonnes[c+3*C[f]].cases[z])->possibles[n]) { test_cr=true;test=true;}
(colonnes[c+3*C[f]].cases[z])->possibles[n]=false;
}
}
if (test_cr){
if (verbose) cout << "{c" << (1+c+3*C[f]) << "," << n << "}";
}
}
}
}
definirpossibles(); //redÃ©finition de la grille des possibles avant de lui repasser dessus... t'as les idÃ©es tordues !
if (verbose) cout << endl;
if (!test_cr && verbose) cout << " passe " << N << " : pas de modifications"<<endl;
}while(test_cr);

}
void Sudoku::min_possibilites(int &i,int &j,int &n){
/* cherche la case oÃ¹ il y a le moins de possibilitÃ©s */
n=9;i=0;j=0;
int M=9;
for (int k=0;k<9;k++){
for (int l=0;l<9;l++){
int M=cases[k][l].nombrepossibles();
if (M<n> un tableau des possibles tous Ã false
un groupe avec une case avec une valeur => valeur impossible dans tout le groupe
une grille avec un groupe avec une case avec une valeur possible mais pas croyable comment t'as fait pour lire tout Ã§a?
*/
bool test=false;
for (int i=0;i<9;i++){
for (int j=0;j<9;j++){
if (cases[i][j].Valeur!=0){
for (int k=1;k<10;k++) {
if (cases[i][j].possibles[k]) test=true;
cases[i][j].possibles[k]=false;

}
}
}
}
for (int k=0;k<9;k++){
for (int n=1;n<10;n++){
bool test_C=parcourir2(colonnes[k],n);
bool test_L=parcourir2(lignes[k],n);
bool test_Z=parcourir2(zones[k],n);

if (test_C) {
for (int l=0;l<9>Niveau+1;
} else {
Niveau=0;
}
}
void Noeud::Initialiser_Successeurs(int _nbSuccesseurs) {
/* supprime tous les noeuds fils, et en recrÃ©e des tout nouveaux tout beaux */
if(Successeurs!=ppN_NULL) {
Supprimer_Noeuds_Successeurs();
}
nbSuccesseurs=_nbSuccesseurs;
Successeurs = new pNoeud[nbSuccesseurs];
}
void Noeud::Supprimer_Successeurs() {
/* supprime le tableau de pointeurs vers les successeurs, sans supprimer physiquement la mÃ©moire occupÃ©e par les successeurs */
if(Successeurs!=ppN_NULL) {
delete [] Successeurs;
}
nbSuccesseurs=0;
Successeurs=ppN_NULL;
}
Noeud::Noeud() {
/* constructeur qui effectue les initialisations nÃ©cessaires */
Niveau=0;
nbSuccesseurs=0;
Predecesseur=pN_NULL;
Successeurs=ppN_NULL;
}
Noeud::~Noeud() {
/* apelle une mÃ©thode rÃ©cursive de suppression des noeuds successeurs */
Supprimer_Noeuds_Successeurs();
}
void Noeud::Supprimer_Noeuds_Successeurs() {
/* peu ou prou la mÃªme chose */
for(int i=0; i<nbSuccesseurs; i++) {
delete Successeurs[i];
}
Supprimer_Successeurs();
}
int Noeud::Lire_Niveau() const {
/* retourne la donnÃ©e Niveau, privÃ©e */
return Niveau;
}
int Noeud::Lire_nbSuccesseurs() const {
/* retourne la donnÃ©e nbSuccesseurs, privÃ©e */
return nbSuccesseurs;
}
bool Noeud::valider(bool verbose){
/* renvoie true si la grille associÃ©e au noeud est valide */
Sudoku grille_temporaire=grille.copie();
return grille_temporaire.valider(verbose);
}
void Noeud::Definir_Niveau(int _Niveau) {
/* manipulateur de modification de la donnÃ©e Niveau */
Niveau=_Niveau;
}
void Noeud::Definir_nbSuccesseurs(int _nbSuccesseurs) {
/* manipulateur de modification de la donnÃ©e nbSuccesseurs */
nbSuccesseurs=_nbSuccesseurs;
}
void Noeud::Afficher_Noeud() {
/* mÃ©thode d'affichage d'un Noeud */
Barre(' ',2*Niveau);
cout << Lire_Niveau();
cout << "+ Noeud (" << this << ") :" << " valide:" <<valider(0) << " finie:" << finie()<< endl ;
// affichage + complet de l'arbre, Ã dÃ©commenter si besoin est :
/*Barre(' ',2*Niveau);
cout << " - Niveau = " << Niveau << endl;
Barre(' ',2*Niveau);
cout << " - nbSuccesseurs = " << nbSuccesseurs << endl;
Barre(' ',2*Niveau);
cout << " - Predecesseur = " << Predecesseur << endl;
Barre(' ',2*Niveau);
cout << " - Successeurs[" << nbSuccesseurs << "] = { ";
for(int i=0; i<nbSuccesseurs>0) {
cout << ", ";
}
cout << Successeurs[i];
}
cout << " }" << endl;*/
cout << endl;
}
void Noeud::Afficher_Arbre() {
/* fonction rÃ©cursive de parcours de l'arbre avec affichage de chaque noeud */
Afficher_Noeud();
for(int i=0; i<nbSuccesseurs>Afficher_Arbre();
}
}
bool Noeud::finie(void){
/* retourne true si la grille associÃ©e au noeud est valide */
Sudoku grille_temporaire=grille.copie();
return grille_temporaire.finie();
}
int p_sol=0; // variable globale nÃ©cessaire pour donner le nombre de solutions
void Noeud::parcourir_solutions() {
/* parcours l'arbre, comme pour l'affichage, mais dÃ¨s que la mÃ©thode rencontre un noeud valide et fini, elle l'affiche, et incrÃ©mente p_sol. par contre elle laisse p_soriasis tranquille */
if (valider(0) && finie() ) {
p_sol++;
grille.affichage(0);
}
for(int i=0; i<nbSuccesseurs>parcourir_solutions();
}
}
void Noeud::Creer_Noeuds_Successeurs(int _nbSuccesseurs) {
/* crÃ©e des noeuds successeurs du noeud courant, en copie-collant la grille */
Initialiser_Successeurs(_nbSuccesseurs);
for(int i=0; i<_nbSuccesseurs>Predecesseur=this;
Successeurs[i]->Calculer_Niveau();
Successeurs[i]->grille=grille.copie();
}
}

_________________
Et paf l'évier !

Phelma c'est bien... ou pas ?

P h e l m a

"protos.h"

using namespace std;

class Sudoku;
class Case;
class Pls_cases;
class Noeud;

//fonction utiles
bool Oulogique(bool*,int);
bool parcourir(Pls_cases,int);
bool parcourir2(Pls_cases,int);
void definir_pasposs(Pls_cases&,int,bool&);
bool Ouexclusif(bool*,int);
void charger_depuisfichier(Sudoku&);
void chargermanuellement(Sudoku&);
void creation_arbre_hypotheses(Noeud&);
void Barre(char,int);

class Case{
public:
//donnÃ©es de la classe
int Valeur;
bool possibles[10];
//constructeur. destructeur par dÃ©faut
Case(void);
//mÃ©thodes pour la rÃ©solution
void reduire();
int nombrepossibles();
};

class Pls_cases{
public:
//donnÃ©es de la classe
int Type;
int Num;
Case *cases[9];
Sudoku *sudoku;
//constructeur. destructeur par dÃ©faut
Pls_cases(void);
//mÃ©thodes pour la rÃ©solution
void reduire(bool&);
void reduire_doublettes(bool&);
//mÃ©thodes d'affichage
void affichage();
};

class Sudoku{
public:
//donnÃ©es de la classe
Case cases[9][9];
Pls_cases lignes[9];
Pls_cases zones[9];
Pls_cases colonnes[9];
//Noeud doit Ãªtre une classe amie pour que les mÃ©thodes de rÃ©solution de la classe Noeud puissent accÃ©der aux donnÃ©es de la grille qu'il contient
friend class Noeud;
//constructeurs. destructeur par dÃ©faut
Sudoku(void);
//mÃ©thode de copie
Sudoku copie(void);
//mÃ©thodes d'affichage
void affichage(bool);
//mÃ©thodes pouctr la rÃ©solution
bool valider(bool);
bool finie(void);
void reduire_cases(bool&,bool);
void reduire_pls_cases(bool&,bool);
void reduire_doublettes(bool&,bool);
void reduire_croisements_d(bool&,bool);
void reduire_sans_hyp(bool);
void min_possibilites(int &,int &,int &);
void definirpossibles(void);

};

/*
* Auteur: LANDERCY Jean
* Site Web: http://endorphin.imb.free.fr/
*/
typedef Noeud * pNoeud;
typedef pNoeud * ppNoeud;
const pNoeud pN_NULL=0;
const ppNoeud ppN_NULL=0;

class Noeud {
private:
int Niveau;
int nbSuccesseurs;
void Calculer_Niveau();
void Initialiser_Successeurs(int);
void Supprimer_Successeurs();
public:
pNoeud Predecesseur;
ppNoeud Successeurs;
//constructeurs et destructeurs
Noeud(void);
~Noeud(void);
void Supprimer_Noeuds_Successeurs(); //utilisÃ©e par le destructeur
//manipulateurs des donnÃ©es privÃ©es:
//Lecture
int Lire_Niveau(void) const;
int Lire_nbSuccesseurs(void) const;
//Ecriture
void Definir_Niveau(int);
void Definir_nbSuccesseurs(int);
//mÃ©thode d'affichage
void Afficher_Noeud();
void Afficher_Arbre();

//Ã partir de lÃ : modification de la classe
//classes amies
friend class Sudoku;
friend class Case;
friend class Pls_cases;
//donnÃ©es de la classe
Sudoku grille;
//mÃ©thodes pour la rÃ©solution : modification de la classe
bool valider(bool);
bool finie(void);
void parcourir_solutions();
void Creer_Noeuds_Successeurs(int);

};

_________________
Et paf l'évier !

Phelma c'est bien... ou pas ?

P h e l m a

"main.C"

#include <iostream>
#include <fstream>
#include "protos.h" //prototypes des fonctions et classes
#include "classes.h" //mÃ©thodes des classes
#include "fonctions.h" //fonctions extÃ©rieures aux classes

using namespace std;

class Sudoku;
class Pls_cases;
class Case;
class Noeud;

main(){
int rep=0;
Sudoku grille0;
do{
cout <<solveur>gestion reduction basique"<<endl;
cout <<gestion>gestion croisements deduits"<<endl;
cout <<gestion>gestion exhaustive des solutions" <<endl;
cout << "chargement Ã partir d'un fichier sudoku : tapez 1" <<endl;
cout << "entrÃ©e manuelle des chiffres : tapez 2" <<endl>> rep;
}while(rep!=2 && rep!=1);
if (rep==1){
charger_depuisfichier(grille0);
}
if (rep==2){
chargermanuellement(grille0);
}
//on valide la grille0
bool test=grille0.valider(1);
if(!test){
cout <<"Grille non valide!"<<endl;
return 0;
}else{
cout <<"Grille valide!"<<endl;
//on affiche la grille0 sans la grille des possibles, inutile ici
//on sauvegarde la grille0 puis on commence Ã travailler sur la grille1
Noeud racine;
racine.grille=grille0.copie();
Sudoku grille1=racine.grille.copie();

grille1.reduire_sans_hyp(1);
if (!grille1.finie()) grille1.affichage(1);

if (grille1.finie()) {
cout << "Finie?" <<endl;
if (grille1.valider(0)){
cout << "Finie!"<<endl;
grille0.affichage(0);
grille1.affichage(0);
return 0;
}else{
cout << "RapÃ©... grille non valide" <<endl;
}
}else{
cout << "Debut des hypotheses..." <<endl;
}
Noeud racine_hypotheses;
racine_hypotheses.grille=grille1.copie();
creation_arbre_hypotheses(racine_hypotheses);
//racine_hypotheses.Afficher_Arbre();
racine_hypotheses.parcourir_solutions();//parcours les grilles valides et finies
cout << p_sol << " solutions"<<endl;
return 0;
}
}

_________________
Et paf l'évier !

Phelma c'est bien... ou pas ?

P h e l m a

ça te va ou tu veux aussi les 10 fichiers de mon vrai projet d'info ? Wink

_________________
Et paf l'évier !

Phelma c'est bien... ou pas ?

P h e l m a

	Citation:
	/* * Auteur: LANDERCY Jean * Site Web: http://endorphin.imb.free.fr/ */

Ha non ça on sait faire aussi Rolling Eyes

_________________
Ph e l ma
This is Phelma. Copy Phelma into your signature to help Jetlist' on his way to Google domination!
« les temps comme les oeufs sont durs et la bêtise n'a pas de limite. »
Jetlist = tas de cons

boah genre jlé super modifiée sa classe, regarde un peu Wink

jé gardé le copyright par respect. bon stu veux jtenvoie une autre version sans sa classe mé c moins beau Very Happy

_________________
Et paf l'évier !

Phelma c'est bien... ou pas ?

P h e l m a

ridicules vous êtes les gars Laughing

_________________
6A P h e l m a inside

quoi de la viande après le poisson?
bah non c'est pas un problème, il suffit de prévoir... en plus c'est délicieux !
par contre, les champignons et Phelma c'est signé Dédé...

ok maitre yoda

_________________
Et paf l'évier !

Phelma c'est bien... ou pas ?

P h e l m a

je suis bien d'accord! THIS IS MADNESSSSSSSSSSSSSSSS!

NO !

THIS

IS

SPARTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

_________________
Et paf l'évier !

Phelma c'est bien... ou pas ?

P h e l m a

merde, véro est d'accord avec moi, vous êtes pas ridicules en fait Laughing

_________________
6A P h e l m a inside

quoi de la viande après le poisson?
bah non c'est pas un problème, il suffit de prévoir... en plus c'est délicieux !
par contre, les champignons et Phelma c'est signé Dédé...

comment c'est possible de se faire chier autant alors qu'avec qq boucles j'ai torché un solveur qui marche Question

_________________
Le floodeur fou a encore frappé. D'ailleurs :

Phelma Phelma Phelma Phelma Phelma Phelma Phelma