C# Part2 – Exam 11.02.2013 – Задача 3 – KukataIsDancing!

Продължавам с решения на задачите от изминали изпити, този път ще обясня накратко решението на Задача 3 – KukataIsDancing! от изпита от миналия сезон на Академията на11.02.2013 година.

Условието може да намерите тук: bgcoder.com/Contest/DownloadTask/337

1. Инициализира си куба в един двумерен масив, в случая нямаме нужда от тримерен тъй като Куката танцува само по повърхността на куба. Задаваме на всяко поле съответния цвят спрямо условието.

2. Четем си броя на танците, дефинираме си 3 променлива: currentIndexX и currentIndexY, в която ще пазим индексите на текущото поле в което се намира Куката и currentDirection, в която ще пазим посоката в която се движим, по +x, -x, +y или -y;

3. Пускаме си един цикъл от 0 до броя на танците, всеки ден ще започва от зеленото поле, съответно винаги ще стартираме от поле в куба на позиция [1,1].

4. Логиката, която аз имплементирам е следната, когато currentDirection е равно на 0, ще се движим в посока +x, когато е 1 или -3, ще се движим в посока +y, когато е 2 или -2, в посока -x, и когато е 3 или -1, в посока -y;

Като стойността на currentDirection ще се променя само когато посоките на нашия танц са L или R, при което трябва да променим посоката на движение. Като на всяка стъпка трябва да се застраховаме че текущата стойност на currentDirection не е по-голяма от 3 или по-малка от -3, ако текущата посока на движение става +x, а именно currentDirection = 0;

5. Когато символа от нашия текущ танц е ‘W’ в съответствия от посоката в която трябва да се движим съответно увеличаваме или намаляваме currentIndexX или currentIndexY, и тъй като Куката може да преминава от една стена на куба към друга негова стена, трябва да добавим условие при което никога да не излезнем от границите на нашия куб. А това става по следния начин, Ако текущия индекс по Х е по-голям от 2, преминаваме на нова стена от куба и следователно текущия индекс по Х става равен на 0, същото важи и за Y, А пък ако се движим в противоположната посока, ако текущия индекс по Х е по-малък от 0, отново преминаваме на друга страна на куба и следователно текущия индеск на Х става равен на 2, същото важи и за У.

6. След като сме прочели всички символи от текущия танц, принтираме на конзолата, цвета на полето в което се намира Куката след завършването на неговия танц.


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;


class KukataIsDancing
{
static void Main()
{
string[,] cube = new string[3, 3];

cube[0, 0] = "RED"; cube[0, 2] = "RED"; cube[2, 0] = "RED"; cube[2, 2] = "RED";
cube[0, 1] = "BLUE"; cube[1, 0] = "BLUE"; cube[1, 2] = "BLUE"; cube[2, 1] = "BLUE";
cube[1, 1] = "GREEN";

int number = int.Parse(Console.ReadLine());
int currentIndexX = 1;
int currentIndexY = 1;
int currentDirection = 0;

for (int i = 0; i < number; i++)
{
string text = Console.ReadLine();

currentIndexX = 1;
currentIndexY = 1;

for (int j = 0; j < text.Length; j++)
{
switch (text[j])
{
case 'L':
currentDirection += 1;
if (currentDirection > 3)
{
currentDirection = 0;
}
break;
case 'R':
currentDirection -= 1;
if (currentDirection < -3)
{
currentDirection = 0;
}
break;
case 'W':
if (currentDirection == 0)
{
currentIndexX += 1;
}
else if (currentDirection == 1 || currentDirection == -3)
{
currentIndexY += 1;
}
else if (currentDirection == 2 || currentDirection == -2)
{
currentIndexX -= 1;
}
else if (currentDirection == 3 || currentDirection == -1)
{
currentIndexY -= 1;
}
break;
}
if (currentIndexX > 2)
{
currentIndexX = 0;
}
else if (currentIndexX < 0)
{
currentIndexX = 2;
}
if (currentIndexY > 2)
{
currentIndexY = 0;
}
else if (currentIndexY < 0)
{
currentIndexY = 2;
}
}
Console.WriteLine(cube[currentIndexX, currentIndexY]);
}
}
}



C# Part2 – Exam 11.02.2013 – Задача 1 – 9GagNumbers

В следващите редове, ще обясне накратко решението на Задача 1 – 9GagNumber от изпита от миналия сезон на Академията на11.02.2013 година.

Условието на задачата може да свалите от тук: bgcoder.com/Contest/DownloadTask/322

1. Четем string-а който ни е подаден като вход

