s.selekcje
	static void Sort(int[] L)
        {
            for (int i = 0; i < L.Length - 1; i++)
            {
                int k = i;
                for (int j = i + 1; j < L.Length; j++)
                {
                    if (L[k] > L[j])
                    {
                        k = j;
                    }
                }
                int t = L[k];
                L[k] = L[i];
                L[i] = t;
            }
        }
s.wstawianie
	static void Wstawianie( int[] tab )
	{
		for( int i = 1; i < tab.Length; i++ )
		{
			int key = tab[ i ];
			int j = i;
			while( j > 0 && tab[ j - 1 ] < key )
			{
				tab[ j ] = tab[ j - 1 ];
				j--;
			}
			tab[ j ] = key;
		}
	}
S.bombelkowe
	static void Sort(int[] L)
        {
            int N = L.Length;

            for (int i = 0; i < N; i++)
            {
                for (int j = N - 1; j > i; j--)
                {
                    if (L[j] < L[j - 1])
                    {
                        int t = L[j - 1];
                        L[j - 1] = L[j];
                        L[j] = t;
                    }
                }
            }
            for (int i = 0; i < N; i++)
            {
                Console.Write(L[i]+", ");
            }
        }
S.zliczanie
	static int[] Sort(int[] tab, int k)
        {
           int[] licznik = new int[k+1];
            int[] tab2 = new int[tab.Length];
            for (int i = 0; i < tab.Length; i++)
            {
                licznik[tab[i]]++;
            }
            for (int i = 0; i < k; i++)
            {
                licznik[i + 1] += licznik[i];
            }
            for (int i = tab.Length - 1; i >= 0; i--)
            {
                tab2[licznik[tab[i]] - 1] = tab[i];
                licznik[tab[i]]--;
            }
            return tab2;
        }
MergeSort
	 static void Scalaj(int[] T, int p, int mid, int k)
        {
            int[] T2 = new int[T.Length];
            int p1 = p, k1 = mid;
            int p2 = mid + 1, k2 = k;
            int i = p1;
            while ((p1 <= k1) && (p2 <= k2))
            {
                if (T[p1] < T[p2])
                {
                    T2[i] = T[p1]; p1++;
                }
                else
                {
                    T2[i] = T[p2]; p2++;
                }
                i++;
            }
            while (p1 <= k1)
            {
                T2[i] = T[p1]; p1++; i++;
            }
            while (p2 <= k2)
            {
                T2[i] = T[p2]; p2++; i++;
            }
            for (i = p; i <= k; i++) T[i] = T2[i];
        }
        static void MergeSort(int[] T, int p, int k)
        {
            if (p < k)
            {
                int mid = (p + k) / 2;
                MergeSort(T, p, mid);
                MergeSort(T, mid + 1, k);
                Scalaj(T, p, mid, k);
            }
        }
QuickSort
	static int Podzial(int[] T, int l, int p)
        {
            int i, j, klucz, tmp, index;
            index = p;
            klucz = T[index];
            i = l;
            for (j = l; j < p; j++)
            {
                if (T[j] <= klucz)
                { tmp= T[i];
                  T[i] = T[j];
                  T[j] = tmp;
                  i++;
                }
            }
            tmp = T[i];
            T[i] = T[p];
            T[p] = tmp;
            return i;
        }
        static void QuickSort(int[] T, int l, int p)
        {
            if (l >= p)
            {
                return;
            }
            int i = Podzial(T, l, p);
            QuickSort(T, l, i - 1);
            QuickSort(T, i + 1, p);
        }
zad2c/
	static int Przedzial(int[] tab, int x)
        {
            if (x>tab[0])
            {
                return tab.Length;
            }
            for (int i = 0; i < tab.Length; i++)
            {
                if (x>=tab[i])
                {
                    return tab[i];
                }
            }
            return x;
            //złożoność liniowa = n

        }
zad3c/
	static void Wyswietl(int[] a)
        {
            for (int i = 0; i < a.Length; i++)
            {
                Console.Write(a[i] + ", ");
            }
            Console.WriteLine();
        }
        static void Wstawianie(int[] tab)
        {
            for (int i = 0; i < tab.Length; i++)
            {
                int k = tab[i];
                int j = i;
                while (j > 0 && tab[j - 1] > k)
                {
                    tab[j] = tab[j - 1];
                    j--;
                }
                tab[j] = k;
            }
        }
