programme pascal(plongeur) Résolu

Question

Bonjour,

j'aimerais avoir des idee, pour ecrire un programme en langage pascal, qui doit traiter les données d’une compétition de plongeon regroupant cinq plongeurs, effectuant chacun trois plongeons, notés par sept juges. 
nom du plongeur, notes des juges pour chacun de ses plongeons, précédées du coefficient de difficulté de 
ceux-ci. Les coefficients de difficulté des plongeons se situent entre 2 et 3, avec une 
précision de 0,01. Les notes accordées aux plongeurs valent entre 1 et 10, avec une 
précision de 0,1. Les résultats sont calculés et affichés avec une précision de 0,001. 

Pour calculer le résultat final d’un concurrent, on additionne les résultats de chacun 
de ses plongeons, calculés en multipliant le coefficient de difficulté du plongeon par 
la moyenne des notes, desquelles on a retranché la plus haute et la plus basse 
accordées à ce concurrent pour ce plongeon. 

En plus de lire les données et calculer les résultats, le programme produit un rapport affiché à l’écran. Ce rapport présente les plongeurs en ordre décroissant de leur résultat final, et contient les notes et les coefficients de tous leurs plongeons. 

Pour trier les informations, on peut utiliser la méthode d’insertion ou celle de sélection, e 
le programme doit utiliser des enregistrements et/ou des vecteurs (à une et/ou plusieurs dimensions) pour emmagasiner les noms, les données et les résultats des plongeurs.


Quelques idees serais apprecier

lowpien · Answer

voila l'ebauche de mon programme, mais j'ai deja de la misere au niveau de la fonction val, le compilateur me donne une erreur...





program plongeur; 
 

 

const 
  plongeurs = 5; 
  nombre_donnees = 25; 
  notes = 24; 

type 
  plongeur_txt = record                                  
                  nom_txt : string; 
                  coef1_txt : string; 
                  serie1_txt : array[1..7] of string; 
                  coef2_txt : string; 
                  serie2_txt : array[1..7] of string; 
                  coef3 : string; 
                  serie3_txt : array[1..7] of string; 
                 end; 
  notes_txt = array[1..5] of plongeur_txt; 
  plongeur_num = record 
                  nom_num : string; 
                  coef1_num : real; 
                  serie1_num : array[1..7] of real; 
                  coef2_num : real; 
                  serie2_num : array[1..7] of real; 
                  coef3_num : real; 
                  serie3_num : array[1..7] of real; 
                 end; 
  notes_num = array[1..5] of plongeur_num; 

var 
  fiche_notes : text; 
  plongeurs_t : notes_txt; 
  plongeurs_n : notes_num; 
  compteur : integer;                     
  donnees, num_plongeur : integer;       

procedure initialisation; 
  var 
    donnees, num_plongeur : integer; 
  begin 
 
  end; 

procedure extract_notes; 
  var 
    num_plongeur : integer; 
  begin 
    assign (fic_notes, 'D:\Resultat.txt'); 
    reset (fic_notes); 
    for num_plongeur := 1 to nbre_plongeurs do 
      read (fic_notes, plongeurs_t[num_plongeur]); 
    closefile (fic_notes); 
  end; 

procedure converssion_notes; 
  var 
    code : integer; 
    donnees, num_plongeur : integer; 
  begin 
    for num_plongeur := 1 to nbre_plongeurs do 
      for donnees := 2 to nbre_donnees do 
        val(tableau_notes_txt[donnees, num_plongeur], tableau_notes_num[(donnees - 1), num_plongeur], code); 
  end;

KX · Answer

Je fais les remarques au fur et à mesure que je lis ton programme :

Inutile de faire trois types différents pour tes trois séries, alors qu'il s'agit du même type...
Fais un type Serie_Txt=array[1..7] of string que tu utilisera trois fois (idem pour Serie_Num)

Dans ton enregistrement de plongeur, il est inutile de rappeler le _txt ou le _num à chaque fois sinon dans ton code tu vas avoir plongeur_txt.serie1_txt, pongeur_num.serie1_num... c'est lourd !
En général quand on code on préfère en écrire le moins possible, parce que c'est plus clair !

En plus tu écris toujours array[1..5] alors qu'en fait c'est plutôt array[1..Nbre_Plongeur];const Nbre_Plongeurs = 5;
      Nbre_Donnees = 25;
      Notes = 24;

