Bibm@th

Forum de mathématiques - Bibm@th.net

Bienvenue dans les forums du site BibM@th, des forums où on dit Bonjour (Bonsoir), Merci, S'il vous plaît...

Vous n'êtes pas identifié(e).

#26 12-05-2010 18:03:14

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 16 946

Re : [C (et PYTHON)] matrice triangulaires supérieures et inférieures!

Re,

J'avance lentement mais surement (du moins je l'espère).
Je pense pouvoir t'apporter un commencement de début de solution bientôt...

@+

PS
Voilà, ça, ça fonctionne... à peu près :

# include <stdio.h>
# include <stdlib.h>

int main()
{
    float ts[4][4],coeff,pv;
    int i,j,db;

    printf("        Triangularisation de matrices 4 x 4\n\n");
    printf("      Elements\n");
    for (j = 0 ; j<4 ; j++)
        for(i = 0 ; i < 4; i++)
    {
        /* Saisie des valeurs */

            printf("Ligne, %d,colonne, %d : ", j + 1, i + 1);
            scanf("%f", &(ts[j][i]));
    }
 
    system("cls");
   
    printf("\n+--------+--------+--------+-------+\n");
   
    for (j = 0 ; j<4 ; j++)
    {
        printf("| %.2f | %.2f | %.2f | %.2f |\n", ts[j][0], ts[j][1], ts[j][2], ts[j][3]);
        printf("+--------+--------+--------+-------+\n");
    }

    printf("\n\n");
    printf("+--------+--------+--------+-------+\n");
    for (db = 0 ; db<3 ; db++)
        {
            pv=ts[db][db];

            for (i=db ; i<4; i++)
                ts[db][i]=ts[db][i]/pv;
               
            for (j=db+1;j<4;j++)
                coeff=ts[j][db];
                for (i=db;i<4;i++)
                    ts[j][i]=ts[j][i]-coeff*ts[db][i];
         }
               
        for (j = 0 ; j<4 ; j++)
    {
        printf("| %.2f | %.2f | %.2f | %.2f |\n", ts[j][0], ts[j][1], ts[j][2], ts[j][3]);
        printf("+------+------+------+------+\n");
    }        
                             
    system("pause");

    return 0;
}

Ne fait pas les calculs demandés...

@+

Je me suis fait piéger : je trouve un post en double, je le supprime, et voilà le travail : rebelote ! Va falloir attendre que la Base de données de BibM@th ait retrouvé sa sérénité...


Arx Tarpeia Capitoli proxima...

Hors ligne

#27 14-05-2010 09:43:32

Valentin
Membre
Inscription : 17-02-2010
Messages : 143

Re : [C (et PYTHON)] matrice triangulaires supérieures et inférieures!

Bonjour Yoshi,
Je vais essayer de tester ta solution. Sinon, pour l'instant j'ai lu et écrit la matrice. Voici le code qui fonctionne mieux.

#include <stdio.h>
#include <stdlib.h>

void lecture (float tab[4][4]){
    int i,j;
    for(i=1;i<=4;i++){
        for(j=1;j<=4;j++){
            printf("entrez une valeur\n");
            scanf("%f",&tab[i][j]);
         }
     }
     return;
}
        void ecriture (float t[4][4]){
           int i,j;
           for(i=1;i<=4;i++){
               for(j=1;j<=4;j++){
                   printf("%f",t[i][j]);
               }
               printf("\n");
           }
           return;
        }
        main(){
        float tt[4][4];
        lecture(tt);
        ecriture(tt);
        getchar();
        }
Maintenant, il ne reste plus qu'à triangulariser cette matrice.
J'ai trouvé une définition qui dit que "on appelle une matrice triangulaire supérieure toute matrice TS dont les coefficients strictement au-dessous de la diagonale sont nuls: a[i][j] =0 pour i>j"
Dans mon programme où j'ai fait la lecture et l'écriture, il me faudrait insérer avant la fonction main() une opération. D'après cette définition: a[i][j]=0 pour i>j, il va falloir faire une boucle for ou une condition if(i>j){tab[i][j]=0;} je ne sais pas trop!

