c# terelik

1 zadacha


/Write a program that allocates array of 20 integers and initializes each element by its index multiplied by 5. Print the obtained array on the console.

        int[] myArr = new int[20];

        for (int i = 0; i < myArr.Length; i++)
        {
            myArr[i] = i * 5;
        }

        for (int i = 0; i < myArr.Length; i++)
        {
            Console.WriteLine(myArr[i]);
        }
    }
}

//ОПИСАНИЕ: Инициализираме масив от 20 елемента. С for цикъл обхождаме елементите му всеки един от които го умножаваме по 5.
//След това с втория for цикъл принтираме резултата на конзолата.


Problem 2. Compare arrays///////////////////////////////////////////////////////////////////////////////////
 //Write a program that reads two arrays from the console and compares them element by element

        Console.WriteLine("Pleas enter the lenght of the FIRST Array:");
        int f = int.Parse(Console.ReadLine());
        int[] firstArr = new int[f];

        Console.WriteLine("Pleas enter the lenght of the SECOND Array:");
        int s = int.Parse(Console.ReadLine());
        int[] secondArr = new int[s];

        if (firstArr.Length != secondArr.Length)
        {
            Console.WriteLine("Error! The FIRST Array lenght and the SECOND Array lenght are not equal. Please try again and enter EQUAL array lenghts");
        }

        for (int i = 0; i <= firstArr.Length - 1; i++)
        {
            Console.WriteLine("Please enter the {0} number of FIRST array", i);
            firstArr[i] = int.Parse(Console.ReadLine());
        }

        for (int i = 0; i <= secondArr.Length - 1; i++)
        {
            Console.WriteLine("Please enter the {0} number of SECOND array", i);
            secondArr[i] = int.Parse(Console.ReadLine());
        }

        bool areEqual = true;
        for (int i = 0; i < secondArr.Length; i++)
        {
            if (firstArr[i] != secondArr[i])
            {
                areEqual = false;
                break;
            }
        }

        Console.WriteLine("The two arrays are equal: {0}", areEqual);
    }
}

//ОБЯСНЕНИЕ: Първото нещо, което правим е да инициализираме самия размер на двата масива.
//Макар и незадължително по условие, с помоща на if условието проверяваме дали броя на елементите в двата масива са равни.
//Това може и да не го правим, ако просто накараме потребителя веднъж да въведе число за размера на масивите (веднъж като го въведе ще го ползваме същата променлива при инициализацията и на втория масив).
//След това с помощта на for цикли въвеждаме самите стойности из одтелните позиции на двата масива.
//Преминаваме към същинската част на задачата - сравняване на самите отделни стойности в масива една по една. Използваме булева променлива, в която изначално казваме че елементите в двата масива са равни, до доказване на противното.
//С помощта на for цикъл започваме да сравняваме отделните елементи на масивите един по един.
//В случай че два елемента от една и съща позиция в масивите се случи да не са равни се изпълнява if условието, променливата, която съзадохе по-горе вече става false и се прехвърляме към break оператъра, тъй като при това положение няма смисъл да продължаваме да сравняваме останалите елементи из масивите.
//Отпечатваме резолтата на конзолата.




Problem 3. Compare char arrays ////////////////////////////////////////////////////////////////////////////


//Write a program that reads two arrays from the console and compares them element by element

            Console.WriteLine("Pleas enter the lenght of the FIRST Array:");
            int f = int.Parse(Console.ReadLine());
            int[] firstArr = new int[f];

            Console.WriteLine("Pleas enter the lenght of the SECOND Array:");
            int s = int.Parse(Console.ReadLine());
            int[] secondArr = new int[s];

            if (firstArr.Length != secondArr.Length)
            {
                Console.WriteLine("Error! The FIRST Array lenght and the SECOND Array lenght are not equal. Please try again and enter EQUAL array lenghts");
            }

            for (int i = 0; i <= firstArr.Length - 1; i++)
            {
                Console.WriteLine("Please enter the {0} number of FIRST array", i);
                firstArr[i] = char.Parse(Console.ReadLine());
            }

            for (int i = 0; i <= secondArr.Length - 1; i++)
            {
                Console.WriteLine("Please enter the {0} number of SECOND array", i);
                secondArr[i] = char.Parse(Console.ReadLine());
            }

            bool areEqual = true;
            for (int i = 0; i < secondArr.Length; i++)
            {
                if (firstArr[i] != secondArr[i])
                {
                    areEqual = false;
                    break;
                }
            }

            Console.WriteLine("The two arrays are equal: {0}", areEqual);