type Serie_Txt = array[1..7] of string;

     Plongeur_Txt = record
                    nom:string;
                    c1,c2,c3 : string;
                    s1,s2,s3 : Serie_Txt;
                    end;

     Notes_Txt = array[1..Nbre_Plongeurs] of Plongeur_Txt;

     Serie_Num = array[1..7] of real;

     Plongeur_Num = record
                    nom:string;
                    c1,c2,c3 : real;
                    s1,s2,s3 : Serie_Num;
                    end;

     Notes_Num = array[1..Nbre_Plongeurs] of Plongeur_Txt;

     Fichier_Notes = Text;De plus tu déclares toutes tes variables 2 fois ! Une fois en globale, et une fois en locale dans chacune de tes procédures... Forcément que ton compilateur plante... À quoi ça sert qu'on ait inventé les paramètres ?

Dans tes procédures les noms ne coïncident pas avec ce que tu déclares (Nbre_Plongeur, Fic_Notes...)
Tu ne peux pas te servir d'un fichier Text pour faire ce que tu veux...

À moins que tu ne code avec Delphi, pour fermer un fichier l'expression est close(fichier) et non closefile

Pour deux types imbriqués comme Notes et Plongeur, il faut d'abord faire appel à plongeur=Notes[i] puis à coefficient=(Notes[i]).c1

D'ailleurs je ne vois pas à quoi sert Nbre_Donnees... Tu m'expliqueras à l'occasion...procedure Extract_Notes(Chemin_Txt:string; var N_Txt:Notes_Txt); // avec Chemin='D:\Resultat.txt'
var f:Fichier_Txt;
begin
assign(f,Chemin_Txt);
reset(f);
read(f, N_Txt);
close(f);
end;

procedure conversion_notes(var N_Txt:Notes_Txt; var N_Num:Notes_Num);
var code,i,j:integer; r:real;
begin
for i:=1 to Nbre_Plongeurs do
    begin
    val(N_Txt[i].c1,N_Num[i].c1,code);
    val(N_Txt[i].c2,N_Num[i].c2,code);
    val(N_Txt[i].c3,N_Num[i].c3,code);
    for j:=1 to 7 do
        begin
        val(N_Txt[i].s1[j],N_Num[i].s1[j],code);
        val(N_Txt[i].s2[j],N_Num[i].s2[j],code);
        val(N_Txt[i].s3[j],N_Num[i].s3[j],code);
        end;
    end;
end;

lowpien · Answer

Nbr_donnees represente le nombre de donnee qui sont entrer (notes(24) + nom du plongeur) mais c'est vrais que en bout de compte je ne l'utilise pas. Mon plan est comme suit, mais je me demandais si je pouvais faire appel a plusieur procedure pour lire le programme sans le surcharger?


function Entree_des_donnees : plongeur_txt;
var b:byte;
begin

writeln; writeln('---- Entree DES DONNEES ----'); writeln;

  for plongeur 1 to 5 do
   
      begin
      writeln('Nom : ');
      
      readln(Nom );
      writeln;
for notes 1 to 3 do
begin
writeln(' notes : ');
readln(notes);
writeln(' coeffient de difficulte : ');
readln(code);
writeln;
      end;
end;




procedure lecture_notes; 
  begin 
    extract_notes; 
    conversion_notes; 
  end; 

procedure exclusion_Notemin_Notemax; 
  begin 

 end; 

procedure calcul_moyenne; 
  begin 
  end; 

procedure calcul_note; 
  begin 
  end; 

procedure note_finale; 
  begin 
  end; 

procedure calcul_resultats; 
  begin 
    exclusion_Notemin_Notemax; 
    calcul_moyenne; 
    calcul_note; 
    note_finale; 
  end; 

procedure afficher_ecran; 
  begin 
  end; 

procedure imprime; 
  begin 
  end; 

procedure rapport; 
  var 
    rep : string[1]; 
  begin 
    repeat                                                                    
      write ('Voulez-vous afficher ou imprimer les notes (tapez A ou I) ? ');  
      readln (rep);                                                             
    until (rep = 'A') or (rep = 'I'); 
    if rep = 'A' then 
      afficher_ecran 
    else 
      imprime; 
  end; 