Hors ligne

#28 14-05-2010 10:50:16

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 16 946

Re : [C (et PYTHON)] matrice triangulaires supérieures et inférieures!

Salut pt'it gard,

Mon dernier code foirait à cause de la mauvaise délimitation des blocs par des accolades.
J'ai tout revu ce matin, ça marche :

# include <stdio.h>
# include <stdlib.h>

int main()
{
    float ts[4][4],coeff,pv;
    int i,j,k,db;
    k=0;
    printf("        Triangularisation de matrices 4 x 4\n\n");
    printf("      Elements\n");
    {
            /* Saisie des valeurs */
        for (j = 0 ; j<4 ; j++)
            {
                for(i = 0 ; i < 4; i++)
                    {
                        printf("Ligne, %d,colonne, %d : ", j + 1, i + 1);
                        scanf("%f", &(ts[j][i]));
                    }
            }
    }
    /* Efface l'écran et affiche la matrice entrée */
    system("cls");
    {
        printf("+------+------+------+------+\n");
   
        for (j = 0 ; j<4 ; j++)
            {
                printf("| %.2f | %.2f | %.2f | %.2f |\n", ts[j][0], ts[j][1], ts[j][2], ts[j][3]);
                printf("+------+------+------+------+\n");
            }
    }
    {
    /* Traitement de la matrice */
        for (db = 0 ; db<3 ; db++)
            {
                {
           /* Normalisation on ramène à 1 le 1er coeff non nul */
                    pv=ts[db][db];
                    for (i=db ; i<4; i++)
                    {
                        ts[db][i]=(ts[db][i])/pv;
                    }
                }
      /* On annule le 1er terme non nul de chaque ligne suivante */    
                {
                    for (j=db+1;j<4;j++)
                        {
                            coeff=ts[j][db];
 
                            for (i=db;i<4;i++)
                                {
                                    ts[j][i]=ts[j][i]-coeff*ts[db][i];
                                }
                        }
                }
            }
    }
    printf("\n\n");
    printf("+------+------+------+------+\n");            
    for (j = 0 ; j<4 ; j++)
    {
        printf("| %.2f | %.2f | %.2f | %.2f |\n", ts[j][0], ts[j][1], ts[j][2], ts[j][3]);
        printf("+------+------+------+------+\n");
    }        
                       
    system("pause");

    return 0;
}

Cela dit, plusieurs questions se posent,
1. Cas éventuel de la division par zéro : que doit-on faire, si au moment du traitement il y a déjà un zéro à l'endroit où on veut en mettre un ? On passe à la ligne suivante ?
2. Pour minimiser les erreurs dues aux valeurs approchées, il est conseillé, à ce que j'ai lu, de diviser la ligne (phase de "normalisation") par le plus grand terme de la ligne. Mais après, on traite comment ?
Dans la matrice de test, la première ligne deviendrait :
0.25 0.5  0.75 1
Et là, faudrait-il multiplier cette ligne par (2/0.25) puisque la deuxième ligne est :
2 3 4 1 ?
3. Comment passer un tableau à une fonction pour modification, puis récupération du tableau modifié dans le programme principal et poursuite du traitement ? J'ai essayé, ça a foiré. Alors comme ce n'était pas indispensable au fonctionnement du programme, j'ai fait autrement...
4. Dans ce que j'ai fait, y a-t-il des accolades inutiles ?
5.

Dans mon programme où j'ai fait la lecture et l'écriture, il me faudrait insérer avant la fonction main() une opération. D'après cette définition: a[i][j]=0 pour i>j, il va falloir faire une boucle for ou une condition if(i>j){tab[i][j]=0;} je ne sais pas trop!

