Licence et Magistère 1ère année de Physique fondamentale Examen d’informatique 2001-2002 première session

Examen d’informatique première session 2002

Le chiffre à côté du titre de la question indique le nombre de points sur 40, les * le niveau de difficulté.

Plus grand entier int, plus grand et plus petit réel double (1) *
Sur Criens :
Quel est l’ordre de grandeur du plus grand entier de type int positif ?
Quel est l’ordre de grandeur du plus grand réel de type double positif ?
Quel est l’ordre de grandeur du plus petit réel de type double non nul et positif ?
Réponse :
Voir cours.

Comparaison de deux réels (1) *

Le programme suivant :
#include<stdio.h>
int main(void)
{
if(0.3*0.3==0.09) printf("normal\n");
else printf("anormal\n");
return (0);
}
donne, avec le compilateur de Criens, le résultat :
anormal
Expliquer en une phrase pourquoi.
Réponse :
Parceque 0.3 n’a pas une représentation finie en binaire.

break et continue (1) *

Quel est le rôle de ces deux instructions ?
Réponse :
Voir cours.

Variables locales et globales (1) *

Qu’est-ce qu’une variable locale, où la déclare-t-on ?
Qu’est-ce qu’une variable globale, où la déclare-t-on ?
Réponse :
Voir cours.

Fonction en argument d’une fonction (2) **

Expliquer quel est l’intérêt de passer une fonction en argument d’une fonction.
Réponse :

1 2004-12-07 22 :00 :37.000000000

Licence et Magistère 1ère année de Physique fondamentale Examen d’informatique 2001-2002 première session

Voir cours.

Compilation et exécution (1) *

Expliquer en quelques lignes ce que sont ces deux opérations.
Réponse :
Voir cours.

Résultats (3) **
Quels résultats donne le programme suivant :
#include<stdio.h>
int main(void)
{
int i=1,j,k;
double x=1.,y,z;
j=x*i/2; k=i/2*x;
y=x*i/2; z=i/2*x;
printf("%d %d %lg %lg\n",j,k,y,z);
return (0);
}
Réponse :
0 0 0.5 0

Pointeurs (3) **
Quel est le résultat fourni par le programme suivant :
#include<stdio.h>
#define N 4
int main(void)
{
double t[N]={1,3,5,7};
double *x;
x=t;
printf("%lg %lg %lg\n",x[2],*x,*(x+1));
printf("%lg %lg\n",x[4],*(x+4));
return (0);
}
Réponse :
5 1 3
4.8543e-270 4.8543e-270

Valeurs extrêmes (4) **

Ecrire une fonction renvoyant en argument le plus petit et le plus grand élément d’un tableau 1 d’entiers passé en
argument de cette fonction. Ecrire un exemple d’appel de cette fonction.
Réponse :
1 à un indice

2 2004-12-07 22 :00 :37.000000000

Licence et Magistère 1ère année de Physique fondamentale Examen d’informatique 2001-2002 première session

#include<stdio.h>
#define N 7
/* ---------------------------------------------------*/
void extremes(int l[],int n,int *li,int *la)
{ int i;
*li=l[0]; *la=l[0];
for(i=1; i<n; i++)
{
if(l[i] < *li) *li=l[i];
if(l[i] > *la) *la=l[i];
}
}
/* ---------------------------------------------------*/
int main(void)
{
int n,l[N]={23,76,98,1,43,212,11},lmin,lmax;
n=N;
extremes(l,n,&lmin,&lmax);
printf("%d %d\n",lmin,lmax);
return (0);
}
/* ---------------------------------------------------*/

Somme partielle (6) ***

La fonction créneaux représentée sur la figure ci-dessous :

O x

Fig. 1 –

a pour développement en série de Fourier :

1 X 2
+∞
+ m(m − 2)(m − 4) cos πlx
2 3lπ
l=1

m étant le reste de la division de l par 4.

On veut tracer la fonction définie par la somme suivante :
1 X 2
s(x) = + m(m − 2)(m − 4) cos πlx
2 3lπ
l=l1 ,l2 ,l3 ,...

les valeurs possibles de l : l1 , l2 , l3 , ... étant quelconques mais entières, strictement positives, deux à deux distinctes
et en nombre inférieur ou égal à un entier N arbitraire.
s(x) est donc simplement la série de Fourier de la fonction créneaux restreinte aux termes pour lesquels l = l 1 , l2 , l3 , ....
Ecrire un programme qui effectue les tâches suivantes :

