Menu

 

Thoughts on Software Engineering

195 души продължават да учат безплатно програмиране и C# в Софтуерната академия на Телерик след първия C# изпит

На 6-7 декември 2011 г. се проведе първият междинен изпит по програмиране на C# за учащите в софтуерната академия на Телерик – програма за безплатно обучение на софтуерни инженери и работа в Телерик.

Академия на Телерик - C# изпит - 7 декември 2011

В програмата кандидатстваха около 450 души, от които за обучение в началото на ноември 2011 г. бяха приети 306 участници. Предстои те да бъдат обучавани между 5 и 10 месеца (според специалността) и най-сериозните и най-старателните 60 от тях да започнат работа като софтуерни инженери в софтуерната корпорация Телерик – работодател #1 на България и световен лидер в разработката на софтуерни продукти, технологии и инструменти в помощ на разработчиците на софтуер.

За програмата “софтуерна академия” – безплатно обучение и работа в Телерик

Програмата за безплатно обучение и работа следва следната схема: C# обучение по основи на програмирането, част I (306 души) –> изпит –> продължават най-добрите –> C# програмиране, част II (195 души) –> изпит –> продължават най-добрите –> C# програмиране, част III (120 души) –> изпит –> най-добрите 60 продължават в 3 специалности –> .NET developer (учат още 5 месеца целодневно); QA инженер (учат още 4 месеца вечерно); developer support инженер (учат още 3 месеца вечерно). Достигналите последната фаза на обученията овладяват безплатно професията “софтуерен инженер” и 60 от тях започват работа в една от най-добрите софтуерни компании в света.

Първият изпит по C# програмиране в софтуерната академия на Телерик

След първия месец на безплатни уроци по основи на програмирането, решаване на задачи, упражнения и тренировки, участниците в курса трябваше да се явят на първия си изпит, след който в програмата трябва да продължат 180-200 души. На изпита се явиха около 270 души, които се състезаваха върху 5 практически задачи по програмиране за 6 часа.

Академия на Телерик - C# изпит - 6 декември 2011

Шампионите от първия C# изпит

Най-добре представилите се участници в курса решиха самостоятелно всичките 5 задачи в рамките на определеното им време. Някои бяха по-бързи и предадоха верни решения само за 2 часа, докато други успяха едва в края на позволеното им време от 6 часа. Следва списък от най-добре представилите се на изпита курсисти (до момента, по азбучен ред). Това не са всички класирани за следващия етап от обученията, а хората с резултат близък до максималния (5 решени задачи):

  • А. Ж. Колев
  • А. Г. Петров
  • А. П. Петков
  • А. Р. Венчев
  • А. К. Сотиров
  • А. Ст. Богданов
  • Б. С. Статев
  • Б. Ан. Желязков
  • В. Вл. Букуров
  • В. Ст. Стайков
  • Вл. Хр. Ценев
  • В. Г. Вълков
  • Г. Б. Синеклиев
  • Г. В. Стоянов
  • Г. И. Петров
  • Г. М. Матеев
  • Г. П. Ваклинов
  • Гр. В. Генев
  • Д. И. Тачев
  • Д. К. Маджаров
  • Д. В. Агайна
  • Е. П. Генчева
  • И. Б. Бабалев
  • И. Б. Тончев
  • И. Д. Ненчовски
  • И. Ст. Стоянов
  • И. Цв. Колчагов
  • К. Ст. Попов
  • Кр. Д. Ташков
  • Кр. Н. Николов
  • Л. Л. Цонов
  • М. М. Маринов
  • М. Б. Пенков
  • М. И. Янков
  • М. Л. Нинов
  • М. К. Господинов
  • М. Вл. Рогелов
  • М. И. Стефанов
  • Н. А. Банкин
  • Н. И. Вълчев
  • П. Д. Колев
  • П. В. Вълчев
  • П. Т. Сотирова
  • С. Д. Георгиева-Христова
  • С. Н. Димитров
  • С. В. Радков
  • С. Д. Стоянов
  • С. А. Стоянов
  • С. В. Василев
  • Т. И. Илиев
  • Хр. Ж. Маринов

Класирането в софтуерната академия

