Професионална програма
Loading...
+ Нов въпрос
Vesolini avatar Vesolini 7 Точки

06. Balanced Brackets

Здравейте банда! Може ли някой да ми помогне да разбера къде греша. Judge ми дава 85/100

https://pastebin.com/CckYHSD3

 

6.   Balanced Brackets

You will receive n lines. On those lines, you will receive one of the following:

  • Opening bracket – “(“,
  • Closing bracket – “)” or
  • Random string

Your task is to find out if the brackets are balanced. That means after every closing bracket should follow an opening one. Nested parentheses are not valid, and if two consecutive opening brackets exist, the expression should be marked as unbalanced.

Input

  • On the first line, you will receive n – the number of lines, which will follow
  • On the next n lines, you will receive “(”, “)” or another string

Output

You have to print “BALANCED”, if the parentheses are balanced and “UNBALANCED” otherwise.

Constraints

  • n will be in the interval [1…20]
  • The length of the stings will be between [1…100] characters

Examples

Input

Output

 

Input

Output

8

(

5 + 10

)

* 2 +

(

5

)

-12

BALANCED

 

6

12 *

)

10 + 2 -

(

5 + 10

)

 

 

UNBALANCED

Тагове:
1
Module: C# Advanced
inkarnasion avatar inkarnasion 278 Точки

Здравей, 

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

https://pastebin.com/zu7wvL0V

Поздрави

 

1
26/05/2019 18:33:40
nsavov avatar nsavov 68 Точки

Здравейте,

Аз я реших с 2 булеви и доста простичка логика:

Цък

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

Поздрави!

1
27/05/2019 18:04:56
Vesolini avatar Vesolini 7 Точки

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

0
yocalee avatar yocalee 3 Точки

Привет!

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

Поздрави!

0
Joro_Paspalev avatar Joro_Paspalev 21 Точки

Здравей,

тъй като немога да отворя кода ти в Pastebin - явно е премахнат от модератор, пускам моя код тук, който дава 100/100 в Judge.

Използвам метода TryParse, който учихме преди няколко лекции.

Успех!


            int countOfLines = int.Parse(Console.ReadLine());

            int deviationCounter = 0;
            bool isBalanced = true;

            int counterLeftBracket = 0;
            int counterRightBracket = 0;

            for (int i = 0; i < countOfLines; i++)
            {
                string currentSymbol = Console.ReadLine();

                bool isChar = char.TryParse(currentSymbol, out char chValue);
                if (chValue == '(')
                {
                    deviationCounter++;
                    counterLeftBracket++;
                    if (deviationCounter >= 2)
                    {
                        isBalanced = false;
                        break;
                    }
                }
                else if (chValue == ')')
                {
                    deviationCounter--;
                    counterRightBracket++;
                    if (deviationCounter < 0)
                    {
                        isBalanced = false;
                        break;
                    }
                }
            }
            if (isBalanced && counterLeftBracket == counterRightBracket)
            {
                Console.WriteLine("BALANCED");
            }
            else
            {
                Console.WriteLine("UNBALANCED");
         

0
krum_43 avatar krum_43 547 Точки

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

0
grafcheto avatar grafcheto 2 Точки

https://pastebin.com/7g2EBN9P

85/100?

0
Savas avatar Savas 37 Точки

Бих казал една хубава задача, но има един недостатък – намирам, че условието не е добре формулирано. По принцип има да се направят 2-3 проверки. За тези като мен, които се загубиха в превода – ще напиша на български какво се иска в условието, за да може да се пробвате да решите задачата сами преди да погледнете към чуждите решения.

  • За да имаме BALANCED - след всяка отваряща скоба, трябва да има затваряща скоба.
  • Две еднакви скоби, една след друга, не се толерират - следователно крайния резултат ще е UNBALANCED.
  • Не е ОК и да се започва със затваряща скоба т.е. ако най-първата скоба, която се появи на входа е затваряща – резултата следва да е UNBALANCED.
2
19/05/2020 19:43:27
Angello avatar Angello 1 Точки

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

0
Elena123456 avatar Elena123456 222 Точки

Здравейте, имам същата задача във 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");
            }

 

        }

        }
        }

 

0
Savas avatar Savas 37 Точки

На български съм направил коментари в кода Ви.
Опитал съм се да се впиша във вашата логика… май кода трудно си личи какъв е бил в началото :)
По принцип логиката може доста да се оптимизира…
Ползвал съм 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");
            }

        }

    }
}

 

 

 

 

1
17/06/2020 18:53:13
krum_43 avatar krum_43 547 Точки

Ето едно кратко решение и от мен(57/100):

using System;

namespace Balanced_Brackets
{
    class Program
    {
        static void Main(string[] args)
        {
            int number =int.Parse(Console.ReadLine());
            bool isExistLeftBracket = false;
            for (int i = 0; i <number; i++)
            {
                string line = Console.ReadLine();
                if(line=="(")
                {
                    isExistLeftBracket = true;
                }
                if(line==")")
                {
                    if(isExistLeftBracket==false)
                    {
                        Console.WriteLine("UNBALANCED");
                        return;
                    }
                    else
                    {
                        isExistLeftBracket = false;
                    }
                }
            }
            Console.WriteLine("BALANCED");

        }
    }
}
 

0
Elena123456 avatar Elena123456 222 Точки

Здравейте, споделям още две решения на тази задача, които са 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");
            }

        }
    }
}

1
03/09/2020 11:59:44
vezy1326 avatar vezy1326 1 Точки

100/100 с List<String> -  https://pastebin.com/KNkvR4HD 

Целият проблем според мен идва от условието, иначе задачата не е сложна!

Тази част от условието е сгрешена:

"That means after every closing bracket should follow an opening one"

 

 

0
26/09/2020 11:35:02