daily pastebin goal
7%
SHARE
TWEET

Untitled

a guest Dec 16th, 2017 53 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <iostream>  // cout, cin
  2.  
  3. using namespace std;
  4.  
  5. struct t_coord
  6. {
  7.     double valeur;
  8.     int indice; // 1 ? Dimension
  9.     t_coord *suiv;
  10. };
  11.  
  12. struct t_vecteur
  13. {
  14.     int dimension;
  15.     double defaut;
  16.     t_coord *tete;
  17. };
  18.  
  19. void initialiser(t_vecteur &v, int d, double dft)
  20. {
  21.     v.dimension = d;
  22.     v.defaut = dft;
  23.     v.tete = nullptr;
  24. }
  25.  
  26. void vider(t_vecteur &v)
  27. {
  28.     t_coord *tmp;
  29.     tmp = v.tete;
  30.  
  31.     while(tmp != nullptr)
  32.     {
  33.         t_coord *n = tmp->suiv;
  34.         delete tmp;
  35.         tmp = n;
  36.     }
  37.  
  38.     delete tmp;
  39.     v.tete = nullptr;
  40. }
  41.  
  42. void modifier(t_vecteur &v, int i, double val)// on suppose l'indice <= dimension
  43. (precondition)
  44. {
  45.     if(v.tete != nullptr)// il y a au moins une valeur significative
  46.     {
  47.         t_coord *svt = v.tete; // on stock le premier maillon
  48.         t_coord *prv = nullptr;// et celui avant lui donc nullptr au debut
  49.         while(svt != nullptr && svt->indice < i) // en gros ici on va chercher le
  50. premier maillon dont l'indice est >= ? i
  51.         {                                        //comme ca on ajoute le nouveau
  52. maillon dans un ordre logique par rapport aux indices et pas en vrac
  53.             prv = svt;
  54.             svt = svt->suiv;
  55.         }
  56.  
  57.         if(svt != nullptr) // Si indice >= i (en effet si != nullptr alors la boucle
  58. s'est forcement arret?e a cause de la 2?me condition)
  59.         {
  60.             if(svt->indice == i)// Si indice = 1
  61.             {
  62.                 if(val != v.defaut) // et que la valeur != defaut, on remplace
  63.                 {
  64.                     svt->valeur = val;
  65.                 }
  66.                 else // sinon on supprime car le maillon n'est plus significatif
  67.                 {
  68.                     if(prv == nullptr) // donc si il n'y avait que la tete
  69.                         vider(v); // on vide car on a remplac? par une valeur par
  70. defaut (cf le if/else au dessus)
  71.                     else // si il y avait plus que 1 maillon
  72.                     {
  73.                         if(svt->suiv != nullptr) // et que ce n'est pas le dernier
  74. du chainage
  75.                         {
  76.                             prv->suiv = svt->suiv; // on court circuite
  77.                             delete svt; // on degage le 'flottant'
  78.                             svt = nullptr; // peut etre pas obligatoire, par
  79. securite on fais ca quand meme
  80.                         }
  81.                         else // si c'etait le dernier maillon du chainage
  82.                         {
  83.                             delete svt; // on le supprime
  84.                             prv->suiv = nullptr; // on fait pointer celui d'avant
  85. sur null et pas random zone memoire
  86.                         }
  87.                     }
  88.                 }
  89.             }
  90.             else // si l'indice est superieur ? i
  91.             {
  92.                 if(val != v.defaut) // on ajoute avant svt si necessaire (donc si
  93. pas valeur par defaut)
  94.                 {
  95.                     t_coord *nouveau = new t_coord;
  96.                     nouveau->indice = i;
  97.                     nouveau->valeur = val;
  98.                     nouveau->suiv = svt;
  99.                     if(prv == nullptr)
  100.                     {
  101.                         v.tete = nouveau;
  102.                     }
  103.                     else
  104.                         prv->suiv = nouveau;
  105.                 }
  106.             }
  107.         }
  108.         else //si null alors ce la implique que prv a un indice < i donc on ajoute
  109. apres prv
  110.         {
  111.             t_coord *nouveau = new t_coord;
  112.             nouveau->indice = i;
  113.             nouveau->valeur = val;
  114.             prv->suiv = nouveau;
  115.         }
  116.     }
  117.     else // il n'y a aucune coord significatives pour le moment
  118.     {
  119.         if(val != v.defaut) // on cr?e le premier maillon si necessaire
  120.         {
  121.             v.tete = new t_coord;
  122.             v.tete->indice = i;
  123.             v.tete->valeur = val;
  124.             v.tete->suiv = nullptr;
  125.         }
  126.     }
  127. }
  128.  
  129. void saisir(t_vecteur &v)
  130. {
  131.     int r = 0;
  132.     cout << "###### Nouvelle Saisie ######\n" << endl;
  133.     cout << "Avez vous une coordonn?e significative ? rajouter? (0 pour non, 1 pour
  134. oui)" << endl;
  135.     cin >> r;
  136.     bool termine = r == 0? true:false;
  137.     while(!termine)
  138.     {
  139.         int ind = 0;
  140.         int val = 0;
  141.         cout << "A quel indice voulez vous rajouter une valeur significative?" << endl;
  142.         cin >> ind;
  143.         cout << "Quelle valeur? (diffente de " << v.defaut << ")" << endl;
  144.         cin >> val;
  145.         modifier(v,ind,val);
  146.  
  147.         cout << "\n\n Bien recu, Avez vous une autre coordonn?e significative ?
  148. rajouter? (0 pour non, 1 pour oui)" << endl;
  149.         cin >> r;
  150.         termine = r == 0? true:false;
  151.     }
  152. }
  153.  
  154.  
  155. // pas tres efficace comme algo mais ?a fait le taff
  156. void afficher(t_vecteur v, bool complet)
  157. {
  158.     cout << "[" ;
  159.     if(complet)
  160.     {
  161.         for(int i = 1; i<=v.dimension;i++) // indice commence a 1
  162.         {
  163.             t_coord *tmp = v.tete;
  164.  
  165.             while(tmp != nullptr && tmp->indice < i)
  166.             {
  167.                 tmp = tmp->suiv;
  168.             }
  169.             if(tmp != nullptr && tmp->indice == i)
  170.             {
  171.                 cout << tmp->valeur << ",";
  172.             }
  173.             else
  174.             {
  175.                 cout << v.defaut << ",";
  176.             }
  177.         }
  178.         cout << "\b";
  179.     }
  180.     else
  181.     {
  182.         for(int i = 1; i<=v.dimension;i++) // indice commence a 1
  183.         {
  184.             t_coord *tmp = v.tete;
  185.  
  186.             while(tmp != nullptr && tmp->indice < i)
  187.             {
  188.                 tmp = tmp->suiv;
  189.             }
  190.             if(tmp != nullptr && tmp->indice == i)
  191.             {
  192.                 cout << "I"<< i << ":" <<tmp->valeur << ",";
  193.             }
  194.         }
  195.         cout << "\b"; // on supprime la derniere virgule
  196.     }
  197.  
  198.     cout << "]" << endl;
  199. }
  200.  
  201. t_vecteur somme (t_vecteur v1, t_vecteur v2)
  202. {
  203.     t_vecteur res;
  204.     initialiser(res,v1.dimension,v1.defaut+v2.defaut);
  205.  
  206.     t_coord *t1 = v1.tete;
  207.     t_coord *t2 = v2.tete;
  208.  
  209.     while(t1 != nullptr || t2 != nullptr)
  210.     {
  211.         if(t1 != nullptr && t2 != nullptr)
  212.         {
  213.             if(t1->indice == t2->indice)
  214.             {
  215.                 modifier(res,t1->indice,((t1->valeur)+(t2->valeur)));
  216.                 t1 = t1->suiv;
  217.                 t2 = t2->suiv;
  218.             }
  219.             else
  220.             {
  221.                 if(t1->indice < t2->indice)
  222.                 {
  223.                     modifier(res,t1->indice,t1->valeur + v2.defaut);
  224.                     t1 = t1->suiv;
  225.                 }
  226.                 else
  227.                 {
  228.                     modifier(res,t2->indice,t2->valeur + v1.defaut);
  229.                     t2 = t2->suiv;
  230.                 }
  231.             }
  232.         }
  233.         else if(t1 == nullptr)
  234.         {
  235.             modifier(res,t2->indice,t2->valeur+v1.defaut);
  236.             t2 = t2->suiv;
  237.         }
  238.         else
  239.         {
  240.             modifier(res,t1->indice,t1->valeur+v2.defaut);
  241.             t1 = t1->suiv;
  242.         }
  243.     }
  244.  
  245.     return res;
  246. }
  247.  
  248. t_vecteur produit (t_vecteur v1, t_vecteur v2)
  249. {
  250.     t_vecteur res;
  251.     initialiser(res,v1.dimension,v1.defaut*v2.defaut);
  252.  
  253.     t_coord *t1 = v1.tete;
  254.     t_coord *t2 = v2.tete;
  255.  
  256.     while(t1 != nullptr || t2 != nullptr)
  257.     {
  258.         if(t1 != nullptr && t2 != nullptr)
  259.         {
  260.             if(t1->indice == t2->indice)
  261.             {
  262.                 modifier(res,t1->indice,((t1->valeur)*(t2->valeur)));
  263.                 t1 = t1->suiv;
  264.                 t2 = t2->suiv;
  265.             }
  266.             else
  267.             {
  268.                 if(t1->indice < t2->indice)
  269.                 {
  270.                     modifier(res,t1->indice,t1->valeur * v2.defaut);
  271.                     t1 = t1->suiv;
  272.                 }
  273.                 else
  274.                 {
  275.                     modifier(res,t2->indice,t2->valeur * v1.defaut);
  276.                     t2 = t2->suiv;
  277.                 }
  278.             }
  279.         }
  280.         else if(t1 == nullptr)
  281.         {
  282.             modifier(res,t2->indice,t2->valeur*v1.defaut);
  283.             t2 = t2->suiv;
  284.         }
  285.         else
  286.         {
  287.             modifier(res,t1->indice,t1->valeur*v2.defaut);
  288.             t1 = t1->suiv;
  289.         }
  290.     }
  291.  
  292.     return res;
  293. }
  294.  
  295.  
  296. //question optionelle, pas super optimis? comme algo mais ca marche
  297. t_vecteur conversion (double t[],int taille)
  298. {
  299.     double popVal = t[0];
  300.     int occurMax = 0;
  301.  
  302.     for(int i = 0; i<taille;i++)
  303.     {
  304.         int compteur = 1;
  305.         for(int j = i+1; j<taille;j++)
  306.         {
  307.             if(t[i] == t[j]) compteur++;
  308.         }
  309.         if(compteur > occurMax)
  310.         {
  311.             occurMax = compteur;
  312.             popVal = t[i];
  313.         }
  314.     }
  315.  
  316.     t_vecteur res;
  317.     res.dimension = taille;
  318.     res.defaut = popVal;
  319.  
  320.     for(int i = 0; i<taille;i++)
  321.     {
  322.         if(t[i] != popVal)
  323.         {
  324.             modifier(res,i+1,t[i]);
  325.         }
  326.     }
  327.  
  328.     return res;
  329. }
  330.  
  331. int main()
  332. {
  333.     /*t_vecteur vecteur;
  334.     t_vecteur v2;
  335.     initialiser(v2,10000000,1);
  336.     initialiser(vecteur,10000000,0);
  337.     saisir(v2);
  338.     saisir(vecteur);
  339.     //afficher(vecteur,false);
  340.     //afficher(v2,false);
  341.  
  342.     t_vecteur som = somme(v2,vecteur);
  343.     afficher(som,false);
  344.     t_vecteur prod = produit(v2,vecteur);
  345.     afficher(prod,false);
  346.  
  347.     vider(v2);
  348.     vider(vecteur);
  349.     vider(som);
  350.     vider(prod);*/
  351.  
  352.  
  353.  
  354.     // ### test de la partie optionnelle ###
  355.     double t[10] = {1,0,2,3,0,4,5,0,4,6};
  356.     t_vecteur t2v = conversion(t,10);
  357.     afficher(t2v,true);
  358.  
  359.     vider(t2v);
  360.  
  361.  
  362.  
  363.     return 0;
  364. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top