begin 
  initialisation; 
  extraction_notes; 
  conversion_notes; 
  lecture_notes; 
 calcul_resultats; 
  rapport 

end.

KX · Answer

Pour la forme, j'ai remplacé tous tes 7 par Nbre_Juges une constante que j'ai déclaré au début...procedure Entree_Plongeon(n:integer;var s:Serie_Num;var c:real);
var i:integer;
begin
writeln('Plongeon ',n,' :');
writeln;
write('    Coefficient : ');
readln(c);
writeln;
for i:=1 to Nbre_Juges do
    begin
    write('    Note ',i,' : '); readln(s[i]);
    end;
writeln;
end;

function Entree_Donnees:Notes_Num;
var i:integer;
begin
writeln;
for i:=1 to Nbre_Plongeurs do
with result[i] do
     begin
     write('Nom : '); readln(Nom);
     writeln;
     Entree_Plongeon(1,s1,c1);
     Entree_Plongeon(2,s2,c2);
     Entree_Plongeon(3,s3,c3);
     end;
end;

function Importer_Donnees:Notes_Num;
var Chemin:string; N_Txt:Notes_Txt;
begin
writeln('Import de donnees a partir de quel fichier ?');
readln(Chemin);
Extract_Notes(Chemin,N_Txt);
Conversion_Notes(N_Txt,result);
end;En ce qui concerne ton systeme de calcul (exclusion du min et du max) tu aurais intéret à faire une fonction min, et une fonction max puis de faire directement moyenne=(somme-min-max)/(Nbre_Juges-2)

lowpien · Answer

Si je le met sous cette forme pour faire un tri par  selection ?





TYPE (recherche note_min)
tableaux = ARRAY[1..Notemax] OF INTEGER;
VAR
lesnotes : tableau;
minj, compteur, minx, i, j, notes : INTEGER;

FOR i := 1 TO (Notes – 1) DO
BEGIN
minj := i;
minx := lesnotes[i];
FOR j := (i + 1) TO notes DO
BEGIN
IF (lesnotes[j] < minx) THEN
BEGIN
minj := j;
minx := lesnotes[j];
END;
END;
lesnotes[minj] := lesnombres[i];
lesnotes[i] := minx;
END;





TYPE (recherche note_max)
tableaux = ARRAY[1..Notemax] OF INTEGER;
VAR
lesnotes : tableau;
maxj,  maxx, i, j, notes : INTEGER;

FOR i := 1 TO (Notes – 1) DO
BEGIN
maxj := i;
maxx := lesnotes[i];
FOR j := (i + 1) TO notes DO
BEGIN
IF (lesnotes[j] > maxx) THEN
BEGIN
maxj := j;
maxx := lesnotes[j];
END;
END;
lesnotes[maxj] := lesnombres[i];
lesnotes[i] := maxx;
END;

KX · Answer

Il n'est pas nécessaire de faire un tri pour calculer min et max... On peut même tout faire d'un coup !function Moyenne_Serie(var s:Serie_Num):real;
var min,max,total:real; i:integer;
begin
min:=s[1];
max:=s[1];
total:=s[1];
for i:=2 to Nbre_Juges do
    begin
    total:=total+s[i];
    if s[i]>max then max:=s[i];
    if s[i]<min then min:=s[i];
    end;
result:=(total-min-max)/real(Nbre_Juges-2);
end;

lowpien · Answer

est ce que le 

total:=total+s[i];  c'est le total de tout les  plongeons? pour un plongeur?

et cette ligne result:=(total-min-max)/real(Nbre_Juges-2); est ce une division par le nombre de juges? 

je n'ai donc plus besoin d'ecrire des procedures comme suit? :

procedure exclusion_Notemin_Notemax; 

procedure calcul_moyenne; 

procedure calcul_note; 

procedure note_finale; 

procedure calcul_resultats; 
begin 
exclusion_Notemin_Notemax; 
calcul_moyenne; 
calcul_note; 
note_finale; 
end; 

procedure afficher_ecran; 
 

comment m'y prendre pour faire afficher un rapport qui comprend  les plongeurs en ordre décroissant de leur résultat final, ainsi que leur  notes et les coefficients de tous leurs plongeons. 