zad4/
	static void Przedzial2(int[] A, int x)
        {
            int[] w = new int[2];
            if (A[0] >= x)
            {
                Console.WriteLine("A[0]>=" + x);
            }
            else if (A[A.Length - 1] < x)
            {
                Console.WriteLine("A[n]<" + x);
            }
            else
            {
                int i = 0;
                int j = A.Length - 1;
                while (i < j)
                {
                    int k = (i + j) / 2;
                    if (x > A[k])
                    {
                        i = k + 1;
                    }
                    else
                    {
                        j = k;
                    }
                }
                Console.WriteLine("(" + A[j - 1] + "," + A[j] + ">");
            }
            Console.WriteLine();
        }
zad5c/
	static int Siatka(int[,] p, int[,] d, int[,] s, int y, int x,int[,] kroki)
        {
            int[,] wynik = new int[y + 1, x + 1];
            wynik[0, 0] = 0;

            for (int i = 1; i < y+1; i++)
            {
                wynik[i, 0] = wynik[i-1,0]+d[i-1,0];
            }
            for (int i = 1; i < x+1; i++)
            {
                wynik[0, i] = wynik[0,i-1]+p[0,i-1];
            }
            for (int i = 1; i < y+1; i++)
            {
                for (int j = 1; j < x+1; j++)
                {
                    if ((wynik[i - 1, j] + d[i - 1, j] > wynik[i, j - 1] + p[i, j - 1]) && p[i, j - 1] != -1)
                    {
                        if (wynik[i, j - 1] + p[i, j - 1] > wynik[i - 1, j - 1] + s[i - 1, j - 1])
                        {
                            wynik[i, j] = wynik[i - 1, j - 1] + s[i - 1, j - 1];
                            kroki[i, j] = 3;
                        }
                        else
                        {
                            wynik[i, j] = wynik[i, j - 1] + p[i, j - 1];
                            kroki[i, j] = 2;
                        }
                    }
                    else
                    {
                        if (wynik[i - 1, j] + d[i - 1, j] > wynik[i - 1, j - 1] + s[i - 1, j - 1])
                        {
                            wynik[i, j] = wynik[i - 1, j - 1] + s[i - 1, j - 1];
                            kroki[i, j] = 3;
                        }
                        else
                        {
                            wynik[i, j] = wynik[i - 1, j] + d[i - 1, j];
                            kroki[i, j] = 1;
                        }
                    }
                }
            }
            return wynik[y, x];
        }
        static void Ścieżka(int[,] kroki, int m, int n)
        {
            Stack<string> ścieżka = new Stack<string>();
            int i = n;
            int j = m;
            while (kroki[i, j] > 0)
            {
                if (kroki[i, j] == 1)
                {
                    ścieżka.Push("down");
                    i--;
                }
                else if (kroki[i, j] == 2)
                {
                    ścieżka.Push("right");
                    j--;
                }
                else
                {
                    ścieżka.Push("skos");
                    i--;
                    j--;
                }
                ;
            }
            while (ścieżka.Count > 0)
            {
                Console.WriteLine(ścieżka.Pop()); //Pop usuwa ze stosu
            }
        }

        static void Main(string[] args)
        {
            int n = 3;
            int m = 4;
            int[,] kroki = new int[n + 1, m + 1];
            int[,] d =
            {
                {1,2,3,5,0 },
                {1,1,0,9,3 },
                {2,2,0,1,1 }
            };
            int[,] p =
            {
                {3,2,0,1 },
                {-1,-1,-1,-1 },
                {-1,-1,-1,-1 },
                {2,1,0,4 }
            };
            int[,] s =
            {
                {5,2,1,0 },
                {2,2,2,1 },
                {0,1,2,3 }
            };
            Console.WriteLine(Siatka(p, d, s, n, m,kroki));
            Ścieżka(kroki, m, n);
            Console.ReadKey();
        }
zad5/
	static int[,] Torba2(int[] tab, int k)
        {
            int[,] w = new int[tab.Length+1,k+1];
            for (int i = 0; i <= tab.Length; i++)
            {
                w[i, 0] = 0;
            }
            for (int i = 0; i <= k; i++)
            {
                w[0, i] = 0;
            }

            for (int i = 1; i <= tab.Length; i++)
            {
                for (int j = 1; j <= k; j++)
                {
                    int m = Math.Max(w[i - 1, j], w[i, j - 1]);
                    if (j >= tab[i - 1])
                    {
                        m = Math.Max(m, w[i - 1, j - tab[i - 1]] + tab[i - 1]);
                    }
                    w[i, j] = m;
                }
            }
            return w;
        }
        static void Wyswietl(int[,] a, int[] b)
        {
            for (int i = 0; i < a.GetLength(0); i++)
            {
                for (int j = 0; j < a.GetLength(1); j++)
                {
                    Console.Write(a[i,j] + ", ");
                }
                Console.WriteLine();
            }
            Console.WriteLine();
            Console.WriteLine("Max = " + a[a.GetLength(0)-1,a.GetLength(1)-1]);
            Console.WriteLine();
            for (int i = 1; i <= b.Length; i++)
            {
                if (a[i,a.GetLength(1)-1]!=a[i-1, a.GetLength(1)-1])
                {
                    Console.Write(b[i-1]+", ");
                }
            }
        }