Класирането за продължаването в следващия етап от обученията в софтуерната академия на Телерик е базирано не само на изпита по практическо програмиране на C#, но и на няколко други критерия, които бяха обявени в началото и бяха взети в предвид:

  • Прилежно предадени домашни за всяка от изучаваните теми
  • Есе за професията на софтуерния инженер
  • Всекидневен отчет за свършеното по обученията в курса (C# игра)
  • Докладвани грешки и проблеми в учебника по C# програмиране
  • Активно участие в онлайн дискусиите във форума на курса
  • Указана помощ в обучението на колеги от курса

По всички тези критерии в челото на генералното класиране са следните участници в курса (списъкът не е пълен):

  • Л. Л. Цонов – 108.00 т.
  • М. И. Стефанов – 107.50 т.
  • Т. И. Илиев – 104.00 т.
  • Д. К. Маджаров – 104.00 т.
  • Ст. Вл. Радков – 103.00 т.
  • Д. И. Тачев – 102.00 т.
  • А. Ст. Богданов – 100.00 т.
  • Д. В. Агайна – 100.00 т.
  • П. Д. Колев – 99.50 т.
  • Кр. Н. Николов – 99.00 т.
  • П. В. Вълчев – 99.00 т.
  • М. Л. Нинов – 99.00 т.
  • Б. А. Желязков – 99.00 т.
  • И. Б. Бабалев – 98.00 т.
  • М. Вл. Рогелов – 98.00 т.
  • Н. И. Вълчев – 98.00 т.
  • В. Вл. Букуров – 98.00 т.
  • Е. П. Генчева – 98.00 т.
  • Г. П. Ваклинов – 97.00 т.
  • Ст. А. Стоянов – 97.00 т.
  • Г. М. Матеев – 97.00 т.
  • П. Т. Сотирова – 96.50 т.
  • М. М. Маринов – 96.00 т.
  • Г. В. Стоянов – 96.00 т.
  • И. Ст. Стоянов – 96.00 т.
  • Ст. Хр. Гочев – 95.00 т.
  • Н. Н. Петрова – 94.50 т.
  • Хр. Ж. Маринов – 94.00 т.
  • К. Й. Вандов – 94.00 т.
  • В. Г. Станкова – 93.50 т.
  • М. К. Господинов – 93.00 т.
  • М. И. Янков – 93.00 т.
  • Ст. Д. Стоянов – 92.50 т.
  • Ст. В. Василев – 92.50 т.
  • С. Н. Димитров – 92.50 т.
  • Г. И. Петров – 92.17 т.
  • И. Д. Ненчовски – 92.00 т.
  • Ат. Г. Цанков – 92.00 т.
  • А. П. Петков – 91.83 т.
  • И. Б. Тончев – 91.50 т.
  • К. Ст. Попов – 91.00 т.
  • В. Ст. Стайков – 91.00 т.
  • А. Р. Венчев – 90.83 т.
  • В. Г. Вълков – 90.50 т.
  • Вл. И. Илиев – 90.50 т.
  • С. Д. Георгиева-Христова – 90.00 т.

Шампиони по отделните критерии

Освен на изпита и в генералното класиране, имаме шампиони, които се отличиха и по другите критерии за оценяване в този първи етап на софтуерната академия. Всички те ще получат награди и продължават в следващия етап от курса.

Най-добро есе за професията “софтуерен инженер”

Най-добро есе за професията на софтуерния инженер и предизвикателствата пред всеки, който се захваща с нея, е написал Стефан Стефанов Байчев.

Най-висока активност във форума на курса

Най-висока активност в дискусионния форум на C# курса e реализирал Стамо Христов Гочев. Той е публикувал общо 161 мнения за периода на първия месец от курса и е бил активен в дискусиите във форума през 23 различни дни.

Най-висока активност в отчета за работа по курса

Най-висока активност в отчета за всекидневната работа по обучението си в курса е постигнала Надежда Николова Петрова. Тя е отчела общо 120 различни действия в т. нар. “C# игра” (решаване на задачи, четене на статии, упражнения и др.) извършени в 50 различни дни.

Най-много докладвани грешки в учебника

Най-много грешки в учебника по основи на програмирането със C# е докладвала Вася Георгиева Станкова – 124.

Най-активно указване на помощ на колеги

Най-активно е помагал на своите колеги от курса по време на учебните занятия, при работа по домашните и по време на подготовката за изпитите по програмиране Николай Евгениев Демирев. Той е помагал на 13 свои колеги.

Задачите от изпита по C# програмиране

Първият изпит по основи на програмирането със C# се проведе в да поредни дни на 6 и 7 декември 2011 г. От общо 306 участника в курса на първия изпит се явиха общо около 270 души, разпределени в 8 групи (2 дни – сутрин и следобед, в двете учебни зали на Телерик, паралелно). От тях ненулеви резултати изкараха 230 участника в курса. Имаше и участници, които за 6 часа не можаха да решат дори частично нито една от задачите.

Задачите бяха лесни за опитен софтуерен инженер (отнемат по 5-10 минути за прочитане на условието, по 10-15 минути за решаване и по 5-10 минути за тестване), но за начинаещи в програмирането се оказаха сериозно предизвикателство. Учащите в курса са учили до момента 6 теми и задачите на изпита бяха съобразени с тези знания и не включваха допълнителен учебен материал:

  • Въведение в програмирането – езика C# и среда за програмиране Visual Studio
  • Примитивни типове данни и променливи – числа, аритметика с цели и дробни числа, символен тип, променливи и данни
  • Оператори, изрази и конструкции – оператори в езика C# (булеви, аритметични, за сравнение, за присвояване), изрази, константи, литерали, прости програмни конструкции
  • Вход и изход от конзолата – четене на входни данни и отпечатване на текст и числа на конзолата
  • Условни конструкции – конструкции за избор и изпълнение на блокове команди според входно булево условие (if, if-else, switch-case)
  • Цикли – изпълняване на блокове команди многократно според различни входни и изходни условия (for-цикли, while-цикли, do-while-цикли, foreach-цикли и т.н.)

Въпреки, че учебният материал е много малък като обем, той дава възможност за доста разнообразни задачи: пресмятане на формули, работа с битове, пресмятания с цикли, отпечатване на различни фигури, измисляне и имплементация на не много сложни алгоритми и други.

Автори на задачите и на авторските решения са Светлин Наков, Николай Костов и Мартин Иванов.

C# изпит по програмиране – 6 декември

Условията на всички задачи в изпитите в академията на Телерик за софтуерни инженери по традиция се дават на английски език.

Задача “Ship Damage” – условие

Inside the sea (a standard Cartesian /rectangular/ coordinate system) we are given a ship S (a rectangle whose sides are parallel to the coordinate axes), a horizontal line H (the horizon) and three catapults, given as coordinates C1, C2 and C3 that will be used to fire the ship. When the attack starts, each catapult shoots a projectile exactly into the positions that are symmetrical to C1, C2 and C3 with respect to the horizon H. When a projectile hits some of the corners of the ship, it causes a damage of 25%, when it hits some of the sides of the ship, the damage caused is 50% and when it hits the internal body of the ship, the damage is 100%. When the projectile does not reach the ship, there is no damage. The total damage is a sum of the separate damages and can exceed 100%.

At the figure below a sea, a ship S, a line H, three points C1, C2 and C3 and their hit positions are shown:

Ship Damage - example

Your task is to write a program that calculates the total damage caused after the attack over the ship.

Задача “Ship Damage” – вход

The input data should be read from the console.

There will be exactly 11 lines holding the integer numbers SX1, SY1, SX2, SY2, H, CX1, CY1, CX2, CY2, CX3, and CY3.

The ship S is given by any two of its opposite corners and is non-empty (has positive width and height).

The line H is given by its vertical offset.

The points C1, C2 and C3 are given as couples of coordinates and cannot overlap each other.

The line and the ship cannot overlap.

The input data will always be valid and in the format described. There is no need to check it explicitly.

Задача “Ship Damage” – изход

The output data should be printed on the console.

The output should consist of a single line holding the total damage given as percentage.

Задача “Ship Damage” – ограничения

The numbers SX1, SY1, SX2, SY2, H, CX1, CY1, CX2, CY2, CX3, and CY3 are all integers between -100 000 and 100 000, inclusive.

Allowed work time for your program: 0.1 seconds.

Allowed memory: 16 MB.

Задача “Ship Damage” – примери

Input Output Input Output
-11
6
-6
3
1
-9
-3
-12
-4
-6
-1 
125%
-6
6
-11
3
1
-9
-4
-11
-1
2
2 
75%

Задача “Ship Damage” – авторско решение

Авторското решение проверява разрушенията за всяко от трите попадения директно. Очертанията на кораба се смятат във формат (minX, minY, maxX, maxY). Няма други особености. Нарочно са използвани само изучавани до момента в C# курса програмни техники и езикови конструкции (не използва масиви, списъци и методи):

using System;

class ShipDamage
{
    static void Main()
    {
        // Read the input
        int sx1 = Int32.Parse(Console.ReadLine());
        int sy1 = Int32.Parse(Console.ReadLine());
        int sx2 = Int32.Parse(Console.ReadLine());
        int sy2 = Int32.Parse(Console.ReadLine());
        int h = Int32.Parse(Console.ReadLine());
        int cx1 = Int32.Parse(Console.ReadLine());
        int cy1 = Int32.Parse(Console.ReadLine());
        int cx2 = Int32.Parse(Console.ReadLine());
        int cy2 = Int32.Parse(Console.ReadLine());
        int cx3 = Int32.Parse(Console.ReadLine());
        int cy3 = Int32.Parse(Console.ReadLine());

        // Find the hit points (apply symmetrics)
        cy1 = 2 * h - cy1;
        cy2 = 2 * h - cy2;
        cy3 = 2 * h - cy3;

        // Find the ship bounds
        int minX = Math.Min(sx1, sx2);
        int maxX = Math.Max(sx1, sx2);
        int minY = Math.Min(sy1, sy2);
        int maxY = Math.Max(sy1, sy2);

        int totalDamage = 0;

        // Check the corners damage
        if ((cx1 == minX || cx1 == maxX) && (cy1 == minY || cy1 == maxY))
        {
            totalDamage += 25; // Hit in the corner
        }
        if ((cx2 == minX || cx2 == maxX) && (cy2 == minY || cy2 == maxY))
        {
            totalDamage += 25; // Hit in the corner
        }
        if ((cx3 == minX || cx3 == maxX) && (cy3 == minY || cy3 == maxY))
        {
            totalDamage += 25; // Hit in the corner
        }

        // Check the borders damage
        if (((cx1 == minX || cx1 == maxX) && (cy1 > minY && cy1 < maxY)) ||
            ((cy1 == minY || cy1 == maxY) && (cx1 > minX && cx1 < maxX)))
        {
            totalDamage += 50; // Hit in the border
        }
        if (((cx2 == minX || cx2 == maxX) && (cy2 > minY && cy2 < maxY)) ||
            ((cy2 == minY || cy2 == maxY) && (cx2 > minX && cx2 < maxX)))
        {
            totalDamage += 50; // Hit in the border
        }
        if (((cx3 == minX || cx3 == maxX) && (cy3 > minY && cy3 < maxY)) ||
            ((cy3 == minY || cy3 == maxY) && (cx3 > minX && cx3 < maxX)))
        {
            totalDamage += 50; // Hit in the border
        }

        // Check the internal body damage
        if ((cx1 > minX) && (cx1 < maxX) && (cy1 > minY) && (cy1 < maxY))
        {
            totalDamage += 100; // Hit in the internal body
        }
        if ((cx2 > minX) && (cx2 < maxX) && (cy2 > minY) && (cy2 < maxY))
        {
            totalDamage += 100; // Hit in the internal body
        }
        if ((cx3 > minX) && (cx3 < maxX) && (cy3 > minY) && (cy3 < maxY))
        {
            totalDamage += 100; // Hit in the internal body
        }

        Console.WriteLine(totalDamage + "%");
    }
}

Задача “Tribonacci” – условие

The Tribonacci sequence is a sequence in which every next element is made by the sum of the previous three elements from the sequence.
Tribunacci - formula

Write a computer program that finds the Nth element of the Tribonacci sequence, if you are given the first three elements of the sequence and the number N. Mathematically said: with given T1, T2 and T3 – you must find Tn.

Задача “Tribonacci” – вход

The input data should be read from the console.

The values of the first three Tribonacci elements will be given on the first three input lines.

The number N will be on the fourth line. This is the number of the consecutive element of the sequence that must be found by your program.

The input data will always be valid and in the format described. There is no need to check it explicitly.

Задача “Tribonacci” – изход

The output data should be printed on the console.

At the only output line you must print the Nth element of the given Tribonacci sequence.

Задача “Tribonacci” – ограничения

The values of the first three elements of the sequence will be integers between -2 000 000 000 and 2 000 000 000.

The number N will be a positive integer between 1 and 15 000, inclusive.

Allowed working time for your program: 0.25 seconds.

Allowed memory: 16 MB.

Задача “Tribonacci” – примери

Input Output Input Output
1
1
1
4
3
2
3
4
10
335

Задача “Tribonacci”– авторско решение

Авторското решение смята числата като директно прилага формулата, но работи с типа BigInteger, защото редицата нараства твърде бързо и би препълнила всички възможни примитивни числови типове в езика C#:

using System;
using System.Numerics;

class Tribonacci
{
    static void Main()
    {
        // Read input
        BigInteger trib1 = new BigInteger(int.Parse(Console.ReadLine()));
        BigInteger trib2 = new BigInteger(int.Parse(Console.ReadLine()));
        BigInteger trib3 = new BigInteger(int.Parse(Console.ReadLine()));
        int n = int.Parse(Console.ReadLine());

        // Calculate the Tribonacci sequence
        if (n == 1)
            Console.WriteLine(trib1);
        else if (n == 2)
            Console.WriteLine(trib2);
        else if (n == 3)
            Console.WriteLine(trib3);
        else
        {
            for (int i = 4; i < = n; i++)
            {
                BigInteger tribNew = trib1 + trib2 + trib3;
                trib1 = trib2;
                trib2 = trib3;
                trib3 = tribNew;
            }
            Console.WriteLine(trib3);
        }
    }
}

Задача “Fir Tree” – условие

Christmas Eve is coming so even programmers have to prepare!

In the spirit of the event your task is to write a program that prints a fir tree to the console.

The format of the tree is shown in the examples bellow.

Задача “Fir Tree”– вход

The input data should be read from the console.

On the only input line you have an integer number N, showing the height of the tree.

The input data will always be valid and in the format described. There is no need to check it explicitly.

Задача “Fir Tree”– изход

The output data should be printed on the console.

You must print the fir tree on the console. Each row contains only characters “.” (point) or “*” (asterisk).

The first row should have exactly one “*” in the middle (that is the top of the tree) and each of the next lines two more.

The last line should have exactly one asterisk in the middle, showing the stem of the tree.

Задача “Fir Tree”– ограничения

The number N is a positive integer between 4 and 100, inclusive.

Allowed working time for your program: 0.25 seconds.

Allowed memory: 16 MB.

Задача “Fir Tree”– примери

Input Output Input Output
5
...*...
..***..
.*****.
*******
...*...
9
.......*.......
......***......
.....*****.....
....*******....
...*********...
..***********..
.*************.
***************
.......*.......

Задача “Fir Tree”– авторско решение

Решението е абсолютно тривиално. Тази задача по трудност е за 3-4 клас. Ако някой не е успял да я реши след един месец усърдно учене, трябва да се замисли дали програмирането наистина е за него. Авторското решение смята за всеки ред броя звездички и броя точки отляво и отдясно и ги печата. Накрая печата стъблото.

using System;

class FirTree
{
    static void Main()
    {
        // Read the input
        int n = int.Parse(Console.ReadLine());

        // Print the tree
        for (int i = 0; i < n - 1; i++)
        {
            string dots = new string('.', (n - i) - 2);
            string stars = new string('*', (i * 2) + 1);
            Console.Write(dots);
            Console.Write(stars);
            Console.Write(dots);
            Console.WriteLine();
        }

        // Print the stem
        string finalDots = new string('.', n - 2);
        Console.Write(finalDots);
        Console.Write("*");
        Console.Write(finalDots);
        Console.WriteLine();
    }
}

Задача “We All Love Bits!” – условие

One of the things the programmers love the most is bitwise operations. The “bitwise guy” is a synonym for a programmer that loves bits more than everything else in programming. Mitko is a “bitwise guy”. He invented a new bitwise algorithm. The algorithm takes one positive integer P, makes magic with it and returns a new positive integer. He also defined a new number P~ which represents the number P in binary numeral system with inverted bits. All zeros in P are ones in P~ and all ones in P are zeros in P~. For example if we have P = 9 (which is 1001in binary numeral system) its inverted number P~ will be equal to 6 (which is 110 in binary numeral system). But that’s not all! He invented another number P`, which represents reversed number P in binary numeral system. For example if we have P = 11 (which is 1011 in binary numeral system) its reversed number P` is equal to 13 (which is 1101 in binary numeral system). Mitko’s magical algorithm takes a number P and transforms it to a new numberPnew using the following bitwise transformation: Pnew = (P ^ P~) & P`.

Your task is to write a program that transforms a sequence of N positive integer numbers using Mitko’s algorithm.

Задача “We All Love Bits!” – вход

The input data should be read from the console.

At the first input line there will be one positive integer – the number N.

At each of the next N lines there will be one positive integer – the consequent number that must be converted using Mitko’s algorithm.

The input data will always be valid and in the format described. There is no need to check it explicitly.

Задача “We All Love Bits!” – изход

The output data should be printed on the console.

The output must consist of N lines, containing the transformed numbers for each number from the input.

Задача “We All Love Bits!” – ограничения

The number N will be positive integer number between 1 and 800, inclusive.

Each of the N numbers will be positive integer numbers between 1 and 2 147 483 647, inclusive.

Allowed working time for your program: 0.20 seconds.

Allowed memory: 16 MB.

Задача “We All Love Bits!” – примери

Input Output Input Output
1
2 
1
2
19
248
25
31

Задача “We All Love Bits!” – авторско решение

Авторското решение на задачата използва факта, че (P ^ P~) е винаги число, състоящо се само от единици във всичките си битове. Следователно Pnew = (P ^ P~) & P` = P`. Така задачата се опростява до обръщане на двоичните цифри на дадено число отзад напред. Решението преминава през двоичните цифри на P отдясно наляво и ги прибавя в десния край на новополученото число Pnew. Имплементацията е доста проста:

using System;

class WeAllLoveBits
{
    static void Main()
    {
        // Read N
        int n = int.Parse(Console.ReadLine());

        // For all N numbers
        for (int i = 1; i < = n; i++)
        {
            // Read P
            int p = int.Parse(Console.ReadLine());

            // calculate pNew
            int pNew = 0;
            while (p > 0)
            {
                pNew < < = 1;
                if ((p & 1) == 1)
                {
                    pNew |= 1;
                }
                p > > = 1;
            }

            // Write pNew
            Console.WriteLine(pNew);
        }
    }
}

Задача “Pillars” – условие

You are given a list of 8 bytes (positive integers in the range [0…255]) n0, n1, …, n7. These numbers represent a square grid consisting of 8 lines and 8 columns. Each cell of the grid could either be empty or full. The first line is represented by the bits of n0, the second – by the bits of n1 and so on, and the last line is represented by the bits of n7. Each bit with value 1 denotes a full cell and each bit with value 0 denotes an empty cell. The lines are numbered from the first (top) to the last (bottom) with the numbers 0, 1, …, 7. The columns are numbered from right to left with the indices 0, 1, …, 7. The figure shows a square grid and its representation by a sequence of 8 numbers n0, n1, …, n7:

Pillars - example

We are allowed to put a vertical pillar over any of the columns in the grid. Pillars split the grid into two sides (left and right) and the column holding the pillar is ignored. Write a program that finds the leftmost column where the pillar can be put so that the full cells on the left side and on the right side are equal number. For example, in the figure if we put the pillar at column 5, it will split the grid into two sides and both sides will have exactly 3 full cells.

Задача “Pillars” – вход

The input data should be read from the console.

There will be exactly 8 lines each holding the integer numbers n0, n1, …, n7.

The input data will always be valid and in the format described. There is no need to check it explicitly.

Задача “Pillars” – изход

The output data should be printed on the console.

If a pillar splitting the grid into two vertical sides each holding the same number of full cells exists, print its column index on the first line and the number of full cells in each of the sides. If multiple pillars can do the job, print only the leftmost. If no such pillar exists, print the string “No” on the console (just one line holding the word “No”).

Задача “Pillars” – ограничения

The numbers n0, n1, …, n7 are positive integers in the range [0…255].

Allowed work time for your program: 0.25 seconds.

Allowed memory: 16 MB.

Задача “Pillars” – примери

Input Output Input Output
0
64
0
8
0
12
224
0 
5
3
3
0
0
0
0
0
0
0
No

Задача “Pillars” – авторско решение

Това е най-сложната задача от първия изпитен ден. Тя изисква работа с битове и двоична бройна система, измисляне на прост алгоритъм въхру матрица с размер 8 на 8 и използване на вложени цикли. За всяка възможна колона (от 0 до 7) се проверява, ако се сложи разделящата стена в нея, колко пълни клетки ще останат вляво и вдясно от нея. Клетките вляво и вдясно се броят чрез проверка на всички колони вляво и вдясно по всичките 8 реда. Ако има няколко решения, най-лявото от тях се запомня по естествен начин, защото се намира най-късно (то има най-голям индекс на колона). Следва имплементацията, която може съществено да се подобри, ако се използват масиви и методи, но тъй като те не са все още изучавани в курса по C# програмиране, тяхната употреба е съзнателно избегната:

using System;

class Pillars
{
    static void Main()
    {
        // Read the input numbers
        int num0 = Int32.Parse(Console.ReadLine());
        int num1 = Int32.Parse(Console.ReadLine());
        int num2 = Int32.Parse(Console.ReadLine());
        int num3 = Int32.Parse(Console.ReadLine());
        int num4 = Int32.Parse(Console.ReadLine());
        int num5 = Int32.Parse(Console.ReadLine());
        int num6 = Int32.Parse(Console.ReadLine());
        int num7 = Int32.Parse(Console.ReadLine());

        // Find the optimal pillars
        int bestCount = Int32.MinValue;
        int bestIndex = Int32.MinValue;
        for (int index = 0; index < = 7; index++)
        {
            // Count the full cells on the left side
            int leftCount = 0;
            for (int leftIndex = index + 1; leftIndex < = 7; leftIndex++)
            {
                leftCount += (num0 >> leftIndex) & 1;
                leftCount += (num1 >> leftIndex) & 1;
                leftCount += (num2 >> leftIndex) & 1;
                leftCount += (num3 >> leftIndex) & 1;
                leftCount += (num4 >> leftIndex) & 1;
                leftCount += (num5 >> leftIndex) & 1;
                leftCount += (num6 >> leftIndex) & 1;
                leftCount += (num7 >> leftIndex) & 1;
            }

            // Count the full cells on the right side
            int rightCount = 0;
            for (int rightIndex = 0; rightIndex < = index - 1; rightIndex++)
            {
                rightCount += (num0 >> rightIndex) & 1;
                rightCount += (num1 >> rightIndex) & 1;
                rightCount += (num2 >> rightIndex) & 1;
                rightCount += (num3 >> rightIndex) & 1;
                rightCount += (num4 >> rightIndex) & 1;
                rightCount += (num5 >> rightIndex) & 1;
                rightCount += (num6 >> rightIndex) & 1;
                rightCount += (num7 >> rightIndex) & 1;
            }

            if (leftCount == rightCount)
            {
                bestCount = leftCount;
                bestIndex = index;
            }
        }

        if (bestCount != Int32.MinValue)
        {
            Console.WriteLine(bestIndex);
            Console.WriteLine(bestCount);
        }
        else
        {
            Console.WriteLine("No");
        }
    }
}

Тестове на журито

Както на всяко състезание по алгоритмично програмиране, и на този изпит проверката на задачите се базира на тестови примери, които покриват по възможно най-пълен начин всички интересни случаи за входните данни. За всяка задача има лесни тестове, по-трудни тестове и екстремални тестове – около границата на входа (най-малки и най-големи числа) и други интересни случаи, които изискват специално внимание при изготвяне на решенията на задачите. Всяка задача се оценява с по 10 теста, всеки от които дава по еднакъв брой точки. В приложения файл са дадени нулевите тестове (от условията на задачите) и десетте изпитни теста, както и съответните им верни изходи.

Изтеглете тестовете на журито от изпита по C# програмиране от 6 декември 2011 г. в софтуерната академия на Телерик: Tests-CSharp-Exam-I-6-December-2011.rar.

C# изпит по програмиране – 7 декември

Във втория изпитен ден задачите бяха аналогични на задачите от първия ден, но се оказаха малко по-сложни и общите резултати бяха по-слаби. Това наложи да скалираме резултатите в края на двата изпитни дни с цел уеднаквяване на средните резултати от двата дни, за да е честен изпитът спрямо всички участници.

Следват условията на задачите, авторските решения и тестовете на журито.

Задача “Fighter Attack” – условие

A rectangular plant P located in east-west direction is under attack by a fighter aircraft flying over it on the west. When the fighter launches a missile we have its coordinates F. It is assumed that the missile’s direction is always straight on the west and the missile always hits the target after a fixed distance D in front of the fighter.

To simplify our model we assume the land is built of square cells of size 1 x 1 located in east-west direction and each cell has integer Cartesian coordinates {x, y}. In this model the plant can be represented by a rectangular area of cell and the missile always hits some of the square cells (inside or outside of the plant).

When the missile hits a certain cell, the damage over it is 100%, on the cells staying on the left and on the right of it the damage is 50% and in front of it the damage is 75%. The total damage is sum of the separate damages and can exceed 100%.

You are given the location of the plant P, the location of the fighter F and the distance D. Write a program that calculates the damage over the plant after the attack. Note that the missile could hits the plant partially of fully or can hit some area outside of the plant and cause no damage.

At the figure below a plant P, a fighter F, a distance D and the missile hit point are shown along with the damage caused over the cells by the hit. Note that some of the damaged cells are outside of the plant and thus the total damage is 225%:

Fighter Attack - example

Your task is to write a program that calculates the total damage caused after the attack over the plant.

Задача “Fighter Attack” – вход

The input data should be read from the console.

There will be exactly 7 lines holding the integer numbers PX1, PY1, PX2, PY2, FX, FY, and D. The plant P is given by the coordinates of any two of its opposite corners and is non-empty (consists of at least one cell). The location of the fighter is given as cell coordinates FX, and FY and the distance D is given as an integer number.

The input data will always be valid and in the format described. There is no need to check it explicitly.

Задача “Fighter Attack” – изход

The output should consist of a single line holding the total damage given as percentage.

Задача “Fighter Attack” – ограничения

The numbers PX1, PY1, PX2, PY2, FX, FY, and D are all integers in the range [-100 000 … 100 000].

Allowed work time for your program: 0.1 seconds.

Allowed memory: 16 MB.

Задача “Fighter Attack” – примери

Input Output Input Output Input Output
2
5
6
3
-6
3
9
225%
2
5
6
3
-6
5
7
75%
6
5
2
3
0
1
-3
0%

Задача “Fighter Attack” – авторско решение

Задачата се решава директно, следвайки условието. Първо се изчисляват границите на завода, който е под атака във формат (minX, maxX, minY, maxY) и координатите на четирите точки на удара. След това се изчисляват попаденията и се изчислява сумарният размер на разрушенията. Ето и сорс кода на авторското решение:

using System;

class FighterAttack
{
    static void Main()
    {
        // Read the input
        int px1 = Int32.Parse(Console.ReadLine());
        int py1 = Int32.Parse(Console.ReadLine());
        int px2 = Int32.Parse(Console.ReadLine());
        int py2 = Int32.Parse(Console.ReadLine());
        int fx = Int32.Parse(Console.ReadLine());
        int fy = Int32.Parse(Console.ReadLine());
        int d = Int32.Parse(Console.ReadLine());

        // Find the plant bounds
        int minX = Math.Min(px1, px2);
        int maxX = Math.Max(px1, px2);
        int minY = Math.Min(py1, py2);
        int maxY = Math.Max(py1, py2);

        // Find the hit points
        int hitX = fx + d;
        int hitY = fy;
        int hitUpX = hitX;
        int hitUpY = hitY - 1;
        int hitDownX = hitX;
        int hitDownY = hitY + 1;
        int hitRightX = hitX + 1;
        int hitRightY = hitY;

        // Calculate the damage over the plant
        int totalDamage = 0;
        if (hitX > = minX && hitX < = maxX && hitY > = minY && hitY < = maxY)
        {
            totalDamage += 100;
        }
        if (hitUpX > = minX && hitUpX < = maxX && hitUpY > = minY && hitUpY < = maxY)
        {
            totalDamage += 50;
        }
        if (hitDownX > = minX && hitDownX < = maxX && hitDownY > = minY && hitDownY < = maxY)
        {
            totalDamage += 50;
        }
        if (hitRightX > = minX && hitRightX < = maxX && hitRightY > = minY && hitRightY < = maxY)
        {
            totalDamage += 75;
        }

        // Print the damage
        Console.WriteLine(totalDamage + "%");
    }
}

Задача “Astrological Digits” – условие

The astrological digit of a given number N is a digit calculated by the number’s digits by a special algorithm. The algorithm performs the following steps:

(1) Sums the digits of the number N and stores the result back in N.

(2) If the obtained result is bigger than 9, step (1) is repeated, otherwise the algorithm finishes.

The last obtained value of N is the result, calculated by the algorithm.

Задача “Astrological Digits” – вход

The input data should be read from the console.

The only line in the input contains a number N, which can be integer or real number (decimal fraction).

The input data will always be valid and in the format described. There is no need to check it explicitly.

Задача “Astrological Digits” – изход

The output data should be printed on the console.

You must print the calculated astrological digit of the number N on the first and only line of the output.

Задача “Astrological Digits” – ограничения

The number N will be in range [-1.7 × 10−308… 1.7 × 10308]

N will have no more than 300 digits before and after the decimal point.

The decimal separator will always be the “.” symbol.

Allowed working time for your program: 0.2 seconds.

Allowed memory: 16 MB.

Задача “Astrological Digits” – примери

Input Output Input Output Input Output
8
8
-1337
5
1234567.8900
9

Задача “Astrological Digits” – авторско решение

Задачата е изключително лесна, но трябва да се съобразят ограниченията на входните данни. Въведеното число може да има доста голям брой цифри преди и след десетичната запетая и следователно не може да бъде събрано в нито един от вградените в C# числови типове. Следователно входът трябва да бъде четен или символ по символ или да бъде прочетен в string и да бъде след това обработен символ по символ. Всички символи от входа, които са цифри се сумират, а останалите се пропускат. След това, ако сумата е повече от 9, отново се сумират цифрите на полученото число (по класическия алгоритъм чрез делене на 10 и сумиране на остатъците) и така докато се достигне сума, по-малка от 9. Ето и сорс кода на авторското решение:

using System;

class AstrologicalDigits
{
    static void Main()
    {
        // Read the number and sum its digits
        ulong sumOfDigits = 0;
        while (true)
        {
            int ch = Console.Read();
            if (ch == (int)'\n' || ch == (int)'\r' || ch == -1)
            {
                // The input number is finished --> stop reading any more
                break;
            }
            if (ch > = '0' && ch < = '9')
            {
                ulong digit = (ulong)ch - (ulong)'0';
                sumOfDigits = sumOfDigits + digit;
            }
        }

        // Continue to sum the digits until a single digit is obtained
        while (sumOfDigits > 9)
        {
            ulong nextSumOfDigits = 0;
            while (sumOfDigits > 0)
            {
                ulong lastDigit = sumOfDigits % 10;
                nextSumOfDigits = nextSumOfDigits + lastDigit;
                sumOfDigits = sumOfDigits / 10;
            }
            sumOfDigits = nextSumOfDigits;
        }

        Console.WriteLine(sumOfDigits);
    }
}

Задача “Sand-Glass” – условие

Once upon a time a powerful wizard was born. His name was Gwenogfryn and soon he became a great sorcerer. Kind-hearted he was. He would only use his magic to protect humans from the evil witches that would come at night. Gwenogfryn, however was a pacifist and did not want to fight or hurt the witches, so he came up with another solution. He would catch the witches and throw them into a sand-glass (the only prison a witch cannot escape from). Unfortunately, he is running out of sand-glasses. Help Gwenogfryn catch all witches by making your own sand-glasses.

Задача “Sand-Glass” – вход

The input data should be read from the console.

You have an integer number N (always odd number) showing the height of the sand clock.

The input data will always be valid and in the format described. There is no need to check it explicitly.

Задача “Sand-Glass” – изход

The output should be printed on the console.

You should print the hourglass on the console. Each row can contain only the following characters: “.” (dot) and “*” (asterisk). As shown in the example: the middle row must contain only one ‘*’ and all other symbols must be “.”. Every next row (up or down from the middle one) must contain the same number of ‘*’ as the previous one plus two. You should only use “.” to fill-in the rows, where necessary.

Задача “Sand-Glass” – ограничения

The number N will be a positive integer number between 3 and 101, inclusive.

Allowed working time for your program: 0.25 seconds.

Allowed memory: 16 MB.

Задача “Sand-Glass” – примери

Input Output Input Output
5
*****
.***.
..*..
.***.
*****
7
*******
.*****.
..***..
...*...
..***..
.*****.
*******

Задача “Sand-Glass” – авторско решение

Авторското решение е абсолютно тривиално – просто върти цикли и смята колко звездички и колко точки отляво и отдясно да отпечата на всеки ред. Тази задача е може би най-лесната от втория изпитен ден. Ако някой не може да я реши, поне частично, и е учил цял месец програмиране, тряба да с замисли дали програмирането е за него. Ето и сорс кода на решението:

using System;

class SandGlass
{
    static void Main()
    {
        string line = Console.ReadLine();
        int n = int.Parse(line);

        for (int i = 0; i < = n / 2; i++)
        {
            string dots = new string('.', i);
            string stars = new string('*', n - 2 * i);
            Console.WriteLine("{0}{1}{2}", dots, stars, dots);
        }

        for (int i = n / 2 - 1; i > = 0; i--)
        {
            string dots = new string('.', i);
            string stars = new string('*', n - 2 * i);
            Console.WriteLine("{0}{1}{2}", dots, stars, dots);
        }
    }
}

Задача “Dancing Bits” – условие

Gergana loves dancing and she also likes bits (she doesn’t know what bits really are, but she knows that she likes them). Few days ago she accidently invented a new term – “dancing bits”.

If you ask her what “dancing bits” mean she will tell you that it’s a sequence of identical bits (so the bits can dance together – zeros can only dance with other zeros, the same applies for ones).

You are given N positive integer numbers that are converted to binary numeral system and are concatenated together in one big sequence of bits.

For example: if we have 4 numbers: 5 (101 in binary numeral system), 6 (110 in binary numeral system), 14 (1110 in binary numeral system) and 143 (10001111 in binary numeral system) their concatenation will be 101110111010001111.

You are also given a positive integer K – the number of identical bits (zeroes or ones that can dance together).

Write a program that finds the number of all “dancing bits” (the sequences of equal bits) with a length of exactly K bits. Your program should search in the concatenation of the given N numbers.

For example, if we have 4 numbers (5, 6, 14 and 143, the concatenation of their binary representation is 101110111010001111) and we are searching for the total number of all sequences of equal bits with an exact length of 3 bits, the answer will be 3 (the sequences are bolded in the concatenation above).

In this example we have two sequences of “dancing bits” – “111” consisting of only ones and one sequence of “dancing bits” – “000” consisting of only zeros. Note that the sequence “1111” is not a sequence of exact 3 identical bits.

Задача “Dancing Bits” – вход

The input data should be read from the console.

At the first input line there will be one positive integer – the number K.

At the second input line there will be another positive integer – the number N.

At each of the next N lines there will be one positive integer – the N numbers that represent the input sequence of bits.

The input data will always be valid and in the format described. There is no need to check it explicitly.

Задача “Dancing Bits” – изход

The output data should be printed on the console.

The only output line must contain the answer – the number of “dancing bits” sequences found.

Задача “Dancing Bits” – ограничения

The number K will be positive integer number between 1 and 25 600, inclusive.

The number N will be positive integer number between 1 and 800, inclusive.

Each of the N numbers will be positive integer numbers between 1 and 2 147 483 647, inclusive.

Allowed working time for your program: 0.25 seconds.

Allowed memory: 16 MB.

Задача “Dancing Bits” – примери

Input
Output
Input
Output
3
4
5
6
14
143 
3
1
4
2
10
42
170
20

Задача “Dancing Bits” – авторско решение

Тази задача не е от най-лесните. Алгоритъмът, който е имплементиран в решението, чете и обработва входа число по число. За всяко от тях той първо пропуска водещите нулеви битове отляво, а след това обработва останалите битове един по един. При обработката на значещите битове, се запазват в две променливи какъв е последният бит и колко поредни еднакви на него бита са обработени до момента. При смяна на текущия бит от 0 към 1 или от 1 към 0, това означава, че текущата редица еднакви битове е свършила и започва нова (с дължина 1). Когато текущата редица еднакви битове е свършила, ако тя има дължина K, значи сме намерили “танцуваща редица” и трябва да увеличим брояча. Накрая, когато всички числа и всички битове свършат, отново имаме редица с еднакви числа и трябва също да я проверим дали дължината й е K. Интересни гранични случаи за тестване са само единици (например числото 255 много пъти или само редици с дължина 1, например числото 2 много пъти). Задачата лесно може да се обърка и затова трябва да се тества обстойно. Ето и пълния сорс код на авторското решение:

using System;

class DancingBits
{
    static void Main()
    {
        int k = int.Parse(Console.ReadLine());
        int n = int.Parse(Console.ReadLine());
        int len = 0;
        int lastBit = -1;
        int dancingBitsCount = 0;
        for (int i = 0; i < n; i++)
        {
            int num = int.Parse(Console.ReadLine());

            // Skip the leading zeroes in num
            int firstNonZeroBit = 0;
            for (int bitNum = 31; bitNum > = 0; bitNum--)
            {
                int currentBit = (num > > bitNum) & 1;
                if (currentBit == 1)
                {
                    firstNonZeroBit = bitNum;
                    break;
                }
            }

            // Process the digits of num (without the leading zeroes)
            for (int bitNum = firstNonZeroBit; bitNum > = 0; bitNum--)
            {
                int currentBit = (num > > bitNum) & 1;
                if (currentBit == lastBit)
                {
                    // The current bits continues the last sequence
                    len++;
                }
                else
                {
                    // The sequence is changed - > start a new sequence
                    if (len == k)
                    {
                        dancingBitsCount++;
                    }
                    len = 1;
                }
                lastBit = currentBit;
            }
        }

        // Check the last sequence
        if (len == k)
        {
            dancingBitsCount++;
        }

        Console.WriteLine(dancingBitsCount);
    }
}

Задача “Lines” – условие

You are given a list of 8 bytes (positive integers in the range [0…255]) n0, n1, …, n7.

These numbers represent a square grid consisting of 8 lines and 8 columns.

Each cell of the grid could either be empty or full. The first line is represented by the bits of n0, the second – by the bits of n1 and so on, and the last line is represented by the bits of n7.

Each bit with value 1 denotes a full cell and each bit with value 0 denotes an empty cell.

The lines are numbered from the first (top) to the last (bottom) with the numbers 0, 1, …, 7.

The columns are numbered from right to left with the indices 0, 1, …, 7.

The figure shows a sample square grid and its representation by a sequence of 8 numbers n0, n1, …, n7:

Lines - example

A line is any sequence of full cells staying on the same row or column.

At the figure above we have two lines of 4 cells and two lines of 3 cells and 11 lines of 1 cell.

You need to create a program that finds the longest line in the grid and the number of lines with the longest length.

At the figure we have two largest lines with length of 4 cells.

Задача “Lines” – вход

The input data is should be read from the console.

There will be exactly 8 lines each holding the integer numbers n0, n1, …, n7.

It is guaranteed that there exists at least one line in the grid (the grid is not empty).

The input data will always be valid and in the format described. There is no need to check it explicitly.

Задача “Lines” – изход

The output consists of two integers placed on separate lines.

The first line should hold the length of the longest line in the grid.

The second line should hold the number of lines with the maximal length.

Задача “Lines” – ограничения

The numbers n0, n1, …, n7 are positive integers in the range [0…255].

Allowed work time for your program: 0.25 seconds.

Allowed memory: 16 MB.

Задача “Lines” – примери

Input Output Input Output
8
72
8
8
16
28
240
0 
4
2
246
247
248
249
250
251
252
253
8
4

Задача “Lines” – авторско решение

Тази задача също не е от най-лесните. По принцип трябва да се реши с матрица, която да се обхожда с вложени цикли, но тъй като масиви и матрици в C# курса още не са изучавани, авторското решение ползва 8-те входни числа вместо матрица. За достъп до определен ред и колона се извлича съответният бит (по номер на колона) от съответното входно число (по номер на ред). Алгоритъмът за намиране на най-дългите линии е прост: проверяват се всички хоризонтални и вертикални линии и от тях се намира най-дългата. Ако има няколко най-дълги, се броят. Като се започне в определена позиция (ред и колона), се тръгва надясно по хоризонтал. Докато има битове със стойност 1, понеже те са част от една и съща линия, се броят колко са. Ако текущата линия стане по-дълга от най-дългата за момента, тя се запомня. Ако стане равна на най-дългата за момента, се увеличава броят на най-дългите линии. Ако се стигне до бит със стойност 0, се започва търсенето на нова линия по съответния хоризонтал от нулата. След като се проверят линиите от всички хоризонтали, се прави аналогично сканиране на всички линии по вертикалите. Има и един особен случай: ако най-дългата линия се състои само от една пълна клетка (дължина 1), то тази клетка (линия) е едновременно хоризонтална и вертикална и алгоритъмът я брои два пъти (веднъж по хоризонтала и веднъж по вертикала). В този случай е необходимо общият брой на намерените линии да се раздели на две. Следва пълният сорс код на авторското решение. Не е ползвана матрица, както и методи, защото още не са учени в C# курса. С тях решението би било по-елегантно, но целта на авторското решение е да покаже как се решава задачата с изучаваните средства:

using System;

class Lines
{
    static void Main()
    {
        // Read the input numbers
        int num0 = Int32.Parse(Console.ReadLine());
        int num1 = Int32.Parse(Console.ReadLine());
        int num2 = Int32.Parse(Console.ReadLine());
        int num3 = Int32.Parse(Console.ReadLine());
        int num4 = Int32.Parse(Console.ReadLine());
        int num5 = Int32.Parse(Console.ReadLine());
        int num6 = Int32.Parse(Console.ReadLine());
        int num7 = Int32.Parse(Console.ReadLine());

        int bestLen = 0;
        int bestCount = 0;

        // Check all horizontal lines
        for (int row = 0; row < = 7; row++)
        {
            int rowBits = 0;
            switch (row)
            {
                case 0: rowBits = num0; break;
                case 1: rowBits = num1; break;
                case 2: rowBits = num2; break;
                case 3: rowBits = num3; break;
                case 4: rowBits = num4; break;
                case 5: rowBits = num5; break;
                case 6: rowBits = num6; break;
                case 7: rowBits = num7; break;
            }

            int len = 0;
            for (int col = 0; col < = 7; col++)
            {
                int cell = (rowBits > > col) & 1;
                if (cell == 1)
                {
                    len++;
                    if (len > bestLen)
                    {
                        bestLen = len;
                        bestCount = 0;
                    }
                    if (len == bestLen)
                    {
                        bestCount++;
                    }
                }
                else
                {
                    len = 0;
                }
            }
        }

        // Check all vertical lines
        for (int col = 0; col < = 7; col++)
        {
            int len = 0;
            for (int row = 0; row < = 7; row++)
            {
                int rowBits = 0;
                switch (row)
                {
                    case 0: rowBits = num0; break;
                    case 1: rowBits = num1; break;
                    case 2: rowBits = num2; break;
                    case 3: rowBits = num3; break;
                    case 4: rowBits = num4; break;
                    case 5: rowBits = num5; break;
                    case 6: rowBits = num6; break;
                    case 7: rowBits = num7; break;
                }

                int cell = (rowBits > > col) & 1;
                if (cell == 1)
                {
                    len++;
                    if (len > bestLen)
                    {
                        bestLen = len;
                        bestCount = 0;
                    }
                    if (len == bestLen)
                    {
                        bestCount++;
                    }
                }
                else
                {
                    len = 0;
                }
            }
        }

        // Check for the special case when the largest cell has size 1x1
        if (bestLen == 1)
        {
            // Cells with size 1x1 were counted twice - > recalculate them
            bestCount = bestCount / 2;
        }

        Console.WriteLine(bestLen);
        Console.WriteLine(bestCount);
    }
}

Тестове на журито

Както и първия изпитен ден, всички предадени решения на задачи се оценяват автоматизирано чрез серия тестове. За всяка задача има лесни тестове, по-трудни тестове и екстремални тестове – около границата на входа (най-малки и най-големи числа). Всяка задача се оценява с по 10 теста, всеки от които дава по еднакъв брой точки. В приложения файл са дадени нулевите тестове (от условията на задачите) и десетте изпитни теста, както и съответните им верни изходи.

Изтеглете тестовете на журито от изпита по C# програмиране от 7 декември 2011 г. в софтуерната академия на Телерик: Tests-CSharp-Exam-I-7-December-2011.rar.

Състезателната система за автоматично оценяване на задачите

В Академията на Телерик е разработена judge система за автоматично тестване и оценяване на задачи по програмиране, достъпна публично от сайта judge.softuni.bg:

състезателна система за оценяване на задачи по програмиране

Системата “Judge System” позволява многократно изпращане на решения по всяка задача по време на изпитите и предоставя пълен фийдбак в реално време, т.е. изпълнява веднага изпратените решения върху тестовете на журито и връща информация кои тестове са преминали успешно и кои не.

Тренировъчен и изпитен режим в Judge системата

Системата “Judge” работи в два режима – режим “тренировка” и режим “изпит”.

В режим “тренировка” всеки може да се регистрира и да тренира върху примерни изпитни задачи, да изпраща решения и да получава след това резултатите от изпълнените автоматично тестове – кои тестове минават успешно и кои не минават и по каква причина (грешен резултат, пресрочено време за изпълнение, грешка по време на изпълнение, грешка при компилация и т.н.).

В режим “изпит” системата позволява изпращане на задачи само от участници в изпита и в рамките на определеното за изпита време.

Класация на участниците във всяко състезание (изпит)

И в двата режима се поддържа класация на всички участници, която се обявява публично и се обновява в реално време. Така всеки участник може да види кои задачи са решили неговите колеги и колко точки имат на всяка от задачите:

Judge System - система за автоматично тестване и оценяване на на задачи по програмиране

Свободна тренировка в judge системата

Всички приятели на програмирането могат да се регистрират свободно в Judge системата и да тренират върху задачите от няколко тренировъчни изпита и от изпитите от 6 и 7 декември. С времето ще добавяме още тестови състезания (изпити) с много задачи – лесни и трудни, по възможностите на всеки. За момента се поддържа само език C#, но се предвижда разширяване на системата с поддръжка и на други езици за програмиране.

Успех на всички в програмирането!

Tags:
Previews (29,144), Views (1,366), Comments (11)

11 Responses to “195 души продължават да учат безплатно програмиране и C# в Софтуерната академия на Телерик след първия C# изпит”

  1. Patrick Valchev says:

    Интересувам се защо не попадам в класирането след като имам 500/500 точки. Просто сте ме изпуснали или не ми достигат точки макар да имам пълен брой точки и от домашните. Поздрави Патрик Вълчев

  2. Lachezar Tsonov says:

    И аз имам подобен въпрос като колегата – това класиране най-отгоре за финалния сбор точки или за точки от изпита?

    Питам, тъй като едно класиране е важен критерий къде се намираме при преминаване на определени бройки в по-следващи етапи.

  3. nakov says:

    Има бъг в Google Docs и се бяха объркали точките. Сега вече трябва да са коректни. Оказа се, че при export към Excel се разместват имената на хората и техните точки. Обаче с export към HTML и след това import в Excel работи коректно.

  4. Lachezar Tsonov says:

    И google се дънят понякога, какво да се прави:)

  5. Deyan Zhelyazkov says:

    Активно участие в онлайн дискусиите във форума на курса, по този критерий искам да кажа само, че около 60% от хората писаха пълни глупости не по същество и се заяждаха едни с други

  6. nakov says:

    За съжаление нямаме добър инструмент да отделим смислените от безсмислените коментари във форума. За това бртоим брой дни на активност + брой коментари общо.

  7. Plamen Hristov says:

    Мен лично много ме интересува,въпроса с класацията, къде?Дай те да я видим, черно на бяло кой, на кое място, много сте ми съмнителни, то е ясно че си имате вътрешни хора, ама поне си го признайте.

  8. Честито на всички, които продължават! Да не се отпускаме и да си помагаме!

  9. nakov says:

    @Plamen, няма да пускаме класация, тъй като тя разкрива персонална информация. Не искаме да показваме кой е най-слабият в курса. Шампионите сме ги обявили вече.

  10. krasin says:

    Добро постижение в C# играта – 120 действия извършени в 50 различни дни в рамките на един месец 🙂
    Предложение за тест към “Astrological Digits” – числото 12300, въведено обаче като 1.23e4 🙂

  11. Anonymous says:

    Абе вие луди ли сте да се омекотявате, не го работете това!!!

RSS feed for comments on this post. TrackBack URL

LEAVE A COMMENT