SHARE
TWEET

Untitled

a guest Dec 3rd, 2019 75 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. using System;
  2. using System.Collections.Generic;
  3.  
  4. class ExoListe
  5. {
  6.     static void Main()
  7.     {
  8.         List<int> f = new List<int>() { 1, 2, 9, 11, 14 };
  9.         Random r = new Random();
  10.  
  11.  
  12.         List<int> fe = new List<int>() { 3, 5, 8, 12 };
  13.        
  14.  
  15.         // List<int> fer = new List<int>() { 1, 2, 4, 2, 99, 9, 8, 7, 2, 7, 6 };
  16.        
  17.  
  18.         // interclassementDeuxListeTrie(fe, f);
  19.         // TriParInsertion(fer);
  20.  
  21.         List<int> fer = new List<int>() { 503, 087, 512, 061, 908, 170, 897, 275, 653, 426, 154, 509, 612, 677, 765, 703 };
  22.         TriParFusion(fer);
  23.         // interclassementDeuxListeTrie(f, fe);
  24.  
  25.  
  26.     }
  27.     public static List<int> fibonacci(int n)
  28.     {
  29.         List<int> fibonacci = new List<int>();
  30.         fibonacci.Add(1);
  31.         fibonacci.Add(1);
  32.         for (int i = 2; i < n; i++)
  33.         {
  34.             fibonacci.Add(fibonacci[i - 1] + fibonacci[i - 2]);
  35.         }
  36.         return fibonacci;
  37.     }
  38.     public static void show(List<int> li)
  39.     {
  40.         foreach (int nbr in li)
  41.         {
  42.             Console.Write(nbr + " ,");
  43.         }
  44.         Console.WriteLine();
  45.     }
  46.  
  47.     public static int occ(List<int> li, int x)
  48.     {
  49.         int occu = 0;
  50.         for (int i = 0; i < li.Count; i++)
  51.         {
  52.             if (x == li[i])
  53.             {
  54.                 occu++;
  55.             }
  56.         }
  57.         return occu;
  58.  
  59.     }
  60.  
  61.     public static int firstAppa(List<int> li, int x)
  62.     {
  63.         int index = -1;
  64.         int i = 0;
  65.         while (i < li.Count && index == -1)
  66.         {
  67.             if (li[i] == x)
  68.             {
  69.                 index = i;
  70.             }
  71.         }
  72.         return index;
  73.     }
  74.     public static int firstAppaTrie(List<int> li, int x)
  75.     {
  76.         int index = -1;
  77.         int i = 0;
  78.         while (i < li.Count && index == -1 && li[i] <= x)
  79.         {
  80.             if (li[i] == x)
  81.             {
  82.                 index = i;
  83.             }
  84.             i++;
  85.         }
  86.         return index;
  87.     }
  88.  
  89.     public static int max(List<int> li)
  90.     {
  91.         int maxI = 0;
  92.         for (int i = 1; i < li.Count; i++)
  93.         {
  94.             if (li[i] > li[maxI])
  95.             {
  96.                 maxI = i;
  97.             }
  98.         }
  99.         return li[maxI];
  100.     }
  101.  
  102.     public static int min(List<int> li, int borneInf, int borneSup)
  103.     {
  104.         int minI = borneInf;
  105.         for (int i = borneInf + 1; i <= borneSup; i++)
  106.         {
  107.             if (li[i] < li[minI])
  108.             {
  109.                 minI = i;
  110.             }
  111.         }
  112.         return li[minI];
  113.     }
  114.  
  115.     public static bool estTrie(List<int> li)
  116.     {
  117.         bool estTrie = true;
  118.         int i = 1;
  119.         while (i < li.Count && estTrie)
  120.         {
  121.             if (li[i - 1].CompareTo(li[i]) > 0)
  122.             {
  123.                 estTrie = false;
  124.             }
  125.             i++;
  126.         }
  127.         return estTrie;
  128.     }
  129.     public static bool estTrieSousListe(List<int> li, int borneInf, int borneSup)
  130.     {
  131.         bool estTrie = true;
  132.         int i = borneInf + 1;
  133.         while (i <= borneSup && estTrie)
  134.         {
  135.             if (li[i - 1].CompareTo(li[i]) > 0)
  136.             {
  137.                 estTrie = false;
  138.             }
  139.             i++;
  140.         }
  141.         return estTrie;
  142.     }
  143.  
  144.     /* /
  145.     public static int rangValSup(List<int> li, int x) {
  146.         int index = -1;
  147.         int i = 0;
  148.         while (i < li.Count && index == -1) {
  149.             if (li[i] > x) {
  150.                 index=i;
  151.             }
  152.         }
  153.         return index;
  154.     } */
  155.     public static List<int> TriParInsertion(List<int> li)
  156.     {
  157.         // Version à moi
  158.         // List<int> liTrie = new List<int>();
  159.         // liTrie.Add(li[0]);
  160.         // for (int i = 1; i < li.Count; i++)
  161.         // {
  162.         //     int rangValSup = -1;
  163.         //     for (int j = 0; j < liTrie.Count && rangValSup == -1; j++)
  164.         //     {
  165.         //         if (liTrie[j] > li[i])
  166.         //         {
  167.         //             rangValSup = j;
  168.         //         }
  169.         //     }
  170.         //     if (rangValSup == -1)
  171.         //     { // Pas de valeur supérieur
  172.         //         liTrie.Add(li[i]);
  173.         //     }
  174.         //     else
  175.         //     {
  176.         //         liTrie.Insert(rangValSup, li[i]);
  177.         //     }
  178.  
  179.         //     Console.WriteLine(rangValSup);
  180.         //     show(li);
  181.         //     show(liTrie);
  182.         // }
  183.         // return liTrie;
  184.  
  185.         // Version P12.
  186.         List<int> listTrie = new List<int>();
  187.         listTrie.Add(li[0]);
  188.         li.RemoveAt(0);
  189.         while (li.Count > 0) {
  190.             int indexValSup = -1;
  191.             int i = 0;
  192.             while (indexValSup == -1 && i < listTrie.Count) {
  193.                 if (listTrie[i] > li[0]) {
  194.                     indexValSup = i;
  195.                 }
  196.                 i++;
  197.             }
  198.  
  199.             if (indexValSup == -1) { // Pas de valeur sup.
  200.                 listTrie.Add(li[0]);
  201.             }  else {
  202.                 listTrie.Insert(indexValSup, li[0]);
  203.             }
  204.  
  205.             li.RemoveAt(0);
  206.             show(li);
  207.             show(listTrie);
  208.             Console.WriteLine();
  209.         }
  210.        
  211.         show(listTrie);
  212.         return listTrie;
  213.     }
  214.  
  215.     public static void criblePremier(List<int> li)
  216.     {
  217.         for (int n = li.Count - 1; n >= 0; n--)
  218.         {
  219.             bool estDivisible = false;
  220.             int i = 2;
  221.             while (i <= 9 && !estDivisible)
  222.             {
  223.                 if (li[n] % i == 0 && i != li[n])
  224.                 {
  225.                     estDivisible = true;
  226.                 }
  227.                 i++;
  228.             }
  229.             if (estDivisible)
  230.             {
  231.                 li.Remove(n);
  232.             }
  233.         }
  234.         show(li);
  235.     }
  236.  
  237.     public static List<int> interclassementDeuxListeTrie(List<int> li1, List<int> li2)
  238.     {
  239.         List<int> listeTrie = new List<int>();
  240.  
  241.         while (li1.Count > 0 && li2.Count > 0)
  242.         {
  243.             if (li1[0] <= li2[0])
  244.             {
  245.                 listeTrie.Add(li1[0]);
  246.                 li1.RemoveAt(0);
  247.             }
  248.             else
  249.             {
  250.                 listeTrie.Add(li2[0]);
  251.                 li2.RemoveAt(0);
  252.             }
  253.             // show(li1);
  254.             // show(li2);
  255.             // show(listeTrie);
  256.         }
  257.  
  258.         if (li1.Count > 0) {
  259.             for (int i = 0; i < li1.Count; i++)  {
  260.                 listeTrie.Add(li1[i]);
  261.             }
  262.         } else if (li2.Count > 0) {
  263.             for (int i = 0; i < li2.Count; i++)  {
  264.                 listeTrie.Add(li2[i]);
  265.             }    
  266.         }
  267.         return listeTrie;
  268.     }
  269.     public static int plusGrandeMonotonie(List<int> li)
  270.     {
  271.         List<int> monotonie = new List<int>();
  272.         int longueurMaxMonotonie = 1;
  273.         int longueurMonotonieActuelle = 1;
  274.         int indexStartMonotonie = 0;
  275.         for (int i = 1; i < li.Count; i++)
  276.         {
  277.  
  278.             if (li[i] > li[i - 1])
  279.             {
  280.                 longueurMonotonieActuelle++;
  281.             }
  282.  
  283.             // Si non n < n+1 et que la longueur de la dernière monotonie est maximale:
  284.             else if (longueurMonotonieActuelle > longueurMaxMonotonie)
  285.             {
  286.                
  287.                 longueurMaxMonotonie = longueurMonotonieActuelle;
  288.                 // Rappel: On est au i tel que li[i] < li[i-1] (début de la monotonie suivante.)
  289.                 // Pour ne pas avoir la ligne suivante, on pourrait aussi créer 2 variables "index" ici.
  290.                 indexStartMonotonie = i - longueurMaxMonotonie;
  291.                 longueurMonotonieActuelle = 1;
  292.             }
  293.         }
  294.  
  295.         // On reconstruit une liste = plus grande monotonie croissante
  296.         for (int i = indexStartMonotonie; i < longueurMaxMonotonie + indexStartMonotonie; i++)
  297.         {
  298.             monotonie.Add(li[i]);
  299.         }
  300.         show(li);
  301.         show(monotonie);
  302.         return longueurMaxMonotonie;
  303.     }
  304.  
  305.     public static void TriParFusion(List<int> li) {
  306.         List<int> listTrie = new List<int>();
  307.         List<int> indexMonotonieCroissante = new List<int>();
  308.  
  309.         indexMonotonieCroissante.Add(0);
  310.         for (int i = 1; i < li.Count; i++) {
  311.             if (li[i-1] > li[i]) {
  312.                 indexMonotonieCroissante.Add(i);                
  313.             }
  314.         }
  315.  
  316.  
  317.         for (int i = 0; i < indexMonotonieCroissante.Count; i++) {
  318.             int tempIndex = indexMonotonieCroissante[i];
  319.             int tempIndexEnd = -1;
  320.             if (i < indexMonotonieCroissante.Count-1) {
  321.                 tempIndexEnd = indexMonotonieCroissante[i+1];
  322.             } else if (i == indexMonotonieCroissante.Count-1) {
  323.                 tempIndexEnd = li.Count;
  324.             }
  325.  
  326.             List<int> tempListMonotonie = new List<int>();
  327.             for (int j = tempIndex; j < tempIndexEnd; j++) {
  328.                 tempListMonotonie.Add(li[j]);
  329.             }
  330.             Console.Write("Monotonie traitée : ");
  331.             show(tempListMonotonie);
  332.             if (i == 0) {
  333.                 listTrie = tempListMonotonie;
  334.             } else {  
  335.                 listTrie = interclassementDeuxListeTrie(tempListMonotonie, listTrie);
  336.             }
  337.             show(listTrie);
  338.             Console.WriteLine();
  339.         }
  340.  
  341.     }
  342. }
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