je voulais ecrire une procedure de se genre : 
procedure rapport; 
procedure rapport; 
var 
rep : string[1]; 
begin 
repeat 
write ('Voulez-vous afficher ou imprimer les notes (tapez A ou I) ? '); 
readln (rep); 
until (rep = 'A') or (rep = 'I'); 
if rep = 'A' then 
afficher_ecran 
else 
imprime; 
end; 

begin 
 
extraction_notes; 
conversion_notes; 
lecture_notes; 
calcul_resultats; 
rapport 

end.

KX · Answer

Telle que je l'ai écrit, c'est la moyenne des notes (sauf extremum) d'une série de notes (d'un seul plongeon).
C'est à dire que pour avoir la note finale sur 3 sauts (contenues dans N_Num) il faudra faireNoteFinale:= Moyenne_Serie(N_Num.s1)+Moyenne_Serie(N_Num.s2)+Moyenne_Serie(N_Num.s3);La division est en fait celle du nombre de juges-2 puisqu'on ôte 2 des votes !

Sinon pour ton Rapport c'est bien, même si le type string[1] peut-être remplacé par le type char
D'un point de vue présentation on pourrait aussi aider l'utilisateur en acceptant les minusculesprocedure Afficher_Ecran;
begin
writeln('Affichage Ecran');
end;

procedure Imprime;
begin
writeln('Impression');
end;

procedure rapport;
var rep:char;
begin
     repeat
     write('Voulez-vous afficher ou imprimer les notes (tapez A ou I) ? ');
     readln(rep); writeln;
     until (rep='A') or (rep='a') or (rep = 'I') or (rep='i');
if (rep='A') or (rep='a') then afficher_ecran
                          else imprime;
end;


begin
Rapport;
writeln; write('Fin du programme. Appuyer sur Entree'); readln;
end.

lowpien · Answer

Si je fais un recapitulatif j'ai: 

procedure Extract_Notes
procedure conversion_notes
procedure Entree_Plongeon
function Entree_Donnees
function Importer_Donnees
function Moyenne_Serie
procedure Afficher_Ecran
procedure Imprime
procedure rapport

il me semble que je dois avoir une procedure trier, pour classer les notes en ordre decroissant ?

KX · Answer

Si tu utilises une unité il ne sera pas nécessaire de déclarer Entree_Plongeon qui n'est qu'une procédure auxiliaire à Entree_Donnees.

Pour afficher par ordre décroissant, il n'est pas forcément nécessaire de trier les éléments, juste de les afficher dans le bon ordre...

Je vais te montrer mais dis moi d'abord de quelles types de notes tu parles (les notes des juges, ou le score final de tous les plongeurs ?)
Donne un exemple d'affichage pour aller droit au but...

KX · Answer

Logiquement je dirais que ce que tu veux c'est l'affichage du score finaltype Resultats=array[1..Nbre_Plongeurs] of real;

procedure Calculer_Resultats(var N:Notes_Num;var R:Resultats);
var i:integer;
begin
for i:=1 to Nbre_Plongeurs do
    with N[i] do
    R[i]:=c1*Moyenne_Serie(s1)+c2*Moyenne_Serie(s2)+c3*Moyenne_Serie(s3);
end;

procedure Affichage_Scores_Decroissant(N:Notes_Num;R:Resultats);
// R doit déjà contenir les Résultats de N
var i,j,k:integer; max:real; Aux:Resultats;
begin
Aux:=R;
for i:=1 to Nbre_Plongeurs do
    begin
    k:=0; max:=0;
    for j:=1 to Nbre_Plongeurs do
        if Aux[j]>max then begin
                           k:=j;
                           max:=Aux[j];
                           end;
    writeln('Position ',i:2,' (',R[k]:7:3,'pts) : ',N[k].Nom);
    Aux[k]:=0;
    end;
end;Tu vois ça ressemble à du tri mais ce n'en est pas vraiment... Les avantages sans les inconvénients !

lowpien · Answer

Oui je parle du score final de tout les plongeurs, mais aussi les notes de chaque plongeon avec le coefficient de difficulter. 

ex  nom du plongeur 1   score finale 

note plongeon 1         coefficient de difficulter
note plongeon 2          coefficient de difficulter
note plongeon 3          coefficient de difficulter

KX · Answer