3 2004-12-07 22 :00 :37.000000000

Licence et Magistère 1ère année de Physique fondamentale Examen d’informatique 2001-2002 première session

1. il demande à l’utilisateur de fournir :

– le nombre de valeurs de l qui vont être utilisées (en lui rappelant au passage qu’il y en a au maximum N 2 )
– les valeurs de l : l1 , l2 , l3 , ... (pas nécessairement dans l’ordre croissant ou décroissant)
– les valeurs de xmin et xmax entre lesquelles il faut calculer s(x)
et il lit ces données à partir du clavier.
2. il écrit dans un fichier nommé sp.res les valeurs nécessaires au tracé par Gnuplot 3 de la courbe représentant la
fonction s(x).
Comment doit-on choisir le pas en x pour tracer la courbe ?
Réponse :

#include<stdio.h>
#include<math.h>
#include<fonctions_magistere.h>
#define N 100
int main(void)
{
int i,n,l[N],lmin,lmax;
double x,dx,xmin,xmax,pi=acos(-1.),u,s;
FILE *fich;
fich=fopen("somme_partielle.res","w");
printf("Combien de valeurs de l (<=%d) ? ",N); scanf("%d",&n);
for(i=0; i<n; i++) {printf("l[%d]=? ",i); scanf("%d",&l[i]);}
printf("Valeurs de xmin et xmax ? "); scanf("%lg %lg",&xmin,&xmax);
/* Determination du pas en x : le pas doit etre petit par rapport a la plus petite periode */
lmax=l[0]; for(i=1; i<n; i++) if(l[i]>lmax) lmax=l[i];
dx=2./lmax/100;
x=xmin;
while(x<=xmax+dx)
{
s=0.5;
for(i=0; i<n; i++)
{
u=l[i]*pi/2;
s=s+sin(u)/u*cos(pi*l[i]*x);
}
fprintf(fich,"%lg %lg\n",x,s);
x=x+dx;
}
fclose(fich);
system("gnuplot somme_partielle.gnu");
return (0);
}

Charges sur un cercle (6) ***

Deux charges ponctuelles Q1 et Q2 sont situées sur un cercle de rayon unité :
2N est défini par un #define
3 aucune instruction Gnuplot n’est demandée

4 2004-12-07 22 :00 :37.000000000

Licence et Magistère 1ère année de Physique fondamentale Examen d’informatique 2001-2002 première session

Q1

θ1

O θ2 x

Q2

Fig. 2 –

La position d’une charge est définie par l’angle polaire θi = (Ox, OQi ).
1. Ecrire une fonction à laquelle on fournit en argument :
les valeurs q1 et q2 des charges
les angles polaires θ1 et θ2
et dont la valeur est l’énergie potentielle électrostatique du système des deux charges.
1
Les valeurs numériques sont dans le système SI, dans lequel = 9 109 .
4πε0
2. Ecrire une seconde fonction qui fait la même chose que celle du 1. mais pour un système de N charges, N étant
défini par un #define N .... Cette seconde fonction doit utiliser celle du 1. Prendre garde à ne pas faire
calculer deux fois les énergies.

Réponse :
#include<stdio.h>
#include<math.h>
#define N 5
/* ------------------------------------------------------------ */
double e(double q1,double q2,double t1,double t2)
{
static double c=9.e9;
double d;
d=sqrt(2*(1-cos(t2-t1)));
if(d==0.) {printf("Charges confondues\n"); exit(1);}
return(q1*q2*c/d);
}
/* ------------------------------------------------------------ */
double en(double q[],double t[],int n)
{
int i,j;
double s=0;
for(i=0; i<n; i++) for(j=i+1; j<n; j++) s=s+e(q[i],q[j],t[i],t[j]);
return(s);
}
/* ------------------------------------------------------------ */

5 2004-12-07 22 :00 :37.000000000

Licence et Magistère 1ère année de Physique fondamentale Examen d’informatique 2001-2002 première session

int main(void)
{
double q1=1,q2=2,t1=1.57,t2=-1.57;
double q[N]={1,3,5,7,9}, t[N]={0,0.2,0.5,0.9,1.4};
printf("Energie (SI) de deux charges=%lg\n",e(q1,q2,t1,t2));
printf("Energie (SI) de N charges=%lg\n",en(q,t,N));
return(0);
}
/* ------------------------------------------------------------ */

Dichotomie (5) ***

