По принцип си прав. Ако трябва да следва примера на задачките ( да продължи докато цикъла свърши и  накрая да даде резултата ) няма нужда да има return там. :)

Привет!

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

Поздрави!

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

Хареса ви начина ти на мислене, защото е 99% подобен на моя. Ето решение с един брояч

using System;

namespace _06._Balanced_Brackets
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());

            int count = 0;
            for (int i = 1; i <= n; i++)
            {
                string bracket = Console.ReadLine();
                
                if (bracket == "(")
                {
                    count++;
                }
                if (bracket == ")")
                {
                    count--;
                }
                if (count < 0)
                {
                    Console.WriteLine("UNBALANCED");
                    return;
                }
            }

            if (count == 0)
            {
                Console.WriteLine("BALANCED");
            }
            else
            {
                Console.WriteLine("UNBALANCED");
            }
        }
    }
}
 

За неточната формулировка си абсолютно прав, благодарско от мен!

Здравейте, имам същата задача във Fundamental модула и Judge ми дава 85/100. Може ли  да ми помогнете да открия къде греша в кода си? Затруднявам се да добавя проверката за две последователни еднакви скоби и може би тук е проблема.

using System;

namespace TrainingWithData2
{
    class MainClass
    {
        public static void Main()
        {

            int rangeofLines = int.Parse(Console.ReadLine());
            int countOpenBracket = 0;
            int countClosedBracket = 0;

            string line = Console.ReadLine();
            if(line==")")
            {
                Console.WriteLine("UNBALANCED");
            }

            else {
                for (int i = 0; i < rangeofLines - 1; i++)
                {

                    if (line == "(")
                    {
                        countOpenBracket++;

                    }
                    else if (line == ")")
                    {
                        countClosedBracket++;

                    }
                    line = Console.ReadLine();
                }
            }

            if (countOpenBracket == countClosedBracket)
            {
                Console.WriteLine("BALANCED");
            }
            else
            {
                Console.WriteLine("UNBALANCED");
            }

        }

        }
        }

На български съм направил коментари в кода Ви.
Опитал съм се да се впиша във вашата логика… май кода трудно си личи какъв е бил в началото :)
По принцип логиката може доста да се оптимизира…
Ползвал съм return-и, което не го намирам за много коректно, но иначе трябва да се пренашише целия код за да се избегне ползването им.

using System;

namespace TrainingWithData2
{
    class MainClass
    {
        public static void Main()
        {

            int rangeofLines = int.Parse(Console.ReadLine());
            int countOpenBracket = 0;
            int countClosedBracket = 0;

            // кода по-долу търси да "хване" първа затваряща скоба...
            // но той ще изследва за първа затвяряща скоба САМО за първия подаден символ
            // затова по-добре да го няма 

            //string line = Console.ReadLine();
            //if (line == ")")
            //{
            //    Console.WriteLine("UNBALANCED");

            //}

            //else
            //{
            
            // ще използваме една променлива в която да съхраняваме всяка предходна скоба и да я сравняваме.
            // като за начало ще сложим ")" скоба - така, ако първо дойде ")" - ще получим сигнал за
            // УНБАЛАНЦЕД... реално нямаме две еднакви скоби, но пък - нямаме право да имаме първа ")" скоба
            // така проверяваме и за първа скоба
            string previousBracket = ")";

            // нещо с диапазона има объркано тук
            // за да не се бъркате, когато неработите с индекси (тогава няма как да не започнете от 0)
            // може да ползвате логичното от i=1 до i<= n
            //for (int i = 0; i < rangeofLines - 1; i++)
            for (int i = 1; i <= rangeofLines; i++)
            {

                // преместил съм входа да е най-отгоре.
                // вход, който се намира най-отдолу в цикъл е нелогичен и може да доведе до грешки 
                // (примерно ако искате да направяите скип на някой от циклите)
                string line = Console.ReadLine();

                if (line == "(")
                {
                    countOpenBracket++;

                    // -------------------------------------------------- това е редно да стане метод ----------
                    // тук ще проверим дали сегашната скоба е същата като предишната
                    if (line == previousBracket)
                    {
                        // ако скобите са еднакви - значи резултата следва да е ЪНБАЛАНСЕД
                        Console.WriteLine("UNBALANCED");
                        return;

                        // ако искаме да оставим да бъде въведен целия вход на задачата =>
                        // няма да приключваме с return, a ще трябва да си направим една bool променлива
                        // някъде извън цикъла, за да може да съхраним информацията, че сме имали две
                        // поредни скоби - и после най-накрая да се съобразим с тази bool и да принтираме
                        // съобразно дали сме имали две поредни скоби
                    }
                    else
                    {
                        // ако скобите не са еднакви
                        previousBracket = line;
                    }
                    // ----------------------------------------------------------------------------------
                }
                else if (line == ")")
                {
                    countClosedBracket++;

                    // -------------------------------------------------- това е редно да стане метод ----------
                    // тук ще проверим дали сегашната скоба е същата като предишната
                    if (line == previousBracket)
                    {
                        // ако скобите са еднакви - значи резултата следва да е ЪНБАЛАНСЕД
                        Console.WriteLine("UNBALANCED");
                        return;

                        // ако искаме да оставим да бъде въведен целия вход на задачата =>
                        // няма да приключваме с return, a ще трябва да си направим една bool променлива
                        // някъде извън цикъла, за да може да съхраним информацията, че сме имали две
                        // поредни скоби - и после най-накрая да се съобразим с тази bool и да принтираме
                        // съобразно дали сме имали две поредни скоби
                    }
                    else
                    {
                        // ако скобите не са еднакви
                        previousBracket = line;
                    }
                    // ----------------------------------------------------------------------------------

                }
                //line = Console.ReadLine();
            }
            //}

            if (countOpenBracket == countClosedBracket)
            {
                Console.WriteLine("BALANCED");
            }
            else
            {
                Console.WriteLine("UNBALANCED");
            }

        }

    }
}