En intégrant l'affichage décroissant des notes intermédiairesprocedure Affichage_Notes_Decroissant(S:Serie_Num;C:real);
var i,j,k:integer; max:real; Aux:Serie_Num;
begin
Aux:=S;
writeln('      Difficulte ',C:4:2,') :');
write('        ');
for i:=1 to Nbre_Juges do
    begin
    k:=0; max:=0;
    for j:=1 to Nbre_Juges do
        if Aux[j]>max then begin
                           k:=j;
                           max:=Aux[j];
                           end;
    write(max:5:2);
    Aux[k]:=0;
    end;
writeln;
end;

type Resultats=array[1..Nbre_Plongeurs] of real;

procedure Calculer_Resultats(var N:Notes_Num;var R:Resultats);
var i:integer;
begin
for i:=1 to Nbre_Plongeurs do
    with N[i] do
    R[i]:=c1*Moyenne_Serie(s1)+c2*Moyenne_Serie(s2)+c3*Moyenne_Serie(s3);
end;

procedure Affichage_Scores_Decroissant(N:Notes_Num;R:Resultats);
// R doit déjà contenir les Résultats de N
var i,j,k:integer; max:real; Aux:Resultats;
begin
Aux:=R;
for i:=1 to Nbre_Plongeurs do
    begin
    k:=0; max:=0;
    for j:=1 to Nbre_Plongeurs do
        if Aux[j]>max then begin
                           k:=j;
                           max:=Aux[j];
                           end;
    writeln('Position ',i:2,' (',R[k]:7:3,'pts) : ',N[k].Nom);
    writeln('   Plongeon 1 :'); Affichage_Notes_Decroissant(N[k].s1,N[k].c1);
    writeln('   Plongeon 2 :'); Affichage_Notes_Decroissant(N[k].s2,N[k].c2);
    writeln('   Plongeon 3 :'); Affichage_Notes_Decroissant(N[k].s3,N[k].c3);
    writeln; readln;
    Aux[k]:=0;
    end;
end;

KX · Answer

Bonne fin de soirée, à demain pour d'éventuels autres problèmes...

KX · Answer

Le problème c'est que tu as changé de nombreux types par rapport au code que j'avais fait notamment avec les fichiers et une confusion entre le type Serie_Txt et Notes_Txt, j'essaye de corriger tout ça, mais peut être pas avant mercredi ou jeudi...

lowpien · Answer

Ok, je vais encore essayer de demeler tout ca...

KX · Answer

Salut Lowpien, voici le code complet de ton programme revu et corrigé.
Je l'ai débugé avec Delphi donc tu ne devrais avoir aucun problème à le faire marcher !

Tu remarqueras le changement de certaines notations (_Num et _Txt) et des noms de certaines fonctions.
J'en ai profité pour faire l'équivalent de tes fonctions Afficher et Imprimer mais simultanément...

program lowpien;

{$APPTYPE CONSOLE}

const Nbre_Plongeurs = 2;
      Nbre_Juges = 7;

type Serie = array[1..Nbre_Juges] of real;

     Plongeur = record
                nom : string[50];
                c1,c2,c3 : real;
                s1,s2,s3 : Serie;
                end;

     Notes = array[1..Nbre_Plongeurs] of Plongeur;

     Fichier = file of Notes;

     Resultats = array[1..Nbre_Plongeurs] of real;

// Traitement des Données

procedure Entree_Plongeon(n:integer;var s:Serie;var c:real);
var i:integer;
begin
writeln('Plongeon ',n,' :');
writeln;
write('    Coefficient : ');
readln(c);
writeln;
for i:=1 to Nbre_Juges do
    begin
    write('    Note ',i,' : '); readln(s[i]);
    end;
writeln;
end;

procedure Entree_Donnees(var N:Notes);
var i:integer;
begin
writeln;
for i:=1 to Nbre_Plongeurs do
with N[i] do
     begin
     write('Nom : '); readln(Nom);
     writeln;
     Entree_Plongeon(1,s1,c1);
     Entree_Plongeon(2,s2,c2);
     Entree_Plongeon(3,s3,c3);
     end;
end;

procedure Importer_Donnees(var N:Notes);
var Chemin:string; F:Fichier;
begin
writeln;
writeln('Charger les donnees a partir de quel fichier ?');
write('    '); readln(Chemin); writeln;
assign(F,Chemin);
reset(F);
read(F,N);
close(F);
end;