2. В един масив от стрингове, добавя всеки един от елементите с които трябва да съвпада част от нашия стринг, които са ни дадени по условие

3. Започваме да обхождаме входния стринг, символ по символ и всеки символ да го добавяме в един String Builder,

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

4. Когато сме приключили с обработката на входния низ, обръщаме листа от интове на обратно, тъй като се изисква последното добавено число, да бъде нашето първо число.

5. Обхождаме листа число по число и умножаваме текущото число по 9 на степен индекса на текущото число и пазим резултата в променливата result. След като сме обходили целия списък, печатаме на конзолата получения резултат. Използваме BigInteger.Pow, тъй като Math.Pow работи с double и не работи напълно коректно за много големи числа.


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Numerics;

class Program
{
static void Main()
{
string input = Console.ReadLine();

string[] symbols = new string[] { "-!", "**", "!!!", "&&", "&-", "!-", "*!!!", "&*!", "!!**!-" };

StringBuilder exact = new StringBuilder();
List<ulong> number = new List<ulong>();

for (int i = 0; i < input.Length; i++)
{
exact.Append(input[i]);

switch (exact.ToString())
{
case "-!":
number.Add(0);
exact.Clear();
break;
case "**":
number.Add(1);
exact.Clear();
break;
case "!!!":
number.Add(2);
exact.Clear();
break;
case "&&":
number.Add(3);
exact.Clear();
break;
case "&-":
number.Add(4);
exact.Clear();
break;
case "!-":
number.Add(5);
exact.Clear();
break;
case "*!!!":
number.Add(6);
exact.Clear();
break;
case "&*!":
number.Add(7);
exact.Clear();
break;
case "!!**!-":
number.Add(8);
exact.Clear();
break;
}
}

ulong[] arrayToReverse = number.ToArray();
Array.Reverse(arrayToReverse);

ulong result = 0;
ulong power = 0;

for (int i = 0; i < arrayToReverse.Length; i++)
{
power = (ulong)BigInteger.Pow(9, i);
result += (arrayToReverse[i] * power);
}

Console.WriteLine(result);

}
}

C# Part2 – Exam 04.02.2013 – Задача 4 – Console Justify

Ще се опитам да представя и обясня подробно авторското си решение на Задача 4 - Console Justify,
от изпита от миналия сезон на Академията на 04.02.2013 година.
Условието на задачата може да свалите от тук:
http://bgcoder.com/Contest/DownloadTask/324

Решение:

Прочитаме си входа, като парсваме към инт съответно :

1. броя на редовете на текста който трябва да обработим

2. броя на максималния символите, който можем да имаме на един ред в подравнения текст

3. четем си текства, като го добавяме в един StringBuilder, като след всеки ред добавяме space, след това

го Split – ваме, в масив от стрингове, като всеки елемент от масива е дума от входния текст

След като сме си прочели входа извикваме функцията OutputJustifyText с параметри масива от стрингове и максималния брой

на символите на един ред:

1. Създаваме си един нов StringBuilder outputText, в който ще добавяме обработения текст

2. Обхождаме масива от стрингове и проверяваме дали текущата дължина на StringBuilder-а + текущата дума е по – малка

от максималния брой символи които можем да имаме на един ред(numberOfSymbols)

Ако условието  е вярно добавяме към outputText текущата дума,  и проверяваме дали текущата дължина на outputText

+ space e по-малко от numberOfSymbols, ако е по-малко добавяме към outputText един space.

3. Ако условието от 2. не е вярно викаме функцията AddOrRemoveSpaces с чиято помощ добавяме и премахваме space-ове, за да

достигнем желания брой на символи на един ред.

Какво прави тя, първо проверява дали случайно последния символ от реда не е space, ако е го премахва.

След това взима индекса на първия намерен символ space в текущия ред.

Проверява дали случайно няма намерен space, това се получава в случай че на реда се събира само една единствена дума,

ако е така принтира на конзолата съответния ред.

Ако е намерен символ space, влизаме в един while цикъл, при който излизаме когато е достигнат желания брой символи на реда:

Вътре в цикъла първо проверяваме дали случайно текущата дума няма дължината равна на броя желани символи

Ако е така, принтираме реда на конзола и break-ваме цикъла, в противен случай добавяме нов space, след първия намерен и продължаваме

да изпълняваме цикъла, като индекс-а на следващия търсен space, ще бъде текущия индекс + променлива spaceCounter в която ще пазим дължината на текущата поредица от space символи, това го правим с цел да не попаднем в един безкраен цикъл.

Ако сме достигнали до момент в който на текущия ред няма повече space-ове, увеличаваме spaceCounter с 1 и присвояваме на променливата index