// sushtoto kato  to 2 zadacha samo che smenqme s charove  firstArr[i] = char.Parse(Console.ReadLine());
//ОБЯСНЕНИЕ: решението е почти същото като на задача 2 от Масиви.
//Разликата е че зададох char-овете предварително в самия код, защото не се сетих как може да се направи, така че потребителя сам самичък да си ги въведене...



Problem 4. Maximal sequence/////////////////////////////////////////////////////////////////
//Write a program that finds the maximal sequence of equal elements in an array.

            Console.Write("Enter the length of the array: ");
            int length = int.Parse(Console.ReadLine());
            int[] arr = new int[length];

            Console.WriteLine("Enter {0} elements: ", length);
            for (int index = 0; index < length; index++)
            {
                arr[index] = int.Parse(Console.ReadLine());
            }

            int counter = 0;
            int longestSequence = 0;
            int value = 0;
            for (int index = 0; index < length - 1; index++)
            {
                if (arr[index] == arr[index + 1])
                {
                    counter++;
                    if (longestSequence < counter)
                    {
                        longestSequence = counter;
                        for (int i = 0; i < longestSequence; i++)
                        {
                            value = + arr[index];

                            Console.Write("{0},", value.ToString().Trim());
                        }

                    }
                }
                else
                {
                    counter = 0;
                }
            }

//ОБЯСНЕНИЕ: Заделяме масив и го инициализираме. Създаваме три нови променливи: counter, longestSequence и value.
//В първата ще записваме текущото проверявано повторение от числа, във втората ще записваме най-гоямото повтореине от числа и в последната (value) ще запишем елемента, който съзава най-дългата поредица.
//С for цикъла сравняваме числата позиция по позиция. Ако намерим две еднакви се изпълнява if условието, в което са събрани трите променливи.
//Накрая яко longestSequence е различно от 0 т.е. ако сме открили някаква повтаряща се поредица, изписваме колко е голяма тя на конзолата.




Problem 5. Maximal increasing sequence/////////////////////////////////////////////////////

  //Write a program that finds the maximal increasing sequence in an array.

            Console.Write("Enter the length of the array: ");
            int length = int.Parse(Console.ReadLine());
            int[] array = new int[length];

            Console.WriteLine("Enter {0} elements: ", length);
            for (int index = 0; index < length; index++)
            {
                array[index] = int.Parse(Console.ReadLine());
            }

            int maxSequence = 0;
            int sequence = 1;
            string sequenceNumbers = "";
            string maxSequenceNumbers = "";
            for (int i = 0; i < array.Length - 1; i++)
            {

                if (array[i + 1] - array[i] == 1)
                {
                    sequence++;
                    sequenceNumbers += array[i] + " ";
                }
                else
                {
                    if (maxSequence < sequence)
                    {
                        maxSequence = sequence;
                        sequenceNumbers += array[i] + " ";
                        maxSequenceNumbers = sequenceNumbers;
                    }
                    sequence = 1;
                    sequenceNumbers = "";
                }
            }

            if (maxSequence < sequence)
            {
                sequenceNumbers += array[array.Length - 1];
                maxSequenceNumbers = sequenceNumbers;
            }

            Console.WriteLine("The maximal increasing sequence in an array is: ");
            Console.WriteLine(maxSequenceNumbers);



//ОБЯСНЕНИЕ: Създаваме си масив от някакви числа, които въвеждаме ръчно от конзолата. Създаваме си първоначално 4 променливи.
//В maxSequence ще отброяваме броя на нарастващите последователности, ако може така да се каже. Примерно ако имаме поредица от числата 1,2,5,1 в тази променлива ще се запише 3.
//В sequence променливата ще записваме броя на моментните повторения, които цикълът е открил.
//В sequenceNumbers ще се записват самите числа, които в момента цикъла проверява.
//В maxSequenceNumbers ще се съдържа максималната, най-голямата последователност от нанрастващи числа, която е открита до момента.
//Пускаме един нормален for цикъл, с който да срявняваме числата в поредицата, като в зависимост от това дали числото е по-малко или по-голямо от следващото сравнявано в редицата се изпълнява едно от if условията.
//Когато програмата премине през скобите със самите if условия, "зачистваме"  sequence и sequenceNumbers променливите, съответно с числото 1 и "". След което останалато е лесно - програмата се връща отново горе във for цикъла,
//минава и сравнява останалите числа по редицата и накрая прогрмата принтира резултата


Problem 6. Maximal K sum //////////////////////////////////////////////////////////