Désolé, rien compris !

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#29 17-05-2010 09:11:33

Valentin
Membre
Inscription : 17-02-2010
Messages : 143

Re : [C (et PYTHON)] matrice triangulaires supérieures et inférieures!

Bonjour Yoshi,
J'ai essayé de tester ton dernier programme, il me demande d'entrer les valeurs de la matrice, mais après il n'affiche pas le résultat! Il fait juste la lecture, au moment d'affichage de résultat, il fait disparaître l'écran!
passage à une fonction: d'après ce que j'ai compris, la fonction se déclare avant la fonction main, cela signifie qu'on fait la lecture-écriture du tableau, puis on fait des opérations que l'on veut, ensuite on rentre dans la fonction main pour afficher le résultat final. C'est cette dernière étape (opération) qui me manque et que je n'arrive pas à faire. Je continue à réfléchir sur ce que tu as fait...

Hors ligne

#30 17-05-2010 10:48:13

Valentin
Membre
Inscription : 17-02-2010
Messages : 143

Re : [C (et PYTHON)] matrice triangulaires supérieures et inférieures!

je ne comprends rien, j'arrive à entrer les valeurs (le programme est compilé et exécuté), mais ça ne m'affiche pas le résultat. J'ai ça comme code:
#include <stdio.h>
#include <stdlib.h>

void lecture (float tab[4][4]){
    int i,j;
    for(i=0;i<4;i++){
        for(j=0;j<4;j++){
            printf("entrez une valeur\n");
            scanf("%f",&tab[i][j]);
         }
     }
     return;
}
        void ecriture (float t[4][4]){
           int i,j;
           for(i=0;i<4;i++){
               for(j=0;j<4;j++){
                   printf("%f",t[i][j]);
               }
               printf("\n");
           }
           return;
        }
        float matrice_triangulaireTS (float tab[4][4]){
              int i,j,k;
              float TS[4][4],coeff,pv;
              for(k=0;k<3;k++){
                  pv=TS[k][k];
                  for(i=k;i<4;i++){
                      TS[k][i]=(TS[k][i])/pv;
                  }
              }
                  for(j=k+1;k<4;k++){
                      coeff=TS[j][k];
                      for(i=k;i<4;i++){
                          TS[j][i]=TS[j][i]-coeff*TS[k][i];
                          }
                      }   
        }
main()
{
        float tt[4][4];
        float TS;
        lecture(tt);
        ecriture(tt);
        printf("la matrice triangulaire est %f",TS);
        getchar();
}

Hors ligne

#31 17-05-2010 10:51:47

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 16 946

Re : [C (et PYTHON)] matrice triangulaires supérieures et inférieures!

Re,

J'ai essayé de tester ton dernier programme, il me demande d'entrer les valeurs de la matrice, mais après il n'affiche pas le résultat! Il fait juste la lecture, au moment d'affichage de résultat, il fait disparaître l'écran!

Là, tu m'en bouches un coin : je me sers de Dev-c++ dernière version qui me donne un résultat sans bavure...
Le system("pause") est là pour temporiser, permettre de lire la console, puis effacer après appui sur n'importe quelle touche.
Je n'ai pas trouvé comment obtenir l'affichage dans une fenêtre windows...
Je reteste et je reviens.

Ça marche, la preuve en image :
affichetriang.png

Essaie dans ce cas autre chose à la place du system("pause") : peut-être est-ce lui qui ne fonctionne pas (chez toi) et la console se ferme dès la dernière entrée validée

Je refais à tout hasard un copier/coller du code qui a fonctionné :

# include <stdio.h>
# include <stdlib.h>