индекс-а на първия намерен space, за да проверим дали вече сме достигнали броя на желаните символи, и ако не сме отново от началото на реда

търсим space и увеличаваме дължината им с 1 и така докато достигнем желания брой символи на реда.

Накрая извикваме функцията AddOrRemoveSpaces още един път, защото в противен случай ще изпуснем последния ред.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;


class ConsoleJustifyMethod
{
static void Main()
{
int numberOfLines = int.Parse(Console.ReadLine());
int numberOfSymbols = int.Parse(Console.ReadLine());

StringBuilder text = new StringBuilder();

for (int i = 0; i < numberOfLines; i++)
{
text.Append(Console.ReadLine());
text.Append(" ");
}
char[] separators = new char[] { ' ' };
string[] splittedText = text.ToString().Split(separators, StringSplitOptions.RemoveEmptyEntries);

OutputJustifyText(splittedText, numberOfSymbols);
}
static void OutputJustifyText(string[] splittedText, int numberOfSymbols)
{

StringBuilder outputText = new StringBuilder();

int spaceCounter = 2;

for (int i = 0; i < splittedText.Length; i++)
{
if (((outputText.ToString() + splittedText[i]).Length <= numberOfSymbols))
{
outputText.Append(splittedText[i]);
if ((outputText.ToString() + " ").Length < numberOfSymbols)
{
outputText.Append(" ");
}
}
else
{
AddOrRemoveSpaces(outputText, numberOfSymbols, spaceCounter);
outputText.Append(splittedText[i] + " ");
}
}
AddOrRemoveSpaces(outputText, numberOfSymbols, spaceCounter);
return;
}

static void AddOrRemoveSpaces(StringBuilder outputText, int numberOfSymbols, int spaceCounter)
{
if (outputText[outputText.Length - 1] == ' ')
{
outputText.Remove(outputText.Length - 1, 1);
}
int index = outputText.ToString().IndexOf(' ', 0);

if (index == -1)
{
Console.WriteLine(outputText.ToString().TrimEnd(' '));
outputText.Clear();
}

int firstIndex = index;
while (index != -1)
{
if (outputText.Length == numberOfSymbols)
{
Console.WriteLine(outputText.ToString().TrimEnd(' '));
outputText.Clear();
spaceCounter = 2;
break;
}
else
{
outputText.Insert(index, ' ');
index = outputText.ToString().IndexOf(' ', index + spaceCounter);
}
if (index == -1)
{
spaceCounter++;
index = firstIndex;
}
}
return;
}
}


[C#] Домашно Strings and Text Processing – 21 задача

Една от задачите, която ми се стори интересна, и ми хареса решението което направих:

Условието на задачата е следното:

Write a program that reads a string from the console and prints all different letters in the string along
with information how many times each letter is found.

http://pastebin.com/YtW5cXrn

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

Пускаме един for цикъл от 0 до дължината на масива, ако буквата върху която сме стъпили не е посетена и съответно е буква, а не напримерно празен низ или запетайка.

Когато сме стъпили на непосетена буква, взимаме нейният индекс с помощта на IndexOf(), пускаме един цъкал while, от който ще излезнем тогава когато няма повече срещания на съответната буква в стринга. На всеки индекс, на който сме стъпили в булевия масив му присвояваме стойност true, и увеличаваме брояча с 1, и съответно на индекса задаваме да търси ново съвпадение на съотвената буква от индекса на вече намерената + 1. Когато няма повече срещания на съотвената буква, индекса връща -1 и излизаме от while цикъла и на конзолата печатим съответната буква и колко пъти се среща тя.

http://telerikacademy.com/

 

Курс “Споделяне на знания и работа в екип”

Паралелно с курса C# – Part – 2, започна и курса “Споделяне на знания и работа в екип”. Той има за цел да възпитава култура на свободно споделяне на знания и взаимопомощ сред курсистите в Академията на Телерик и да им даде възможност да натрупат умения за работа в екип чрез участие в конкретни проекти от реалния свят в екипи от по няколко души.

В този курс е заложена да се научим:

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

– как да си направим developer profile, в който да споделяме свободно сорс кодове от курсовете, проектите в които участваме и т.н.

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

Задачите които ще имаме в този курс са да си направим собствен блог и собствен developer профил, и отборен проект на дадена тема с цял обогатяването на българската уикипедия.

Част от този курс, насочен към курса C# Part – 2 ще е разработването в екип на конзолна игра от тип Tetris, Snakе.

Подробна информация за курса, може да се намери тук:

Курс “Споделяне на знания и работа в екип”