Здравейте, споделям още две решения на тази задача, които са 100/100. Имам питането: ако пренапиша условието на цялата задача на кого трябва да го изпратя за да съм сигурна, че ще го вземат под внимание? Лично според мен в целия Фундаментал модул няма друга подобна задача с по-неясно условие.

Решение 1: с openedBracketCounter и closedBracketsCounter

1) Ако имаме "xxxx(xxxxxx(ххх", т.е две отварящи скоби една след друга-"UNBALANCED" и return. Програмата ще разбере, когато имаме две отварящи скоби една след друга, ако openedBracketCounter стане равен на 2.

2) Ако имаме "хххх)ххххх)ххх", т.е две затварящи скоби една след друга-"UNBALANCED" и return. Програмата ще разбере, когато имаме две затварящи скоби една след друга, ако closedBracketsCounter стане равен на 2.

3) Винаги когато имаме "хххх(хххххх)ххх, т.е една отваряща скоба и ведната след нея една затваряща скоба, то значи всичко е наред в програмата и ще нулирам двата каунтъра за да могат и по-нататъка да работят правилно. За целта правя проверката дали openedBracketCounter=1 и същевременно и closedBracketsCounter=1, като ако е изпълнено това условие openedBracketCounter става 0 и closedBracketsCounter става 0.

4) Винаги, в случаите, когато имаме първоначално само затваряща скоба, без наличието преди това на отваряща такава, също е- "UNBALANCED" и return, т.е. ")хххххх" или "ххххх)ххх". Програмата ще го разбере това, ако input=")" и същевременно openedBracketCounter=0.

5) И накрая след for цикъла, ако двата каунтъра са равни печатаме: "BALANCED", но ако не са равни "UNBALANCED"(значи някоя от песледните скоби ни разваля балансираността).

using System;

namespace BalancedBracketwithCounter
{
    class MainClass
    {
        public static void Main(string[] args)
        {

            int numbersOfLines = int.Parse(Console.ReadLine());
            int openedBracketCounter = 0;
            int closedBracketsCounter = 0;

            for (int i = 0; i < numbersOfLines; i++)
            {
                string input = Console.ReadLine();

                if(input==")" && openedBracketCounter == 0)
                {
                    Console.WriteLine("UNBALANCED");
                    return;
                }

               else if (input == "(")
                {

                    openedBracketCounter ++;
                    if (openedBracketCounter == 2)
                    {
                        Console.WriteLine("UNBALANCED");
                        return;
                    }
                }

                else if (input == ")")
                {
                    closedBracketsCounter ++;
                    if (closedBracketsCounter == 2)
                    {
                        Console.WriteLine("UNBALANCED");
                        return;
                    }
                }

                if(openedBracketCounter==1 && closedBracketsCounter == 1)
                {
                    openedBracketCounter = 0;
                    closedBracketsCounter = 0;
                }
            }

            if (openedBracketCounter == closedBracketsCounter)
            {
                Console.WriteLine("BALANCED");
            }

            else
            {
                Console.WriteLine("UNBALANCED");
            }

        }
    }
}

Решение 2: с listOfOpenedBrackets и listOfClosedBrackets

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

1) Ако дължината на listOfOpenedBrackets=2, то имаме две отварящи скоби една след друга- "UNBALANCED" и return.

2) Ако дължината на listOfClosedBrackets=2, то имаме две  затварящи скоби една след друга- "UNBALANCED" и return.

3) Ако дължината и на двата листа е 1, то значи имаме една "(" и една ")" и всичко е наред в програмата. Ще зачистим и двата листа, като използваме Clear().

4) И допълнителната проверка за ")" без наличието на "(".  Ако inputa=")", но все още нямаме "(" в listOfOpenedBrackets, т.е listOfOpenedBrackets.Count=0: "UNBALANCED" и return.

5) Накрая след for цикъла, ако дължината на двата листа е равна-печатаме "BALANCED", но ако не е, то отново значи някоя от последните скоби ни разваля балансираността.

using System;
using System.Collections.Generic;

namespace balancedBreckets
{
    class MainClass
    {
        public static void Main(string[] args)
        {

            int numberOfLines = int.Parse(Console.ReadLine());
            List < string > listOfOpenedBrackets= new List<string>();
            List<string> listOfClosedBrackets= new List<string>();
           

            for (int i = 0; i < numberOfLines; i++)
            {
                string input = Console.ReadLine();
                if (input == ")"&& listOfOpenedBrackets.Count==0)
                {
                    Console.WriteLine("UNBALANCED");
                    return;
                }

               else if (input == "(")
                {

                    listOfOpenedBrackets.Add(input);
                    if (listOfOpenedBrackets.Count == 2)
                    {
                        Console.WriteLine("UNBALANCED");
                        return;
                    }
                   
                }

                else if (input == ")")
                {
                    listOfClosedBrackets.Add(input);
                    if (listOfClosedBrackets.Count == 2)
                    {
                        Console.WriteLine("UNBALANCED");
                        return;
                    }
                }

                if (listOfOpenedBrackets.Count==1 && listOfClosedBrackets.Count==1)
                {
                    listOfOpenedBrackets.Clear();
                    listOfClosedBrackets.Clear();

                }
            }

            if (listOfOpenedBrackets.Count==listOfClosedBrackets.Count)
            {
                Console.WriteLine("BALANCED");
            }
            else
            {
                Console.WriteLine("UNBALANCED");
            }

        }
    }
}