int main()
{
    float ts[4][4],coeff,pv;
    int i,j,k,db;
    k=0;
    printf("        Triangularisation de matrices 4 x 4\n\n");
    printf("      Elements\n");
    {
            /* Saisie des valeurs */
        for (j = 0 ; j<4 ; j++)
            {
                for(i = 0 ; i < 4; i++)
                    {
                        printf("Ligne, %d,colonne, %d : ", j + 1, i + 1);
                        scanf("%f", &(ts[j][i]));
                    }
            }
    }
    /* Efface l'écran et affiche la matrice entrée */
    system("cls");
    {
        printf("+------+------+------+------+\n");
   
        for (j = 0 ; j<4 ; j++)
            {
                printf("| %.2f | %.2f | %.2f | %.2f |\n", ts[j][0], ts[j][1], ts[j][2], ts[j][3]);
                printf("+------+------+------+------+\n");
            }
    }
    {
    /* Traitement de la matrice donnée */
        for (db = 0 ; db<3 ; db++)
            {
                {
           /* Normalisation on ramène à 1 le 1er coeff non nul */
                    pv=ts[db][db];
                    for (i=db ; i<4; i++)
                    {
                        ts[db][i]=(ts[db][i])/pv;
                    }
                }
      /* On annule le 1er terme non nul de chaque ligne suivante */    
                {
                    for (j=db+1;j<4;j++)
                        {
                            coeff=ts[j][db];
                            for (i=db;i<4;i++)
                                {
                                    ts[j][i]=ts[j][i]-coeff*ts[db][i];
                                }
                        }
                }
            }
    }
    printf("\n\n");
    printf("+------+------+------+------+\n");            
    for (j = 0 ; j<4 ; j++)
    {
        printf("| %.2f | %.2f | %.2f | %.2f |\n", ts[j][0], ts[j][1], ts[j][2], ts[j][3]);
        printf("+------+------+------+------+\n");
    }        
                       
    system("pause");

    return 0;
}

Peux-tu passer un peu plus souvent qu'on règle rapidement le problème ?

@+

http://www.dil.univ-mrs.fr/~garreta/generique/autres/UtiliserDevCpp.html a écrit :

Voici quelques explications sur l’utilisation de Dev-C++, un excellent environnement de développement en C et C++ pour Windows XP (et versions antérieures) qu’on peut télécharger librement depuis le site http://www.bloodshed.net
(téléchargements : http://www.bloodshed.net/dev/devcpp.html)
.................
Une autre manière de garder ouverte la console d’exécution consiste à lancer votre programme depuis une fenêtre MS-DOS (appelée, selon le système, « Invite de commandes », « Console MS-DOS », etc.) : vous saisissez et compilez votre programme à l’intérieur de Dev-C++ mais pour l’exécuter vous vous placez dans une fenêtre « Invite de commandes ». Dans ce cas vous ne devez pas ajouter l’instruction system("pause"); à la fin de votre programme.

Il y a éventuellement un petit travail à faire pour se placer dans le répertoire qui contient le programme. La commande pour changer de répertoire est cd, celle pour lister les fichiers d’un répertoire est dir. Enfin, pour lancer un programme il suffit de taper son nom.

Selon les IDE, apparemment, il ne faut pas mettre system("pause") c'est le cas avec un truc nommé blocks:dd ou qq ch comme ça ; avec Dev-C++ il est nécessaire.
Mets-le en commentaire chez toi pour voir...


Arx Tarpeia Capitoli proxima...

Hors ligne

#32 17-05-2010 12:38:03

Valentin
Membre
Inscription : 17-02-2010
Messages : 143

Re : [C (et PYTHON)] matrice triangulaires supérieures et inférieures!

ça fonctionne maintenant! mais comment tu as fait? Il sert à quoi l'étiquette system("pause") et system("cls")? Pourquoi tu fais varier db de 0 à 3? Il représente quoi (c'est le nombre de ligne et de colonne de TS ou le nombre de pivot de la matrice du départ?)?

Hors ligne

#33 17-05-2010 13:20:21

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 16 946

Re : [C (et PYTHON)] matrice triangulaires supérieures et inférieures!