//Write a program that reads two integer numbers N and K and an array of N elements from the console. Find in the array those K elements that have maximal sum.


        Console.Write("Enter N: ");
        int n = int.Parse(Console.ReadLine());
        int[] myArray = new int[n];
        for (int i = 0; i < n; i++)
        {
            Console.Write("Enter array element {0}: ", i);
            myArray[i] = int.Parse(Console.ReadLine());
        }

        Console.Write("Enter K: ");
        int k = int.Parse(Console.ReadLine());

        string bestSeq = "";
        int sum = 0;
        int bestSum = int.MinValue;
        int arrayLen = myArray.Length;
        for (int i = 0; i < arrayLen; i++)
        {
            string currentSeq = "";

            if (i + k > arrayLen)
            {
                break;
            }

            for (int j = i; j < i + k; j++)
            {
                sum = sum + myArray[j];
                currentSeq = currentSeq + ' ' + myArray[j];
            }

            if (sum > bestSum)
            {
                bestSeq = currentSeq;
                bestSum = sum;
            }
            sum = 0;
        }
        Console.WriteLine(bestSeq);
        Console.WriteLine(bestSum);

    }
}

//ОБЯСНЕНИЕ: Решението е подобно като на задача 5. Особеното е че с if условие се прави проверка i + k > arrayLen, дали случайно не сме излезнали от рамките на масива.
//След това за всяка "заградена" съвкупност от i+k индекси до края на масива правим сравнеиня на самите суми и намираме, коя е най-голямата.


7 e mn lesna ////


Problem 8. Maximal sum  /////////////////////////////////////////////////////////////


 //Write a program that finds the sequence of maximal sum in given array. Can you do it with only one loop (with single scan through the elements of the array)?
            //Example: {2, 3, -6, -1, 2, -1, 6, 4, -8, 8}  ->  {2, -1, 6, 4}


            int[] array = { 2, 3, -6, -1, 2, -1, 6, 4, -8, 8 };

            int currentSum = array[0];
            int startIndex = 0;
            int endIndex = 0;
            int tempStartIndex = 0;
            int maxSum = array[0];

            for (int i = 1; i < array.Length; i++)
            {
                if (currentSum < 0)
                {
                    currentSum = array[i];
                    tempStartIndex = i;
                }
                else
                {
                    currentSum += array[i];
                }
                if (currentSum > maxSum)
                {
                    maxSum = currentSum;

                    startIndex = tempStartIndex;
                    endIndex = i;
                }
            }

            Console.WriteLine("The best sum is: {0} ", maxSum);

            Console.WriteLine("The best sequence is:");

            for (int i = startIndex; i <= endIndex; i++)
            {
                Console.WriteLine(array[i]);
            }


*
ОБЯСНЕНИЕ: За решението на тази задача трябва да се използва алгоритъма на Кадан - http://en.wikipedia.org/wiki/Kadane%27s_algorithm
Инициализираме си масив. Създаваме си 5-те основни променливи, които ще използваме в алгоритъма на Кадан. След това принтираме резултата на конзолата.
*/


Problem 9. Frequent number /////////////////////////////////////////////

//Write a program that finds the most frequent number in an array

            Console.Write("Enter length of the array: ");
            int length = int.Parse(Console.ReadLine());

            int[] array1 = new int[length];
            for (int i = 0; i < length; i++)
            {
                Console.Write("Element[{0}]=", i);
                array1[i] = int.Parse(Console.ReadLine());
            }

            for (int i = 0; i < array1.Length - 1; i++)
            {
                for (int j = i + 1; j < array1.Length; j++)
                {
                    if (array1[i] >= array1[j])
                    {
                        int a = array1[i];
                        array1[i] = array1[j];
                        array1[j] = a;
                    }
                }
            }
            int counter = 0;
            int bigCounter = 0;
            int whatNum = 0;
            for (int i = 0; i < array1.Length - 1; i++)
            {
                if (array1[i] == array1[i + 1])
                {
                    counter++;
                    if (bigCounter <= counter)
                    {
                        bigCounter = counter;
                        whatNum = array1[i];
                    }
                }
                else
                {
                    counter = 0;
                }
            }
            Console.WriteLine("We have {0} members of the number \"{1}\" in the array", bigCounter + 1, whatNum);
        }
    }
}

    //ОБЯСНЕНИЕ: С първите два for цикъла първо подреждаме самия масив от числа във възходящ ред. Стандартен алгоритъм за сортиране си е това, нищо сложно.
    //След което правим класическите три променливи, в които да отброяваме: броя на повторенията към момента, най-голямото повтериение и самото число, което е с най-голямото повторение.
    //Пускаме трети for цикъл, с който започваме да с сравняваме един по един елементите по елементите из масива и съответно ако има еднакви числа в поредица едно до друго if и else конструкцията в кода се грижат за това накрая конзолата да ни ги изпечата правилното решение на задачата.


Problem 10. Find sum in array //////////////////////////////////////////////////////////////////////////////