zad2a
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        static int Podzial(string[] T, int l, int p)
        {
            int i, j, klucz, index;
            string tmp;
            index = p;
            klucz = T[index].Length;
            i = l;
            for (j = l; j < p; j++)
            {
                if (T[j].Length <= klucz)
                {
                    tmp = T[i];
                    T[i] = T[j];
                    T[j] = tmp;
                    i++;
                }
            }
            tmp = T[i];
            T[i] = T[p];
            T[p] = tmp;
            return i;
        }
        static void QuickSort(string[] T, int l, int p)
        {
            if (l >= p)
            {
                return;
            }
            int i = Podzial(T, l, p);
            QuickSort(T, l, i - 1);
            QuickSort(T, i + 1, p);
        }
        static void Main(string[] args)
        {
            string[] a = { "aa", "aaa", "aaaaaa", "a" };
            QuickSort(a, 0, 3);
            for (int i = 0; i < a.Length; i++)
            {
                Console.Write(a[i]+", " );
            }
            Console.WriteLine();
            Console.ReadKey();
        }
    }
}

zad2c
	static public void merge(string[] arr, int p, int q, int r)
        {
            int i, j, k;
            int n1 = q - p + 1;
            int n2 = r - q;
            string[] L = new String[n1];
            string[] R = new String[n2];
            for (i = 0; i < n1; i++)
            {
                L[i] = arr[p + i];
            }
            for (j = 0; j < n2; j++)
            {
                R[j] = arr[q + 1 + j];
            }
            i = 0;
            j = 0;
            k = p;
            while (i < n1 && j < n2)
            {
                if (L[i].Length <= R[j].Length)
                {
                    arr[k] = L[i];
                    i++;
                }
                else
                {
                    arr[k] = R[j];
                    j++;
                }
                k++;
            }
            while (i < n1)
            {
                arr[k] = L[i];
                i++;
                k++;
            }
            while (j < n2)
            {
                arr[k] = R[j];
                j++;
                k++;
            }
        }
        static public void mergeSort(string[] arr, int p, int r)
        {
            if (p < r)
            {
                int q = (p + r) / 2;
                mergeSort(arr, p, q);
                mergeSort(arr, q + 1, r);
                merge(arr, p, q, r);
            }
        }
        static void Main(string[] args)
        {
            string[] arr = { "a","ala","kokokosdasderfni","Alicja","kot","dupa"};
            int n = 6, i;
            Console.WriteLine("Merge Sort");
            Console.Write("Initial array is: ");
            for (i = 0; i < n; i++)
            {
                Console.Write(arr[i] + " ");
            }
            mergeSort(arr, 0, n - 1);
            Console.Write("\nSorted Array is: ");
            for (i = 0; i < n; i++)
            {
                Console.Write(arr[i] + " ");
            }

            Console.ReadKey();
        }
zad3c
	using System;
	using System.Collections.Generic;
	using System.Linq;
	using System.Text;
	using System.Threading.Tasks;

	namespace zad3
	{
  	class Program
    	{
       		static void Main( string[] args )
        	{
            	char[] alfabet = { 'A', 'F', 'B', 'C', 'F', 'B', 'C' };

            	AlfabetSort( alfabet );

            	foreach( char a in alfabet )
                	Console.Write( a );

            	Console.ReadKey();
        }

        static void AlfabetSort( char[] tab )
        {
            int[] wystapienia = new int[ 6 ];   // Ilość Wystąpień znaków A, B, C, D, E F
            char[] w = new char[ tab.Length ];

            foreach( char a in tab )
                wystapienia[ a - 'A' ]++;

            for( int i = 1; i < wystapienia.Length; i++ )
                wystapienia[ i ] += wystapienia[ i - 1 ];

            for( int i = tab.Length-1; i >= 0 ; i-- )
            {
                int p = wystapienia[ tab[ i ] - 'A' ];
                w[ p - 1 ] = tab[ i ];
                wystapienia[ tab[ i ] - 'A' ]--;
            }

            Array.Copy( w, tab, tab.Length );
        }
    }
}