Langage C

[invite8c0f8078]

Salut,
je suis débutant en langage C; donc je souhaite savoir:
1. comment fait on pour retrouver le PGCD et le PPCM de deux variables?
BRIDGE:
2. Dans la fonction rand(), y a pas un moyen de dire au programme qu'il ne donne pas le meme nombre 2 fois, c'est dans une question du Bridge, ou ils disent vous tirez o hasard 5 cartes entre 1 et 13, ça ok, mais apres sans que 2 nombres identiques soit tirés en meme temps!!!
et 2ème question tjs sur le bridge, ils disent afficher les résultats par ordre croissant, commen on fai?
Finalement, quand on a des tableaux et qu'on veux remplir les tableaux on ecrit quoi? moi je fait par exemple dans la boucle for, table[rand()%13]++; c bon ou pa
-----

[invite7a8ce750]

Houla que de questions ...

Salut,
je suis débutant en langage C; donc je souhaite savoir:
1. comment fait on pour retrouver le PGCD et le PPCM de deux variables?

Il y a un algorithme très célèbre pour le PGCD, c'est l'algorithme d'Euclide (fait une petite recherche sur wikipedia). Une fois que tu as le PGCD tu trouves facilement le PPCM avec la formule

BRIDGE:
2. Dans la fonction rand(), y a pas un moyen de dire au programme qu'il ne donne pas le meme nombre 2 fois, c'est dans une question du Bridge, ou ils disent vous tirez o hasard 5 cartes entre 1 et 13, ça ok, mais apres sans que 2 nombres identiques soit tirés en meme temps!!!

Non y'a pas. C'est à toi de gérer les nombres que tu as tiré et de t'assurer que tu ne retires pas les mêmes. Par exemple, simplement, tu pourrais

1. faire
   1. tirer un nombre n
   2. si celui-ci n'est pas dans le tableau des nombres tirés,
      1. le rajouter
      2. n est un nouveau nombre
   3. sinon ce n'est pas un nouveau nombre
2. tant que le nombre n n'est pas un nouveau nombre

et 2ème question tjs sur le bridge, ils disent afficher les résultats par ordre croissant, commen on fai?

Tu dois trier tes éléments dans ton tableau.
De nombreux algorithmes existent pour faire ça.
Une recherche sur Wikipedia par exemple avec « tri »
te donnera le tri sélection et le tri bulle qui sont faciles à mettre en œuvre.

Qui sont « ils » ? « ils » ont l'air bien exigeant

Finalement, quand on a des tableaux et qu'on veux remplir les tableaux on ecrit quoi? moi je fait par exemple dans la boucle for, table[rand()%13]++; c bon ou pa

Ta boucle est incomplète. Difficile de te dire si ça marche. Mais je suppose que non. Car tu aimerais je suppose quelque chose du genre

 table[i]=(rand()%13)+1;

Cependant il faudrait nous dire avec quoi tu veux remplir ton tableau et combien tu as de cellules à remplir...
Sinon difficile de le deviner.

PS: le C est un mauvais langage de programmation pour commencer. D'ailleurs ce n'est plus un bon langage. -_- Pour développer à haut niveau, il vaut mieux choisir autre chose.
(je sais je me répète)

[invite7a8ce750]

Tu es passé du poker au bridge ??
Un amateur de cartes je vois ^_^

[invite74b73858]

Meuh non c'est le passé et l'avenir le C

[A voir en vidéo sur Futura]

[BertrandR]

2. Dans la fonction rand(), y a pas un moyen de dire au programme qu'il ne donne pas le meme nombre 2 fois, c'est dans une question du Bridge, ou ils disent vous tirez o hasard 5 cartes entre 1 et 13, ça ok, mais apres sans que 2 nombres identiques soit tirés en meme temps!!!

Bonjour,