//Write a program that finds in given array of integers a sequence of given sum S (if present).
            //Example:   {4, 3, 1, 4, 2, 5, 8}, S=11  {4, 2, 5}

            int[] array = { 4, 3, 1, 4, 2, 5, 8 };

            Console.WriteLine("Enter sumS:");
            int sumS = int.Parse(Console.ReadLine());
            int currentSum = array[0];

            int startIndex = 0;
            int endIndex = 0;
            int CurrSum = 0;
            for (int i = 0; i < array.Length - 1; i++)
            {
                CurrSum += array[i];
                startIndex = i;
                for (int p = i + 1; p < array.Length; p++)
                {
                    CurrSum += array[p];
                    endIndex = p;
                    if (CurrSum == sumS)
                    {
                        for (int k = startIndex; k <= endIndex; k++)
                        {
                            Console.Write("{0}",array[k]);
                        }
                        return;
                    }
                }
                CurrSum = 0;
            }
            Console.WriteLine("The sumS is not present in the array.");



/*
ОБЯСНЕНИЕ: Тук търсим в масив последователна поредица от числа, чиято сума да е равна на числото S. Правим си три променливи по подобие на 8-ма задача: startIndex, endIndex, CurrSum.
С два for цикъла обхождаме масива събирайки отляво-надясно елементите му. В момента, в който открием елементи, чиято сума да удовлетворява if условието (а именно - временната CurrSum да бъде равна на sumS)
влизаме в третия for цикъл, който ни отпечатва индексите (startIndex e нейното начало, а endIndex нейния край) на търсената поредица от числа. Ако не намерим такава поредица от елементи - изписваме, че в масива няма такава поредица.
*/

Problem 11. Binary search/////////////////////////////////////////////////////////////


static int BinSearch(int[] array, int key)
    {
        Array.Sort(array);
        int iMax = array.Length - 1;
        int iMin = 0;
        while (iMax >= iMin)
        {
            int iMidpoint = (iMin + iMax) / 2;
            if (array[iMidpoint] < key)
            {
                iMin = iMidpoint + 1;
            }
            else if (array[iMidpoint] > key)
            {
                iMax = iMidpoint - 1;
            }
            else
            {
                return iMidpoint;
            }
        }
        return -1;
    }

    static void Main()
    {
        int[] myArray = { 4, 7, 4, 6, 2, 7, 5, 12, 22, 13, };
        int key = 7;
        Console.WriteLine(BinSearch(myArray, key));
    }
}

//ОПИСАНИЕ: Задача имаща за цел да ни запознае с един от основните алгоритми в програмирането - Binary Search. Повече инфо за него тук - http://en.wikibooks.org/wiki/Algorithm_Implementation/Search/Binary_search


Problem 12. Index of letters /////////////////////////////////////////////////////////////

 //initialize alphabet array
        char[] alphabet = new char[26];
        int first = (int)'A';
        for (int i = 0; i < 26; i++)
        {
            alphabet[i] = (char)(first + i);
        }

        Console.Write("Enter word (A-Z): ");
        string word = Console.ReadLine();
        int ih = 91;
        foreach (char item in word)
        {
            int ssh = item - '@';
            Console.WriteLine(ssh);
        }



Problem 15. Prime numbers /////////////////////////////////////////////////

class PrintNumberUsingSieveOfEratosthenes
{
    static List<int> SieveLINQ(int upTo)
    {
        int index = 1;
        List<int> result = Enumerable.Range(2, upTo - 2).ToList();

        while (index <= Math.Sqrt(upTo))
        {
            index = result.First(i => i > index);
            result.RemoveAll(i => i != index && i % index == 0);
        }
        return result;
    }
    static void Sieve(int upTo)
    {
        bool[] notPrime = new bool[upTo];
        notPrime[0] = notPrime[1] = true;
        for (int i = 2; i < Math.Sqrt(notPrime.Length); i++)
        {
            if (!notPrime[i])
            {
                for (int j = i * 2; j < notPrime.Length; j += i)
                {
                    notPrime[j] = true;
                }
            }
        }
        //Print(notPrime);
    }
    static void Print(bool[] arr)
    {
        for (int i = 0; i < arr.Length; i++)
        {
            if (arr[i] == false)
            {
                Console.Write(i + " ");
            }
        }
    }
    static void Main()
    {
        DateTime first = DateTime.Now;
        Sieve(10000000);
        TimeSpan normalSieveTime = DateTime.Now - first;
        DateTime second = DateTime.Now;
        List<int> linqResult = SieveLINQ(10000000);
        TimeSpan linqSieveTime = DateTime.Now - second;

        Console.WriteLine("Sieve with LINQ: {0}", linqSieveTime);
        Console.WriteLine("Sieve with bool: {0}", normalSieveTime);
    }
}