On cherche à résoudre une équation f (x) = 0, f étant une fonction continue. On suppose qu’on sait que cette équation
a une racine et une seule dans l’intervalle ]a, b[, tel que f (a)f (b) < 0. On utilise la méthode dichotomique : c étant
le milieu de ]a, b[, la racine est entre a et c si f (a) et f (c) sont de signes opposés. On réitère en prenant le milieu du
nouveau segment jusqu’à obtenir la précision souhaitée.
Ecrire une fonction nommée racine dont la valeur est la racine et qui a pour arguments a, b et la fonction f(x) 4
supposée définie par ailleurs.
Réponse :

#include<stdio.h>
/* ----------------------------------------------------------- */
double racine(double (*f)(double),double a,double b)
{
static double eps=1.e-10;
double xa,xb,xc,u;
xa=a; xb=b;
while(1)
{
xc=(xa+xb)/2.; u=(*f)(xc);
if(u==0.) return(xc);
else
{
if(u*(*f)(xa)>0.) xa=xc;
else xb=xc;
}
if(fabs(xb-xa)<eps) return(xa);
}
}
/* ----------------------------------------------------------- */
double f1(double x)
{
return(x*(x-1)*(x-2));
}
/* ----------------------------------------------------------- */
int main(void)
{
double a,b;
a=0.5; b=1.5;
printf("Entre %lg et %lg racine = %lg\n",a,b,racine(f1,a,b));
a=1.5; b=2.5;
printf("Entre %lg et %lg racine = %lg\n",a,b,racine(f1,a,b));
}
4 qu’on n’a pas à écrire

6 2004-12-07 22 :00 :37.000000000

Licence et Magistère 1ère année de Physique fondamentale Examen d’informatique 2001-2002 première session

/* ----------------------------------------------------------- */

Surface commune à deux disques (6) ***

On considère deux disques de rayons r1 et r2 , dont les centres sont à une distance d l’un de l’autre :

partie
commune

Fig. 3 –

Ecrire un programme qui :

1. détermine si les disques ont une partie commune
2. calcule par une méthode statistique la surface de cette partie commune lorsqu’elle existe (pour cette seconde
question indiquer en une ou deux phrases de commentaire en tête du programme la méthode employée)
Utiliser la fonction alea() sans la réécrire, en ajoutant simplement #include <fonctions magistere.h> en tête du
programme.
On pourra, si l’on veut5 , utiliser le fait que, étant donné des points distribués de façon aléatoire et uniforme sur un
disque de rayon unité, la distance de ces points au centre du disque peut être générée par l’expression sqrt(alea()).
Réponse :

#include<stdio.h>
#include<math.h>
#include<fonctions_magistere.h>
#define N 10000
int main(void)
{
int i,n;
double pi=acos(-1.),dpi=2*pi;
double r1,r2,d,d1,d2,x,y,t,u;
r1=1.; r2=0.5; d=0.5;
/*-------------------------------------------------------------------------------------*/
if(d>r1+r2) {printf("Les disques n’ont pas de partie commmune\n"); return (1);}
printf("Les disques ont une partie commmune\n");
/*-------------------------------------------------------------------------------------*/
/* Premiere methode */
n=0;
5 mais ce n’est pas la seule méthode possible

7 2004-12-07 22 :00 :37.000000000

Licence et Magistère 1ère année de Physique fondamentale Examen d’informatique 2001-2002 première session

for(i=1; i<=N; i++)

{
x=r1*(2*alea()-1); y=r1*(2*alea()-1);
d1=sqrt(x*x+y*y);
u=x-d; d2=sqrt(u*u+y*y);
if(d1<=r1 && d2<=r2) n=n+1;
}
printf("Methode 1\nsurface commune, l’unite etant la surface du disque (1) : %lg\n",(double)n/N*4/pi);
/*-------------------------------------------------------------------------------------*/
/* Seconde methode, un peu plus compliquee mais un peu plus efficace que la premiere */
n=0;
for(i=1; i<=N; i++)
{
d1=r1*sqrt(alea()); t=dpi*alea();
x=d1*cos(t)-d; y=d1*sin(t);
d2=sqrt(x*x+y*y);
if(d2<=r2) n=n+1;
}
printf("Methode 2\nsurface commune, l’unite etant la surface du disque (1) : %lg\n",(double)n/N);
/*-------------------------------------------------------------------------------------*/
return (0);
}

8 2004-12-07 22 :00 :37.000000000