Salut valentin,

Explication de texte.
Et les commentaires ?
system("cls") efface la console après avoir validé la dernière entrée, c'est pourquoi il est placé là.

for (db = 0 ; db<3 ; db++)  -> db va prendre les valeurs 0, 1 et 2
Je m'arrête là (c'est un choix de programmation) parce que les seules lignes où je vais ramener le 1er coefficient non nul à 1 (phase de normalisation) sont les lignes 0, 1 et 2 : les coefficients pv (pivot) à utiliser sont successivement ts[0][0], ts[1][1] et ts[2][2], soit de façon générique  ts[tb][db]...

C'est bien ce qui se passe ici :

                    pv=ts[db][db];
                    for (i=db ; i<4; i++)
                    {
                        ts[db][i]=(ts[db][i])/pv;
                    }

Après
avec db = 0
je vais multiplier successivement chaque case de la ligne n° 0 (donc de la colonne n° 0 à la colonne n°3)
par ts[1][0], ts[2][0] et ts [3][0] et soustraire chaque produit à
* ts[1][0], ts[1][1], ts[1][2], ts[1][3]
* ts[2][0], ts[2][1], ts[2][2], ts[2][3]
* ts[3][0], ts[3][1], ts[3][2], ts[3][3]
3 lignes à traiter de 1 (=db+1) à 3 et 4 colonnes de 0 à 3 (de db à 3)

avec db = 1
je vais multiplier successivement chaque case de la ligne n° 1, sauf la 1ere (donc de la colonne n° 1 à la colonne n°3) par ts[2][1] et  ts[3][1] et soustraire chaque produit à
* ts[2][1], ts[2][2] et ts[2][3]
* ts[3][1], ts[3][2] et ts[3][3]
2 lignes à traiter de 2 (=db+1) à 3 et 3 colonnes de 1 à 3 (de db à 3)

avec db = 2
je vais multiplier successivement chaque case de la ligne n° 2, sauf la 1ere et la 2e (donc de la colonne n° 2 à la colonne n°3) par  ts[3][2] et soustraire chaque produit à
*  ts[3][2] et ts[3][3]
1 ligne à traiter de 3 (=db+1) à 3 et 2 colonnes de 2 à 3 (de db à 3)
Donc pour chaque tour de db, le nombre de lignes et colonnes décroit
C'est le boulot de 2 boucles contrôlées par j (ligne) et i (colonne):

 /* On annule le 1er terme non nul de chaque ligne suivante */    
                {
                    for (j=db+1;j<4;j++)
                        {
                            coeff=ts[j][db];
                            for (i=db;i<4;i++)
                                {
                                    ts[j][i]=ts[j][i]-coeff*ts[db][i];
                                }
                        }
                }

Bien entendu comme tu l'as vu les coordonnées de la 1ere case à annuler dépendent de j pour la ligne et de db pour la colonne : coeff=ts[j][db]; c'est pourquoi, il est intercalé entre la boucle j et la boucle i.

C'est bon ? T'as tout compris ?

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#34 03-06-2010 08:44:27

Valentin
Membre
Inscription : 17-02-2010
Messages : 143

Re : [C (et PYTHON)] matrice triangulaires supérieures et inférieures!

Bonjour Yoshi,
Et voici ma matrice triangulaire supérieure, elle fonctionne à merveille! En fait, il suffisait d'introduire une fonction dans le code. C'était surtout là la grande difficulté!
Merci beaucoup Yoshi pour ton aide et surtout les liens de cours que tu m'as donnés: ils vont, au moins, me permettre de reviser pour mes examens! Enfin, ce fil de discussion m'a été beaucoup plus pratique pour mieux comprendre le cours. Je ne voyais pas trop l'intérêt d'un tableau en langage C, effectivement, il y a bien des ressemblaces et dissemblaces entre maths et informatique, quand l'informatique est bien expliqué logiquement!...C'est surtout cela que je voulais plutôt voir, il y a un melange de deux!