Avant le premier appel à rand() il faut faire un appel à la fonction randomize(), pour initialiser le générateur de nombre aléatoire. randomize() utilise la date et l'heure pour générer un nombre qui n'est jamais le même (mais qui n'est pas aléatoire). Ainsi la séquence de tirage de la fonction rand() ne sera jamais la même.

et 2ème question tjs sur le bridge, ils disent afficher les résultats par ordre croissant, commen on fai?
Finalement, quand on a des tableaux et qu'on veux remplir les tableaux on ecrit quoi? moi je fait par exemple dans la boucle for, table[rand()%13]++; c bon ou pa

Pour faire une tri par ordre croissant il faut utiliser une routine de tri du genre Quicksort() (faire un recherche sur Google). Ce qui est marrant avec cet algorithme c'est qu'il utilise les capacités de récurrence du C : la fonction s'appelle elle-même.
Pour le remplissage des tableaux, là il faut que tu cherches un peu... c'est vraiment trop basique.

Bon courage.

[invite8c0f8078]

Et si j'utilisais srand((time(NULL)), ça marcherais je pense

Qui sont « ils » ? « ils »

Ils c'est les profs de l'info: Introduction o langage C niveau bac+2

Et puis je ne passe pas du Bridge o poker, , c'est que je me suis trompé c'est bien du Bridge dont je parle, parce que ct le sujet d'exam de l'année dernière, on devrai faire ça en langage C, et avec les tableaux exclusivement donc...

Merci, et tt les commentaires et ameliorations sont les bienvenues

[BertrandR]

Et si j'utilisais srand((time(NULL)), ça marcherais je pense

Ben surtout pas, parce que time() te renvoie une structure time_t et ce n'est pas précisement ce qu'il faut donner à srand en paramètre. randomize() c'est plus simple.

[Jean_Luc]

Ben surtout pas, parce que time() te renvoie une structure time_t et ce n'est pas précisement ce qu'il faut donner à srand en paramètre. randomize() c'est plus simple.

En fait si ca va marcher car time_t est défini comme un long (du moins sur pas mal de platforme). Tu auras peut etre un warning....

Non y'a pas. C'est à toi de gérer les nombres que tu as tiré et de t'assurer que tu ne retires pas les mêmes. Par exemple, simplement, tu pourrais

1. faire
   1. tirer un nombre n
   2. si celui-ci n'est pas dans le tableau des nombres tirés,
      1. le rajouter
      2. n est un nouveau nombre
   3. sinon ce n'est pas un nouveau nombre
2. tant que le nombre n n'est pas un nouveau nombre

Tu peux aussi générer un permutation alléatoire :

void swap(int *c1,int *c2) {

  int temp = *c1;
  *c1 = *c2;
  *c2 = temp;

}

#define N 10
int p[N];
int i;

for(i=0;i<N;i++)
  p[i] = i;

for(i=0;i<N;i++)
  swap( &(p[i]) , &(p[rand() % N]));

[BertrandR]

En fait si ca va marcher car time_t est défini comme un long (du moins sur pas mal de platforme). Tu auras peut etre un warning....

Tu as raison j'ai confondu avec la fonction gettime() et la structure time.
Je me suis également planté en parlant de récurrence alors que je voulais parler de récursivité.

[invite7a8ce750]

Nithael > Le C est un langage dépassé en tant que langage de programmation de haut niveau. Il a été créé pour remplacer l'assembleur et en son temps fut un pionner efficace et élégant. Mais c'est fini. Il est largement dépassé par des jeunes (python) et des vieux (lisp.. et oui) pour ce qui est de faire de la programmation a haut niveau ^_^ Je ne m'étendrais pas plus puisque ce n'est pas le sujet exactement (même si le titre est « Langage C »)

BertrandR > Si j'ai bien compris, le problème de frue20 n'est pas de générer des séries aléatoires. Il veut qu'en générant sa suite il n'y ait pas deux fois le même nombre. Ais-je raison frue20 ? Dans ce cas, il faut que tu fasses ce que j'ai dit...

Jean-Luc > La solution est plus élégante et efficace... mais 1) tu n'aurais pas du lui donner un morceau de code: il est en train d'apprendre. Un pseudo code est plus riche en enseignement car tu dois le convertir. De plus, avant de donner une solution efficace, on commence par les plus évidente Ça fait des catastrophes quand on donne trop trop vite (c'est l'expérience qui parle).

[Jean_Luc]

Jean-Luc > La solution est plus élégante et efficace... mais 1) tu n'aurais pas du lui donner un morceau de code: il est en train d'apprendre. Un pseudo code est plus riche en enseignement car tu dois le convertir. De plus, avant de donner une solution efficace, on commence par les plus évidente Ça fait des catastrophes quand on donne trop trop vite (c'est l'expérience qui parle).