procedure Exporter_Donnees(var N:Notes);
var Chemin:string; F:Fichier;
begin
writeln('Sauvegarder les donnees vers quel fichier ?');
write('    '); readln(Chemin); writeln;
assign(F,Chemin);
rewrite(F);
write(F,N);
close(F);
end;

// Calculs sur les résultats

function Moyenne_Serie(var s:Serie):real;
var min,max,total:real; i:integer;
begin
min:=s[1];
max:=s[1];
total:=s[1];
for i:=2 to Nbre_Juges do
    begin
    total:=total+s[i];
    if s[i]>max then max:=s[i];
    if s[i]<min then min:=s[i];
    end;
result:=(total-min-max)/(Nbre_Juges-2);
end;
                  
procedure Calculer_Resultats(var N:Notes;var R:Resultats);
var i:integer;
begin
for i:=1 to Nbre_Plongeurs do
    with N[i] do
    R[i]:=c1*Moyenne_Serie(s1)+c2*Moyenne_Serie(s2)+c3*Moyenne_Serie(s3);
end;

// Affichage à l'écran et impression dans un fichier F

procedure Notes_Croissant(var F:Text;S:Serie);
var i,j,k:integer; min:real; Aux:Serie;
begin
Aux:=S;
writeln; writeln(F,'');
for i:=1 to Nbre_Juges do
    begin
    k:=0; min:=10000;
    for j:=1 to Nbre_Juges do
        if Aux[j]<min then begin
                           k:=j;
                           min:=Aux[j];
                           end;
    if (i=1) or (i=Nbre_Juges) then begin
                                    writeln('             ',min:7:2,' *');
                                    writeln(F,'             ',min:7:2,' *');
                                    end
                               else begin
                                    writeln('             ',min:7:2);
                                    writeln(F,'             ',min:7:2);
                                    end;
    Aux[k]:=10000;
    end;
writeln; writeln(F,'');
end;

procedure Scores_Decroissant(var F:Text;N:Notes;R:Resultats);
// R doit déjà contenir les Résultats de N
var i,j,k:integer; max:real; Aux:Resultats;
begin
Aux:=R;
for i:=1 to Nbre_Plongeurs do
    begin
    k:=0; max:=0;
    for j:=1 to Nbre_Plongeurs do
        if Aux[j]>max then begin
                           k:=j;
                           max:=Aux[j];
                           end;  
    writeln('_______________________________________');
    writeln;
    writeln('Position ',i:2,' : ',R[k]:6:3,' pts : ',N[k].Nom);
    writeln(F,'Position ',i:2,' : ',R[k]:6:3,' pts : ',N[k].Nom);
    writeln;
    writeln(F,'');
    writeln('   Plongeon 1  (Coeff ',N[k].c1:0:2,')');
    writeln(F,'   Plongeon 1  (Coeff ',N[k].c1:0:2,')');
        Notes_Croissant(F,N[k].s1);
    writeln('   Plongeon 2  (Coeff ',N[k].c2:0:2,')');
    writeln(F,'   Plongeon 2  (Coeff ',N[k].c2:0:2,')');
        Notes_Croissant(F,N[k].s2);
    writeln('   Plongeon 3  (Coeff ',N[k].c3:0:2,')');
    writeln(F,'   Plongeon 3  (Coeff ',N[k].c3:0:2,')');
        Notes_Croissant(F,N[k].s3);
    readln;
    writeln(F,'_______________________________________');
    writeln(F,'');
    Aux[k]:=0;
    end;
end;

// Programme Principal

var i:integer; N:Notes; R:Resultats; F:Text; S:String;
begin
write('Choix de la base de donnee ?      1. Nouvelle, 2. Ancienne : ');
readln(i);
if i=1 then begin
            Entree_Donnees(N);
            Exporter_Donnees(N);
            end
       else Importer_Donnees(N);
Calculer_Resultats(N,R);
writeln('Dans quel fichier enregistrer le rapport ?');
write('    '); readln(s);
writeln;
assign(F,s); rewrite(F);
Scores_Decroissant(F,N,R);
close(F);
writeln; write('Fin du programme. Appuyer sur Entree'); readln;
end.

lowpien · Answer

En effet le programme a beaucoups changer par rapport au debut, et ca repond a ce que j'essaye de faire ...merci de ton aide...

Programme pascal(plongeur)

18 réponses

Discussions similaires

Newsletters