Voici le code de la matrice triangulaire sup:

# include <stdio.h>
# include <stdlib.h>

/* Fonction d'affichage d'une matrice */
void affichage(float ts[4][4]){
    int i=0;
        printf("+----------+----------+----------+----------+\n");
        for (i = 0 ; i<4 ; i++)
            {
                printf("| %8.2f | %8.2f | %8.2f | %8.2f |\n", ts[i][0], ts[i][1], ts[i][2], ts[i][3]);
                printf("+----------+----------+----------+----------+\n");
            }
    }
 
/* Fonction de saisie des valeurs dans une matrice */ 
void saisie (float ts[4][4]){
     int i=0,j=0;
            for (i = 0 ; i<4 ; i++)
            {
                for(j = 0 ; j < 4; j++)
                    {
                        printf("Ligne, %d,colonne, %d : ", i+1, j+1);
                        scanf("%f", &(ts[i][j]));
                    }
            }
    }

/* Fonction de triangularisation d'une matrice */
void triangularisation (float ts[4][4]){
     int db,i,j;
     float coeff,pv;
         /* Traitement de la matrice donnée */
       for (db = 0 ; db<3 ; db++)
       {
           /* On vérifie si le premier nombre sur la diagonale est non nul */
           if(ts[db][db]!=0)
           {
           /* On en fait un pivot, et on normalise le reste de la ligne */
                  pv=ts[db][db];
                  for (j=0 ; j<4; j++)
                  {
                      ts[db][j]=(ts[db][j])/pv;
                  }
           /* On annule le 1er terme non nul de chaque ligne suivante */   
                   for (i=db+1;i<4;i++)
                   {   
                       coeff=(ts[i][db]);
                       for (j=db;j<4;j++)
                       {
                           ts[i][j]=(ts[i][j])-coeff*(ts[db][j]);
                       }
                   }
           /* Affichage en cours de route pour voir l'évolution de la matrice */
      affichage(ts);
           }
      }
}

int main()
{
    float ts[4][4];
    int i,j,db;
    printf("        Triangularisation de matrices 4 x 4\n\n");
    printf("      Elements\n");
   
   saisie(ts);
   system("cls");
   affichage(ts);
   triangularisation(ts);

    printf("\n\n");
   affichage(ts);       
                       
    system("pause");

    return 0;
}

+----------+----------+----------+----------+
|     1.00 |     2.00 |     3.00 |     4.00 |
+----------+----------+----------+----------+
|     2.00 |     3.00 |     4.00 |     1.00 |
+----------+----------+----------+----------+
|     3.00 |     4.00 |     1.00 |     2.00 |
+----------+----------+----------+----------+
|     4.00 |     1.00 |     2.00 |     3.00 |
+----------+----------+----------+----------+
+----------+----------+----------+----------+
|     1.00 |     2.00 |     3.00 |     4.00 |
+----------+----------+----------+----------+
|     0.00 |    -1.00 |    -2.00 |    -7.00 |
+----------+----------+----------+----------+
|     0.00 |    -2.00 |    -8.00 |   -10.00 |
+----------+----------+----------+----------+
|     0.00 |    -7.00 |   -10.00 |   -13.00 |
+----------+----------+----------+----------+
+----------+----------+----------+----------+
|     1.00 |     2.00 |     3.00 |     4.00 |
+----------+----------+----------+----------+
|     0.00 |     1.00 |     2.00 |     7.00 |
+----------+----------+----------+----------+
|     0.00 |     0.00 |    -4.00 |     4.00 |
+----------+----------+----------+----------+
|     0.00 |     0.00 |     4.00 |    36.00 |
+----------+----------+----------+----------+
+----------+----------+----------+----------+
|     1.00 |     2.00 |     3.00 |     4.00 |
+----------+----------+----------+----------+
|     0.00 |     1.00 |     2.00 |     7.00 |
+----------+----------+----------+----------+
|     0.00 |     0.00 |     1.00 |    -1.00 |
+----------+----------+----------+----------+
|     0.00 |     0.00 |     0.00 |    40.00 |
+----------+----------+----------+----------+


