Matematické Fórum

N : intereg; { počet čísel}
...
pole : array[1..N] of integer;
...
{setřiď pole}
pocet := 1;
index := 1;
while index <= N do {pro všechny prvky pole s indexem od 2 do N}
begin
   if pole[index] <> pole[index-1] then {nové číslo - první výskyt}
      pocet := pocet+1;
   index := index+1;
end;
writeln(pocet);

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace elmetrCore.Classes
{
    public class Sort
    {
        /// <summary>
        /// Trideni primym vyberem je zalozeno na opakovanem vybirani 
        /// nejmensiho cisla z doposud nesetridenych cisel. Nalezene cislo
        /// se prohodi s prvkem na zacatku pole a cely postup se opakuje 
        /// tentokrat s nejmensim cislem na indexech 2, ... ,N ktere 
        /// prohodime s druhym prvkem v poli. Pote se postup opakuje s prvky
        /// s indexy 3, ... ,N.
        /// </summary>
        #region SelectSort 
        public static List<int> SelectSort(List<int> A)
        {
            int i, j, k, x;
            int n = A.Count;

            for (i = 1; i < n - 1; i++)
            {
                k = i;

                for (j = i + 1; j < n; j++)
                { 
                    if (A[j]<A[k]) k=j;

                    x=A[k];
                    A[k]=A[i];
                    A[i]=x;
                }
            }
            return A;
        } 
        public static List<int> SelectSort(string filename)
        {
            List <int> A = Mining(filename);
            SelectSort(A);
            return A;
        }
        #endregion SelectSort

        /// <summary>
        /// Trideni primym vkladanim je v podstate podobne. Na zacatku pole
        /// se vytvori spravne utridena posloupnost, kterou postupne 
        /// rozsirujeme. Na zacatku i-teho kroku ma tato utridena pst delku 
        /// i-l. V i-item kroku se urci pozice i-teho cisla v dosud utridene 
        /// posloupnosti a zaradi se do utridene posloupnosti. Zbytek utridene 
        /// posloupnosti se posune o jednu pozici doprava.
        /// </summary>
        #region InsertSort
        public static List<int> InsertSort(List<int> A)
        {
            int i, j, x;
            int n = A.Count;
            for (i = 2; i < n; i++)
            {
                x = A[i];
                j = i - 1;

                while((j>0) && (x<A[j]))
                {
                    A[j + 1] = A[j];
                    j = j - 1;
                }
                A[j + 1] = x;
            }
            return A;
        }

        public static List<int> InsertSort(string filename)
        {
            List <int> A = Mining(filename);
            InsertSort(A);
            return A;
        }
        #endregion InsertSort

        /// <summary>
        /// Bublinkove trideni v podstate jakoby probublava nesetrideny seznam.
        /// Postupne se porovnavaji dvojice sousednich prvku, napr. zleva 
        /// doprava a pokud v porovnane dvojici nasleduje mensi cislo po vetsim,
        /// tak se tato dve cisla prohodi. Cely tento postup se opakuje, dokud
        /// probihaji nejake zmeny. Algoritmus konci tehdy, kdyz jiz nedochazi
        /// k zadne vymene. Tim je pole setridene.
        /// </summary>
        #region BubleSort
        public static List<int> BubleSort(List<int> A)
        {
            int i, x;
            int n = A.Count;
            bool zmena;

            do
            {
                zmena = false;

                for (i = 1; i < n-1; i++)
                {
                    if (A[i] > A[i + 1])
                    {
                        x = A[i];
                        A[i] = A[i + 1];
                        A[i + 1] = x;
                        zmena = true;
                    }
                }
            }
            while(!zmena);
            return A;
        }

        public static List<int> BubleSort(string filename)
        {
            List<int> A = Mining(filename);
            BubleSort(A);
            return A;
        }
        #endregion InsertSort

        /// <summary>
        /// Trideni slevanim neboli Merge Sort je jiz sofistikovanejsi.
        /// Je zalozene na principu spojovani jiz setridenych posloupnosti
        /// dohromady. Pro predstavu, mame-li dve setridene posloupnosti a 
        /// chceme je spojit dohromadz, potom musime porovnat nejmensi prvky
        /// obou posloupnosti a mensi z techto prvku vzdy odstranit a presunout
        /// do nove posloupnosti. Tento algoritmus vyuziva pomocne pole.
        /// </summary>
        #region MergeSort
        public static List<int> MergeSort(List<int> A)
        {
            List<int> Pole = null; // pomocne pole
            /*
             * delka  ... delka setridenych posloupnosti
             *     i  ... index do vytvarene posloupnosti
             * i1, i2 ... index do slevanych posloupnosti
             * k1, k2 ... konce slevanych posloupnosti
             */
            int delka, i, i1, i2, k1, k2;
            int n = A.Count;

            delka = 1;
            while(delka < n)
            {
                i1 = 1;
                i2 = delka + 1;
                i = 1;
                k1 = delka;
                k2 = 2 * delka;

                while(i2<n)
                {
                    // slevani A[i1...k1] a A[i2...k2]
                    if (k2 < n) k2 = n;

                    while((i1<=k1) || (i2<=k2))
                    {
                        
                        if ((i2 > k2) || ((i1 <= k1) && (A[i1] <= A[i2])))
                        {
                            Pole[i] = A[i1];
                            i = i + 1;
                            i1 = i1 + 1;
                        }
                        else
                        {
                            Pole[i] = A[i2];
                            i = i + 1;
                            i2 = i2 + 1;
                        }
                        i1 = k2 + 1;
                        i2 = i1 + delka;
                        k1 = k2 + delka;
                        k2 = k2 + 2 * delka;
                    }
                    A = Pole;
                    delka = 2 * delka;
                }
            }
            return A;
        }

        public static List<int> MergeSort(string filename)
        {
            List<int> A = Mining(filename);
            MergeSort(A);
            return A;
        }
        #endregion MergeSort

        /// <summary>
        /// V case O(N.log N) pracuje také algoritmus QuickSort. Tento algoritmus
        /// je zalozen na metode rozdel a panuj. Nejprve se zvoli pivot (cislo). 
        /// Pak se pole preusporada a rozdeli na dve casti tak, ze zadny prvek
        /// v prvni casti nebude vetsi nez pivot a zadny prvek v druhe casti nebude
        /// mensi nez pivot. Prvky v obou castech se potom rekurzivne setridi. V 
        /// kazdem kroku musi byt obe casti neprazdne, rekurze musi byt konecna.
        /// Pivot se voli nahodne z dosud nesetrideneho useku. Proste se sahne
        /// nekam do pole a nalezeny prvek se prohlasi za pivot. V tomto algoritmu 
        /// se bude za pivot brat prvek uprostred trideneho useku.
        /// </summary>
        #region QuickSort
        public static List<int> QuickSort(List<int> A, int r, int l)
        {
            int i, j, k, x;
            i = 1;
            j = r;
            k=A[(i+j) / 2];
            do
            {
                while(A[i]<k)
                {
                    i=i+1;
                }
                while(A[j]>k)
                {
                    j=j-1;
                }
                if (i<=j)
                {
                    x=A[i];
                    A[i]=A[j];
                    A[j]=x;
                    i=i+1;
                    j=j-1;
                }
            }
            while (i>=j);
            if(j>1) QuickSort(A, 1, j);
            if(i<r) QuickSort(A, i, r);
            return A;
        }

        public static List<int> QuickSort(string filename, int r, int l)
        {
            List<int> A = Mining(filename);
            QuickSort(A, r, l);
            return A;
        }
        #endregion QuickSort

        public static List<int> Mining(string filename)
        {
            List <int> list=null;

            try
            {
                FileStream fs = new FileStream(filename, FileMode.Open);
                StreamReader sr = new StreamReader(fs);
                long pocet = fs.Length;

                list = new List<int>();
                
                string line = "";
                int lineNo = 0;
                
                do
                {
                    line = sr.ReadLine();
                    int line2 = Convert.ToInt32(line);
                    if (line != null)
                    {
                        // zapis udaj do pole
                        list.Add(line2);
                        
                        //Console.WriteLine("{0}: {1}", lineNo, line);
                        lineNo++;
                    }
                } while (line != null);
                sr.Close();
                fs.Close();
            }
            catch (Exception e)
            {
                //Console.WriteLine("Exception in ShowFile: {0}", e);
                MessageBox.Show("Exception in ShowFile: " + e);
            }

            return list;
        } // dolovani z textoveho souboru
    }
}