Programm, um die balance der Klammern

Hallo ich habe ein string-array, das die Werte enthält, die als "{[()]}", "}[]{", "{()[]". Jetzt habe ich, um die balance der Klammern wie für jedes Start-Klammer, z.B. { oder [ oder (, es muss eine schließende Klammer. Wenn der input-string hat die gleiche Anzahl öffnende und schließende Klammern, dann ist die Ausgabe "JA" sonst "NEIN". Auch wenn der string hat eine schließende geschweifte Klammer vor eine passende öffnende Klammer dann auch die Ausgabe "NEIN". Also im Grunde hat die Ausgabe zu einem string-array, werden die Werte enthalten, wie dies für die oben genannten input-Zeichenfolge-array : "JA", "NEIN", "NEIN".

Schrieb ich das folgende Programm, das eine Menge von if-else-Bedingung. Ich Frage mich, ob es keine bessere Möglichkeit in C#, um mit diesem problem umzugehen.

static void Main(string[] args)
{
  string[] arrBraces = Console.ReadLine().Split(' ');
  string[] result = new String[arrBraces.Length];

  for (int i = 0; i < arrBraces.Length; i++) {
    Console.WriteLine(arrBraces[i]);
    int curly = 0, square = 0, round = 0;

    foreach (char c in arrBraces[i]) {
      if (c == '{') {
        curly++;
      } else if (c == '[') {
        square++;
      } else if (c == '(') {
        round++;
      } else if (c == '}') {
        if (curly > 0) {
          curly--;
        } else {
          curly = -1;
          break;
        }
      } else if (c == ']') {
        if (square > 0) {
          square--;
        } else {
          square = -1;
          break;
        }
      } else if (c == ')') {
        if (round > 0) {
          round--;
        } else {
          round = -1;
          break;
        } 
      }
    }

    if (curly == 0 && square == 0 && round == 0) {
      result[i] = "YES";
    } else {
      result[i] = "NO";
    }
  }

  foreach (string str in result) {
    Console.WriteLine (str);
  }
  Console.ReadKey();
}

Fand ich eine ähnliche Frage hier aber so wie es scheint, ist auch die gleiche Sache, nur, dass es mit stack zum speichern der Klammer in der Erwägung, dass mein problem erklärt ausdrücklich, dass die Klammern in einem string-array.

Sowieso jede Hilfe oder Anregungen zur Verbesserung der code wäre sehr hilfreich.

InformationsquelleAutor Naphstor | 2016-05-05

arrays c#conditional if-statement string

8

Folgen Sie den unten algo:

1) Verwenden Sie einen Stapel

2) Lesen string von Links

3) push-to-stack, wenn aktuelle lese-Brief ist geöffnet Klammer ('(','{','[')

4) pop vom stack, wenn aktuelle lese-Brief ist geschweifte Klammer.

5) Überprüfen Sie die geknallt Klammer mit der die aktuelle lese-Klammer

5.a) wenn es das pairing Klammer. ok weiter

5.b) wenn stack leer war, dann ist der Druck NICHT

5.c) wenn knallte char und Lesen char nicht ein paar drucken Sie dann KEINE

6) wenn alle der Zeichenfolge verarbeitet werden. überprüfen Sie die Länge des Stapels.

6.a) wenn die Länge 0 ist print JA

6.b) sonst der Druck NICHT
- Wenn nur der Ausgleich des zählen von öffnenden und schließenden Klammern war die Anforderung, dann Joel Coehoom die erste Lösung richtig war. Ich fehlinterpretieren Ihrer Anforderung. Im Grunde ist dieser Algorithmus funktioniert für das Szenario, wo Sie die open close-Symmetrie auch.
InformationsquelleAutor Kiran Paul
7