+----------+----------+----------+----------+
|     1.00 |     2.00 |     3.00 |     4.00 |
+----------+----------+----------+----------+
|     0.00 |     1.00 |     2.00 |     7.00 |
+----------+----------+----------+----------+
|     0.00 |     0.00 |     1.00 |    -1.00 |
+----------+----------+----------+----------+
|     0.00 |     0.00 |     0.00 |    40.00 |
+----------+----------+----------+----------+
Appuyez sur une touche pour continuer...
Valentin

Dernière modification par Valentin (03-06-2010 08:49:04)

Hors ligne

#35 03-06-2010 16:18:55

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 16 946

Re : [C (et PYTHON)] matrice triangulaires supérieures et inférieures!

Re,

Content de te revoir, je te croyais mort pour l'informatique.
Je vois que mes explications étaient claires : en fait mettre le doigt sur mon petit jeu d'indices, rappelle un peu la recherche de formules avec les suites récurrentes en Maths...
En fait le secret se résume en 3 mots : observer (attentivement), comparer, déduire.
J'ai créé dans le temps sur Amstrad CPC 6128, dans le Basic Locomotive un programme de conjugaison française incollable et très rapide pour un CPU (Z80) cadencé à 4,7 Hz j'ai bien dit Hz tout court, ni MHz, ni GHz....
Je m'étais fixé comme objectif qu'il tienne dans 64 ko...
Ce prog n'a pas de liste de verbes (comme le Bescherelle) : en contrepartie tu peux conjuguer le verbe escalier... ;-)
Tous les temps, tous les modes, Voix Active, Voix passive, forme pronominale...
Il a un module autocorrectif : tu conjugues et il te corrige, avec 1 2 ou 3 essais selon le niveau choisi, il localise l'erreur (23 messages d'erreurs différents) et à la fin, il sort la règle...
En bas de l'écran, un requin se trouve à 6 erreurs d'un poisson (en niveau débutant) : il faut bien répondre pour que le poisson échappe au requin, et pénètre dans une grotte devant lui : à cet instant on entend alors la mélodie de la truite de Schubert...
Mais alors me diras-tu, comment règles-tu le problème des verbes en ir qui se répartissent entre 2e et 3e groupe ? finir, finissant 2e groupe ; mais partir partant 3e groupe : ça c'est bon pour le cerveau humain et ce n'est rien d'autre qu'un lexique...
Mais ton prog  il n'a pas de lexique, alors ?...
Bin, le problème est réglé en 10 lignes : j'ai mis 6 mois pour trouver l'astuce, 6 mois pendant lesquels j'ai mis en pratique mon tryptique observer, comparer, déduire...
Il faut dire que le code est bourré de maths, et que les calculs sont planqués derrière les affichages : même sur une bécane aussi préhistorique, les délais d'attente sont très peu notables : en dessous de la demi-seconde...

La programmation, c'est beaucoup d'obstination et d'inventivité...

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

Réponse rapide

Veuillez composer votre message et l'envoyer
Nom (obligatoire)

E-mail (obligatoire)

Message (obligatoire)

Programme anti-spam : Afin de lutter contre le spam, nous vous demandons de bien vouloir répondre à la question suivante. Après inscription sur le site, vous n'aurez plus à répondre à ces questions.

Quel est le résultat de l'opération suivante (donner le résultat en chiffres)?
soixante huit plus trente cinq
Système anti-bot

Faites glisser le curseur de gauche à droite pour activer le bouton de confirmation.

Attention : Vous devez activer Javascript dans votre navigateur pour utiliser le système anti-bot.

Pied de page des forums