[WikiDyd] [TitleIndex] [WordIndex

Zajęcia 2

1. Program wykonujący operacje na tablicy liczby całkowitych.

   1 using System;
   2 
   3 namespace Wektor
   4 {
   5     class Wektor
   6     {
   7         private int[] v;
   8         public int Length = 0;
   9 
  10         public Wektor(int n)
  11         {
  12             v = new int[n];
  13             for (int i = 0; i < v.Length; i++)
  14                 v[i] = 0;
  15             Length = v.Length;
  16         }
  17 
  18         public void set(int i, int value)
  19         {
  20             v[i] = value;
  21         }
  22 
  23         public int get(int i)
  24         {
  25             return v[i];
  26         }
  27 
  28         public void wypiszNaEkran()
  29         {
  30             System.Console.Write("[");
  31             for (int i = 0; i < v.Length; i++)
  32                 System.Console.Write("{0} ", v[i]);
  33             System.Console.WriteLine("]");
  34         }
  35     }
  36 
  37     class WektorUtils
  38     {
  39         public static void incrInSort(Wektor w)
  40         {
  41             for (int i = 1; i < w.Length; i++)
  42             {
  43                 int tmp = w.get(i);
  44                 int j;
  45                 for (j = i; j > 0 && w.get(j - 1) > tmp; j--)
  46                     w.set(j, w.get(j - 1));
  47                 w.set(j, tmp);
  48             }
  49         }
  50 
  51         public static void decrInSort(Wektor w)
  52         {
  53             for (int i = 1; i < w.Length; i++)
  54             {
  55                 int tmp = w.get(i);
  56                 int j;
  57                 for (j = i; j > 0 && w.get(j - 1) < tmp; j--)
  58                     w.set(j, w.get(j - 1));
  59                 w.set(j, tmp);
  60             }
  61         }
  62     }
  63 
  64     class Program
  65     {
  66         static void Main(string[] args)
  67         {
  68             int n = int.Parse(args[0]);
  69             Wektor w = new Wektor(n);
  70             w.wypiszNaEkran();
  71             Random r = new Random();
  72             for (int i = 0; i < w.Length; i++)
  73                 w.set(i, r.Next(0, 100));
  74             w.wypiszNaEkran();
  75             System.Console.WriteLine("v[{0}]= {1}", n / 2, w.get(n / 2));
  76             WektorUtils.incrInSort(w);
  77             w.wypiszNaEkran();
  78             WektorUtils.decrInSort(w);
  79             w.wypiszNaEkran();
  80         }
  81     }
  82 }

2. Program mierzący czas wykonania funkcji przy wykładniczo rosnącej liczności zbiorów testowych.

   1 using System;
   2 using System.Data;
   3 
   4 namespace CzasWykonywania
   5 {
   6     public class CheckTime
   7     {
   8         DateTime startTime;
   9 
  10         public long check(Osoba objOsoba)
  11         {
  12             DateTime start;
  13             DateTime stop;
  14             TimeSpan t;
  15 
  16             start = DateTime.Now;
  17             objOsoba.wypiszNaEkran();
  18             stop = DateTime.Now;
  19             t = stop.Subtract(start);
  20             return t.Milliseconds;
  21         }
  22 
  23         public DateTime start()
  24         {
  25             startTime = DateTime.Now;
  26             return startTime;
  27         }
  28 
  29         public long stop()
  30         {
  31             DateTime stop = DateTime.Now;
  32             TimeSpan t;
  33             t = stop.Subtract(startTime);
  34             return t.Milliseconds;
  35         }
  36 
  37     }
  38 
  39     public class Osoba
  40     {
  41         String imie;
  42         String nazwisko;
  43 
  44         public Osoba(String aimie, String anazwisko)
  45         {
  46             imie = aimie;
  47             nazwisko = anazwisko;
  48         }
  49 
  50         public void wypiszNaEkran()
  51         {
  52             double g = 1;
  53             for (int i = 0; i <= 100000000; i++)
  54             {
  55                 g += 1;
  56             }
  57             // System.Console.WriteLine("{0} {1}", imie, nazwisko);
  58         }
  59     }
  60 
  61     class Program
  62     {
  63         public static int Main(String[] args)
  64         {
  65             System.Console.WriteLine("Main start.");
  66 
  67             Osoba os;
  68             os = new Osoba("Janek", "Klos");           
  69 
  70             CheckTime stoper = new CheckTime();
  71             System.Console.WriteLine("Czas wykonania (Stoper.check(...)): {0} ms.", stoper.check(os).ToString());
  72 
  73             // lub inaczej:
  74             stoper.start();            
  75             os.wypiszNaEkran();
  76             long t = stoper.stop();
  77             System.Console.WriteLine("Czas wykonania (Stoper): {0} ms.", t);
  78 
  79             System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
  80             sw.Start();
  81             os.wypiszNaEkran();
  82             t = sw.ElapsedMilliseconds;
  83             System.Console.WriteLine("Czas wykonania (Stopwatch): {0} ms.", t);
  84             sw.Stop();
  85 
  86             System.Console.WriteLine("Press enter to close program.");
  87             System.Console.ReadLine();
  88 
  89             return 0;
  90         }
  91     }
  92 }

3. Program sprawdzający rozmiar zajmowanej pamięci.

   1 using System;
   2 using System.Text;
   3 
   4 namespace RozmiarPamieci
   5 {
   6 
   7     class Program
   8     {
   9         static void Main(string[] args)
  10         {
  11             GC.Collect();
  12             Console.WriteLine("Total Memory: {0}", GC.GetTotalMemory(false));
  13 
  14             int[] tabb;
  15             Console.WriteLine("Total Memory: {0}", GC.GetTotalMemory(false));
  16 
  17             Operacje objop = new Operacje();
  18             tabb = objop.Wypel();
  19             tabb = objop.Sortowanie(tabb);
  20             tabb = objop.Wypisz(tabb);                        
  21         }
  22     }
  23     public class Operacje
  24     {
  25         public int[] Wypel()
  26         {
  27             int[] tab = new int[100];
  28             Random rand = new Random();
  29             for (int i = 0; i < tab.Length - 1; i++)
  30             {
  31                 tab[i] = rand.Next(0, 100);
  32             }
  33             return tab;
  34         }
  35         public int[] Sortowanie(int[] tab)
  36         {
  37             int tmp=0;
  38             for (int i = 0; i < tab.Length; i++)
  39             {
  40                 for (int j = 0; j < tab.Length - 1; j++)
  41                 {
  42                     if (tab[j + 1] < tab[j])
  43                     {
  44                         tmp = tab[j];
  45                         tab[j] = tab[j + 1];
  46                         tab[j + 1] = tmp;
  47                         
  48                     }
  49                   Console.WriteLine("Total Memory: {0}", GC.GetTotalMemory(false));
  50                 }
  51             }
  52             return tab;
  53         }
  54         public int[] Wypisz(int[] tab)
  55         {
  56             for (int i = 0; i < tab.Length; i++)
  57             {
  58                Console.WriteLine("posortowana {0}", tab[i]);  
  59             }
  60             return tab;
  61         }
  62 
  63     }
  64 }

4. Wczytaj i zapisz wektor z i do pliku o zadanym formacie. ( nv [ ..... ], nv ......, [ ..... ] ). W poniższym przykładzie wykorzystany jest format: nv [ .... ]. Na zajęciach niezbędna jest umiejętność dostosowania tego formatu do pozostałych dwóch wzorców.

Przykłady plików z wektorami:

   1 using System;
   2 using System.Collections.Generic;
   3 using System.IO;
   4 
   5 namespace WczytywanieWektoraZPliku
   6 {
   7     class Program
   8     {
   9         static void Main(string[] args)
  10         {
  11             Stream stm = new FileStream(args[0], FileMode.Open);
  12             TextReader tr = new StreamReader(stm);
  13 
  14             String s = tr.ReadToEnd();
  15             string [] tokens = s.Split(new char[] { ' ',',' }, StringSplitOptions.RemoveEmptyEntries);
  16 
  17             if (tokens.Length > 0) {
  18                 int v = int.Parse(tokens[0]);
  19                 int i = 0;
  20                 int[] tab = new int[ v ];
  21                 if (tokens[1].Equals("[")) {
  22 
  23                     for (i = 2; i < tokens.Length; i++)
  24                     {
  25                         if (!tokens[i].Equals("]"))
  26                         {
  27                             v = int.Parse(tokens[i]);
  28                             tab[i - 2] = v;
  29                         }
  30                         else
  31                             break;
  32                     }
  33 
  34                     foreach (int vv in tab)
  35                         Console.Write("{0},",vv);
  36 
  37                 } else {
  38                     Console.WriteLine("Nieprawidłowy format pliku. Oczekiwałem [ a otrzymałem {0}.",tokens[1]);
  39                 }
  40             } else {
  41                 Console.WriteLine("Pusty plik?");
  42             }            
  43 
  44             stm.Close();
  45 
  46             Console.ReadLine();
  47         }
  48     }
  49 }

5. Program mierzący czasy sortowania rosnącego i malejącego dla tablic z wartościami losowymi i posortowanymi.

   1 using System;
   2 using System.Data;
   3 
   4 namespace Wektor
   5 {
   6     
   7     class Wektor
   8     {
   9         private int[] v;
  10         public int Length = 0;
  11 
  12         public Wektor(int n)
  13         {
  14             v = new int[n];
  15             for (int i = 0; i < v.Length; i++)
  16                 v[i] = 0;
  17             Length = v.Length;
  18         }
  19 
  20         public void set(int i, int value)
  21         {
  22             v[i] = value;
  23         }
  24 
  25         public int get(int i)
  26         {
  27             return v[i];
  28         }
  29 
  30         public void wypiszNaEkran()
  31         {
  32             System.Console.Write("[");
  33             for (int i = 0; i < v.Length; i++)
  34                 System.Console.Write("{0} ", v[i]);
  35             System.Console.WriteLine("]");
  36         }
  37     }
  38 
  39 
  40     class WektorUtils
  41     {
  42         public static void incrInSort(Wektor w)
  43         {
  44             for (int i = 1; i < w.Length; i++)
  45             {
  46                 int tmp = w.get(i);
  47                 int j;
  48                 for (j = i; j > 0 && w.get(j - 1) > tmp; j--)
  49                     w.set(j, w.get(j - 1));
  50                 w.set(j, tmp);
  51             }
  52         }
  53 
  54         public static void decrInSort(Wektor w)
  55         {
  56             for (int i = 1; i < w.Length; i++)
  57             {
  58                 int tmp = w.get(i);
  59                 int j;
  60                 for (j = i; j > 0 && w.get(j - 1) < tmp; j--)
  61                     w.set(j, w.get(j - 1));
  62                 w.set(j, tmp);
  63             }
  64         }
  65     }
  66 
  67 
  68     public class CheckTime
  69     {
  70         DateTime startTime;
  71                 
  72         public DateTime start()
  73         {
  74             startTime = DateTime.Now;
  75             return startTime;
  76         }
  77 
  78         public double stop()
  79         {
  80             DateTime stop = DateTime.Now;
  81             TimeSpan t;
  82             t = stop.Subtract(startTime);
  83             return t.TotalMilliseconds;
  84         }
  85 
  86     }
  87 
  88     
  89     class Program
  90     {
  91         static void Main(string[] args)
  92         {
  93             System.Console.WriteLine("Main start.");
  94             int n = int.Parse(args[0]);
  95             
  96             Wektor p1 = new Wektor(n);
  97             Wektor p2 = new Wektor(n);
  98             Wektor r1 = new Wektor(n);
  99             Wektor r2 = new Wektor(n);
 100             
 101             //r1.wypiszNaEkran();
 102             //r2.wypiszNaEkran();
 103             //p1.wypiszNaEkran();
 104             //p2.wypiszNaEkran();
 105 
 106             Random r = new Random();
 107             for (int i = 0; i < r1.Length; i++)
 108             {
 109                 p1.set(i, i);
 110                 p2.set(i, i);
 111                 r1.set(i, r.Next(0, 100));
 112                 r2.set(i, r1.get(i));
 113             }
 114 
 115             //r1.wypiszNaEkran();
 116             //r2.wypiszNaEkran();
 117             //p1.wypiszNaEkran();
 118             //p2.wypiszNaEkran();
 119 
 120             CheckTime stoper = new CheckTime();
 121                        
 122             stoper.start();
 123             WektorUtils.incrInSort(p1);
 124             double t = stoper.stop();
 125             System.Console.WriteLine("Czas sortowania rosnacego tablicy posortowanej rosnaco: {0} ms.", t);
 126 
 127             stoper.start();
 128             WektorUtils.decrInSort(p2);
 129             t = stoper.stop();
 130             System.Console.WriteLine("Czas sortowania malejacego tablicy posortowanej rosnaco: {0} ms.", t);
 131 
 132             stoper.start();
 133             WektorUtils.incrInSort(r1);
 134             t = stoper.stop();
 135             System.Console.WriteLine("Czas sortowania rosnacego tablicy z wartosciami przypadkowymi: {0} ms.", t);
 136 
 137             stoper.start();
 138             WektorUtils.decrInSort(r2);
 139             t = stoper.stop();
 140             System.Console.WriteLine("Czas sortowania malejacego tablicy z wartosciami przypadkowymi: {0} ms.", t);
 141 
 142             System.Console.WriteLine("Press enter to close program.");
 143             System.Console.ReadLine();
 144             
 145         }
 146     }
 147 }

6. Do programy 1, dodaj funkcję która podzieli dany wektor na dwie części względem zadanego indeksu. Funkcja powinna otrzymywać trzy argumenty: wektor 1, wektor 2 oraz indeks względem którego wykonywany jest podział.

Przykładowa deklaracja:

   public void split( Wektor lewy, Wektor prawy, int index );

7. Dodaj klasę przechowującą dwuwymiarowe macierze.

8. Zmodyfikuj program 1 tak aby wektor przechowywał oraz operował na zmiennych typu double.

9. Wykorzystaj klasę CheckTime z programu 2 do przetestowania czasu wykonywania sortowania przez wstawianie z przykładu 1.

10. Wykorzystaj procedury do obsługi sprawdzania rozmiaru zajmowanej pamięci i za ich pomocą przetestuj program 1, dla zbioru danych typu double, przy rozmiarach wektora: 10, 100, 1000 oraz 10000.


2015-09-23 06:32