Kann man sicherlich machen diese mehr prägnant:
```
public static bool CheckString(string input)
{
    int braceSum = 0, squareSum = 0, parenSum = 0;

    foreach(char c in input)
    {   //adjust sums
        if (c == '{') braceSum++;
        if (c == '}') braceSum--;
        if (c == '[') squareSum++;
        if (c == ']') squareSum--;
        if (c == '(') parenSum++;
        if (c == ')') parenSum--;

        //check for negatives (pair closes before it opens)
        if (braceSum < 0 || squareSum < 0 || parenSum < 0) return false;
    }
    return (braceSum == 0 && squareSum == 0 && parenSum == 0);
}
```
Beachten Sie, dass in diesem Fall die elses sind nicht unbedingt notwendig. Sie können nur if jeder Charakter option. Es kann eine mikroskopische performance-Vorteil zu nutzen else hier, aber ich würde erwarten, dass der compiler zu optimieren, Weg keinen Unterschied. Wenn Sie dies nicht möchten, können Sie auch ein switch - Anweisung.

Vollständigkeit halber, hier ist ein Main() verwendet diese Funktion:
```
static void Main(string[] args)
{
    var input = Console.ReadLine();
    if (string.IsNullOrWhiteSpace(input))
        input = "{[()]} }[]{ {()[] {()[]} ({)}"; //get through tests faster

    var data = input.Split(' ')
                    .Select(s => new {Input = s, Result = CheckString(s)?"YES":"NO"});

    foreach(var item in data)
    {   //guessing at input length here
        Console.WriteLine("{0,-26} \t--{1,5}", item.Input, item.Result);
    }

    //just because the question asked for an array
    var result = data.Select(i => i.Result).ToArray();

    Console.ReadKey(true);
}
```
Einer Sache, die nicht klar aus der Frage, ob dies legal ist:

({)}