C'est vrai, désolé, la prochaine fois j'essayerai d'etre plus pédagogue...

[invite7a8ce750]

C'est vrai, désolé, la prochaine fois j'essayerai d'etre plus pédagogue...

Remarque, je dis ça mais peut-être que frue20 a très bien compris. Il ne dit plus mot.

[invite6de5f0ac]

Bonjour,

Pour ce problème de bridge, je suggère une autre possibilité, plus basée sur mon expérience de la simulation (non non, je ne me prends pas la grosse tête, c'est juste à titre d'exemple).

On a au départ un jeu de 52 cartes (ou 54 avec les 2 Jokers, ou 78 pour un jeu de Tarot...) que l'on peut représenter par un tableau de 52 éléments, rempli par n'importe quelle boucle classique. C'est l'équivalent d'un jeu de casino qui est déscellé à sa première (et dernière) utilisation.

On mélange ce jeu. Par exemple, on tire un nombre (n) entre 1 et 52 et on permute les cartes (n) et (n+1), modulo 52 bien entendu. Ceci à refaire un nombre suffisant de fois pour avoir un "bon" mélange, mais l'opération est tellement élémentaire qu'une bonne dizaine de milliers de fois devrait être suffisante. Et je ne vais pas me lancer dans l'analyse théorique de cet algorithme, en tout cas pas à cette heure...

Et on donne les 13 premières cartes du jeu. Ou les 13 premières en n'en prenant qu'une sur 4, si on tient au réalisme de la simulation. Je ne pense pas que cela joue, mais par acquit de conscience...

Et pour les classer par ordre croissant, je n'utiliserais certainement pas Quicksort sur une main de 13 cartes... N'importe quel Bubblesort le plus foireux fera le boulot convenablement. Mais un tri par insertion (Shellsort, Heapsort) me semble s'imposer puisque dans mes cours il est toujours comparé à "la méthode utilisée par un joueur de bridge pour classer les cartes qu'il a en main". Et en plus il a la même performance moyenne que dans le pire cas, alors...

Bon jeu,

-- françois

[invite8c0f8078]

Merci merci pour toutes les aides que vous m’avez donné sur le Bridge, ct pour simuler des parties de Bridge en langage C, et ct assez bien réussi.
Par contre là on a nouveau problème toujours en langage C : toutes les contributions sont les bienvenues !! Ça permet d’améliorer son programme lol.
Le but est de créer un algorithme permettant de calculer des fonctions harmoniques dont les valeurs au bord du domaine sont imposés, le domaine D est un carré de longueur 1 discrétisé en N+1 points.
Et on impose l’utilisation de tableaux en 2D

[invite7a8ce750]

[...]
Et pour les classer par ordre croissant, je n'utiliserais certainement pas Quicksort sur une main de 13 cartes... N'importe quel Bubblesort le plus foireux fera le boulot convenablement. Mais un tri par insertion (Shellsort, Heapsort) me semble s'imposer puisque dans mes cours il est toujours comparé à "la méthode utilisée par un joueur de bridge pour classer les cartes qu'il a en main". Et en plus il a la même performance moyenne que dans le pire cas, alors...
[...]
-- françois

Le bubblesort est probablement le plus approprié dans ce cas. Le meilleur des cas est d'ordre linéaire. Quand on a des petits ensembles, on peut aisément tombé sur ce meilleur des cas. Le quicksort voit alors son désavantage devenir probable (le pire des cas, qui est quadratique).

[invite8c0f8078]