Es ist legal, nach dem Beispiel-code, und als dieser sieht aus wie eine Praxis-übung kann es keine Rolle. Aber für die realen Probleme beschrieben, die durch diese übung, dieses oft (nicht immer, aber oft) nicht legal und wird als "unsymmetrisch". Wenn es nicht egal ist, müssen Sie die Verwendung eines einzigen Stack eher als die einzelnen Summen, und Ihre CheckString() Methode könnte wie folgt Aussehen:
```
public static bool CheckString(string input)
{   //Use the closer rather than opener as the key.
    //This will give better lookups when we pop the stack
    var pairs = new Dictionary<char, char>() {
        { '}','{' },  { ']','[' },   { ')','(' }
    }
    var history = new Stack<char>();

    foreach(char c in input)
    {
        if (pairs.ContainsValue(c)) history.Push(c);
        if (pairs.ContainsKey(c) && (history.Count == 0 || history.Pop() != pairs[c]))
            return false;
    }
    return (history.Count == 0);
}
```
- Die meisten prob illegale Joel Coehoom. ({)}, (}{)
- Ich habe eine Methode, die Konten für das jetzt.
- vielen Dank für die Lösung. Ich habe versucht, die erste Lösung, die du gepostet hast, aber ich denke, es versagt in dem Fall, wenn der input-string "} [] { ", weil Sie in diesem Fall zuerst braceSum-- ausführen setzen braceSum Wert " -1 "und dann wenn es auf' { ' , wird es in braceSum++ was bringt der Wert braceSum auf 0. Und so ist die Ausgabe "JA". Ich mag die Verwendung von LinQ in Main (). Auch der Testfall, den Sie zur Verfügung gestellt haben ist legal als Teil des Problems, damit die Ausgabe für "({)} " "JA". Die 2. Lösung nahm meine irgendwann zu verstehen, aber ich mochte es wirklich. Danke.
- Mein erstes Beispiel zurück false für }[]{ weil es prüft, ob eine negative total nach jedem Zeichen, und gibt sofort, wenn er eine findet. Es wird nicht halten lange genug, um zu sehen, die { Charakter.
- Auch: ich hatte eigentlich nicht den code ausführen, bevor jetzt. Alles war nur getippt in der "reply" - Fenster, also ich habe den code für eine schnelle Drehung, um zu bestätigen, es funktioniert tatsächlich und die erwarteten Ergebnisse hervorbringt. Teil davon war die Zugabe von ein paar Zeilen zu Main[] um es schneller zu machen, um zu überprüfen, wie sich änderungen am code werden die Ergebnisse beeinflussen.
InformationsquelleAutor Joel Coehoorn

        public static bool ValidBraces(String braces)
        {
            if (String.IsNullOrWhiteSpace(braces))
            {
                //invalid
                return false;
            }

            Stack<char> stack = new Stack<char>();

            for (int i = 0; i < braces.Length; i++)
            {
                //if its an open brace, stack
                if (braces[i] == '{' || braces[i] == '[' || braces[i] == '(')
                {
                    stack.Push(braces[i]);
                }
                else if (stack.Count != 0)
                {
                    //if its a closed brace, compare with the complement and pop from stack
                    if (stack.Pop() != complement(braces[i]))
                    {
                        //invalid
                        return false;
                    }
                }
                else
                {
                    //invalid, missing brace
                    return false;
                }
            }

            if (stack.Count != 0)
            {
                //invalid, there are still some braces without match
                return false;
            }

            //valid, success
            return true;
        }

        private static char complement(char item)
        {
            switch (item)
            {
                case ')':
                    return '(';
                case '}':
                    return '{';
                case ']':
                    return '[';
                default:
                    return ' ';
            }
        }

        //this is for test. Put it on some method.
        System.Console.WriteLine("" + ValidBraces(""));//false
        System.Console.WriteLine("()" + ValidBraces("()"));//true
        System.Console.WriteLine("[(])" + ValidBraces("[(])"));//false
        System.Console.WriteLine("[()]{}" + ValidBraces("[()]{}"));//true
        System.Console.WriteLine("[({)]}" + ValidBraces("[({)]}"));//false
        System.Console.WriteLine("[[()]{}" + ValidBraces("[[()]{}"));//false

InformationsquelleAutor Alejandro del Río

in jeder situation die inneren Elemente in symmetrischen Fall sein sollte (), {} oder []

Usage  
...........................
string text = "()[][][((()))]{}";
bool isBalanced = IsBalanced(text);
...........................

Method
...........................
bool IsBalanced(string s)
{
int textCount = 0;

do
{
s = s.Replace("[]", string.Empty).Replace("{}", string.Empty).Replace("()", string.Empty);
if (textCount==s.Length)
{
return false;
}
else
{
textCount = s.Length;
}

} while (s.Length>0);

return true;
}

InformationsquelleAutor evren pehlivan

Ich würde eine queue und stack als solche

        var dictionary = new Dictionary<string, string>() {
            { "{", "}" },
            {"[", "]" },
            {"(",")" }
        };


        var par = "{()}";
        var queue = new Queue();
        var stack = new Stack();

        bool isBalanced = true;

        var size = par.ToCharArray().Length;

        if(size % 2 != 0)
        {
            isBalanced = false;
        }
        else
        {
            foreach (var c in par.ToCharArray())
            {
                stack.Push(c.ToString());
                queue.Enqueue(c.ToString());
            }

            while (stack.Count > size/2 && queue.Count > size/2)
            {
                var a = (string)queue.Dequeue();
                var b = (string)stack.Pop();

                if (dictionary.ContainsKey(a) && b != dictionary[a])
                {
                    isBalanced = false;

                }


            }


        }

        Console.WriteLine(isBalanced?"balanced!":"Not Balanced");

        Console.ReadLine();

als ein Beispiel der ersten iteration a = '{' und b ='}'

InformationsquelleAutor carlosJ

  public boolean isValid(String input) {

    Map<Character, Character> map = new HashMap<>();
        map.put('<', '>');
        map.put('{', '}');
        map.put('[', ']');
        map.put('(', ')');

     Stack<Character> stack = new Stack<>();

     for(char ch : input.toCharArray()){
         if(map.containsKey(ch)){
             stack.push(ch);
         } else if(!stack.empty() && map.get(stack.peek())==ch){
             stack.pop();
         } else {
             return false;
         }
     }
     return stack.empty();
 }

InformationsquelleAutor Ostap_87

Könnte genau dies tun...

public static Boolean isBalanced(String input){

  return Regex.Replace(input, @"[^\[\]\{\}()]", "").Replace("[]", "").Replace("{}","").Replace("()","").Length > 0 ? false : true;

}

InformationsquelleAutor J.M.Yates

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.