Voici un programme qui devrait calculer le laplacien d'une fonction quelquonque et retourner la valeur trouvé, j'ai proposé ça "en tant que débutant", mais ça marche pas,
si vous pouvez me trouver les erreurs merci bcp! c'est urgent
#include<stdio.h>
#include<math.h>
#define N 100
double F[N+1][N+1];
void initializeF (void){
int i, j;
double x; x=(double)i/N;
double y; y=(double)j/N;
for(i=0; i<=N; i++)
for(j=0; j<=N; j++)
//F[i][j]=x+2*y;
x*x+2*y*y;
//x/(x*x+(y*y+1+2*y))
//exp(x)*cos(y)
}
double laplacien (int i; int j){
int i, j;
double laplacien;
laplacien=(N*N)*(F[i+1][j]+F[i-1][j]+F[i][j-1]+F[i][j+1]-4*F[i][j]);
for(i=0; i<=N; i++)
for(j=0; j<=N; j++)
laplacien=laplacien+1;
return laplacien;
}
int main (void){
initializeF();
laplacien();
printf(" Le laplacien vaut %g\n", laplacien);
system("pause");
return 0;
}

[invite6de5f0ac]

Bonjour,

Qu'est-ce que tu essayes de faire là:

void initializeF (void){
     int i, j;
     double x; x=(double)i/N;
     double y; y=(double)j/N;
     for(i=0; i<=N; i++)
              for(j=0; j<=N; j++)
                       //F[i][j]=x+2*y;
                       x*x+2*y*y;
                       //x/(x*x+(y*y+1+2*y))
                       //exp(x)*cos(y)
}

Tes x, y sont en-dehors de la boucle ils ne seront donc pas modifiés. Et les i,j ne sont pas initialisés. Et l'expression surlignée (en rouge) n'est assignée à rien... Bref, il manque beaucoup de choses!

-- françois

[invite8c0f8078]

Bonjour,

Qu'est-ce que tu essayes de faire là:

void initializeF (void){
     int i, j;
     double x; x=(double)i/N;
     double y; y=(double)j/N;
     for(i=0; i<=N; i++)
              for(j=0; j<=N; j++)
                       //F[i][j]=x+2*y;
                       x*x+2*y*y;
                       //x/(x*x+(y*y+1+2*y))
                       //exp(x)*cos(y)
}

Tes x, y sont en-dehors de la boucle ils ne seront donc pas modifiés. Et les i,j ne sont pas initialisés. Et l'expression surlignée (en rouge) n'est assignée à rien... Bref, il manque beaucoup de choses!

-- françois

JE M'ADRESSE A TOUS lol
Alors j'explique, on s'interresse a des fonctions harmoniques à 2D dont le domaine D de définition est un carré de coté 1 que l'on discretisera, c.à.d qu'on le ramène a une grille de N+1 points de coté, la fonction étudié sera représenté par un tableau à 2D F[i][j] de type double, les indices i et j varient de 0 à N, et la valeur F[i][j] représentant f(i/N, j/N)
ECRIRE une fonction qui initialise le tableau F[i][j] aux valeurs d'une fonction f(par exemple x+2*y), et une qui calcule le laplacien de f aux points i et j... j'ai proposé un programme a parament ça marche pas,... C URGENT LOL

[invite6de5f0ac]

Rebonjour,

Allez, va, c'est en fait pas si faux ce que tu as écrit... Voilà comment il faut faire en vrai:

void initializeF (void)
{
    int i, j ;
    double x, y ;

    for (i = 0 ; i <= N ; i++)
        for (j = 0 ; j <= N ; j++)
        {
            x = (double) i / N ;
            y = (double) j / N ;
            F[i][j] = x * x + y * y ; // par exemple
        }
}

Bon travail!

-- françois

[invite8c0f8078]

double laplacien (int i; int j){
int i, j;
double laplacien;
laplacien=(N*N)*(F[i+1][j]+F[i-1][j]+F[i][j-1]+F[i][j+1]-4*F[i][j]);
for(i=0; i<=N; i++)
for(j=0; j<=N; j++)
laplacien=laplacien+1;
return laplacien;
}
DANS CETTE FONCTION y a un truc qui va pas, je vois pas c'est quoi... quand je compile il me dit
19 expected `,' or `...' before ';' token, la ligne 19 c'est celle du doublelaplacien(int i; int j){

[invite6de5f0ac]

Facile (et erreur classique, même par simple inattention) : point-virgule au lieu de virgule dans la liste de paramètres. Il faut écrire:

double laplacien (int i, int j)

C'est vrai que le message d'erreur n'est pas très explicite.

- françois

[invite8c0f8078]

#include<stdio.h>
#include<math.h>
#define N 100
double F[N+1][N+1];
void initializeF (void){
int i, j ;
double x, y ;
for (i = 0 ; i <= N ; i++)
for (j = 0 ; j <= N ; j++)
{
x = (double) i / N ;
y = (double) j / N ;
F[i][j] = x * x + 2*y * y ; // par exemple
//F[i][j]=x+2*y;
//x/(x*x+(y*y+1+2*y))
//exp(x)*cos(y)
}
}
double laplacien (int i, int j){
int i, j;
double laplacien;
laplacien=(N*N)*(F[i+1][j]+F[i-1][j]+F[i][j-1]+F[i][j+1]-4*F[i][j]);
for(i=0; i<=N; i++)
for(j=0; j<=N; j++)
laplacien=laplacien+1;
return laplacien;
}
int main (void){
initializeF();
laplacien();
printf(" Le laplacien vaut %g\n", laplacien);
return 0;
}
DONC O FINAL J'AI EU çA, mais il compile pas lol
Il genere le message suivant in fonction double laplacien(int, int) declaration of int i, int j shadows a parameter, et apres il dit too few arguments in fonction double laplacien(int, int)... Merci pour ton aide fderwelt... je vois pas trop là et en plus je prépare un tp tro dur pour demain, je dois apres créer des fichiers et tt, mais là fau passer cette étape pour que j'avance lol ... Merci en tt cas

[invite6de5f0ac]

Aïe aïe aïe... tu devrais vraiment revoir tes cours de C (à moins que tu n'apprennes par toi-même?)

D'abord il est inutile de redéclarer i et j à l'intérieur de la fonction. C'est même nuisible, puisque ce seront des variables locales à la fonction, qui masquent les arguments du même nom donnés dans les parenthèses.

De même, la déclaration "double laplacien" à l'intérieur de la fonction collisionne avec l'en-tête de fonction. Il faut utiliser une autre variable.

Et tes deux boucles for imbriquées avec "laplacien = laplacien+1", je ne comprends pas trop... Je ne me souviens plus exactement de la formule correcte, mais je crois que tu essayes en fait de sommer l'expression au-dessus pour toutes les vameurs de i et j. Et de toutes façons, il mr drmblr qu'on calcule le laplacien en un point, comme déclaré dans l'en-tête de fonction.

Ensuite dans ton main(), tu appelles la fonction "laplacien" sans lui passer d'arguments, et tu n'utilises pas le résultat qu'elle renvoie. Alors...

Bon alors:

double laplacien (int i, int j)
{
    double L ;
    L = (N*N)*(F[i+1][j]+F[i-1][j]+F[i][j-1]+F[i][j+1]-4*F[i][j]) ; // là je supposes que tu sais ce que tu fais
    return L ;
}

main ()
{
    int ii, jj ;
    double lap ;
    initializeF () ;
    printf ("Valeurs de i et j ? ") ;
    scanf ("%d%d", &ii, &jj) ;
    lap = laplacien (ii, jj) ;
    printf ("Le laplacien vaut %lf\n", lap) ;
}

Ce qui est marrant, c'est que tu programmes avec pratiquement que des variables globales (comme dans les vieux Basic) zt quee tu déclares plusieurs fois la même chose (comme en Fortran)...

-- françois

[invite7a8ce750]

[...]
C'est vrai que le message d'erreur n'est pas très explicite.
[...]

Moi je trouve ça très explicite :

19 expected `,' or `...' before ';' token

À la ligne 19, il manque probablement une « , » avant le « ; »

Mon cher Frue20, il va falloir que tu apprennes à trouver tes erreurs tout seul. C'est chiant, c'est fatiguant, c'est souvent à s'arracher les cheveux mais c'est comme ça qu'on fini par apprendre où faire attention. Tant que tu seras incapable de trouver ce genre d'erreur tu vas en baver en programmation.

Quand tu nous dis que tu ne trouves pas, c'est que tu n'as pas assez cherché. Tu vois bien que chaque erreur est très simple. Quand tu penseras avoir cherché très méticuleusement ligne par ligne sans l'avoir trouvé, c'est qu'en fait tu n'auras pas cherché assez méticuleusement. Alors il faudra recommencer. Prendre une pause, et recommencer.

C'est ça la vie du programmeur. Un programme ne pardonne rien.