Programmieren lernen

// Haskell / correctParentheses.hs

// Während dem gesamten  rekursiven Funktionsaufruf wird ein Zähler geführt (n)
// Der Zähler wird am Anfang auf 0 gesetzt
// Er wird erhöht wenn eine Klamme geöffnet wird
// Wenn eine Klammer geschlossen wird, wird er dekrementiert
// Wenn der der Zähler negativ wird, wurden zu viele Klammern geschlossen --> ungültige Klammerung
// Wenn der Zähler am Schluss genau 0 ist, war die Klammerung korrekt
 
correctParentheses :: String -> Bool

correctParentheses x = (calcPar x 0) == 0

calcPar :: (Integral a) => String -> a -> a

calcPar [] n = n

// nimm das erste Element (x) und prüfe, ob es eine Klammer ist.
// wenn der Zähler negativ ist, gebe -1 zurück (ungültige Klammerung)
// Wenn x keine Klammer ist, rufe die Funktion wieder mit dem gleichen Zähler auf und dem Rest der Zeichenkette (xs)
calcPar (x:xs) n
	| n < 0    = (-1)
	| x == ')' = calcPar xs (n - 1)
	| x == '(' = calcPar xs (n + 1)
	| otherwise = calcPar xs n
                

Lösung von: Reto Hablützel (www.rethab.ch)

package ch.programmieraufgaben.strings.klammerproblem;

/**
 * Klammerproblem http://www.programmieren-lernen.ch
 * @author Philipp Gressly (phi@gressly.ch)
 */

public class Klammerproblem {
  public static void main(String[] args) {
    new Klammerproblem().top();  
  }
  
  void top() {
    teste("()", true);
    teste(")(", false);
    teste("(2 + ) ((3) - )", true);
    teste("( () ))((  )", false);
    teste(")", false);
    teste("x", true);
    teste("x(", false);
    teste("((())))", false);
  }
  
  void teste(String klammerausdruck, boolean soll) {
    int fehlerposition = fehlerpos(klammerausdruck);
    if(0 == fehlerposition && soll) {
        System.out.println(klammerausdruck + " ist OK");
    } else if(0 < fehlerposition && !soll){
        System.out.println(klammerausdruck + " wurde korrekt als fehlerhaft interpretiert");
    } else {
        System.out.println("ERROR: Der Klammeraudruck \"" + klammerausdruck + "\" wurde falsch interpretiert!! Fehler an Pos " + fehlerposition );
    }
  }
  /* Gibt 0 zurück, wenn kein Fehler auftrat. */
  /* Fällt der Klammerausdruck ins Negative,
     wird die aktuelle Position als Fehlerposition zurückgegeben.
     Ist am Schluss des Ausdrucks die Zahl offener
     Klammern nicht null, so wird die Länge des Strings
     zurückgegeben. */
  int fehlerpos(String ausdruck) {
      int aktpos      = 0; /* vor index */
      int klammerzahl = 0;
      while(aktpos < ausdruck.length()) {
          char zeichen = ausdruck.charAt(aktpos);
          if('(' == zeichen) {
              klammerzahl = klammerzahl + 1;
          }
          else if(')' == zeichen) {
              klammerzahl = klammerzahl - 1;
          }
          if(klammerzahl < 0) {
              return aktpos + 1;
          }
          aktpos = aktpos + 1;
      }
      if(0 != klammerzahl) return ausdruck.length();
      return 0;
  }
  
}  // end of class Klammerproblem
                

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

import sys
#Eingabe eines Strings. 
string = raw_input("String: ")  
# Schleife die die einzelnen Zeichen aus dem String sliced und auf ( und ) überprüft. Bei ( wird val um eins erhöht, bei ) wird val um 1 verringert.
# Wird val während der Schleife kleiner als 1, ist der String ungültig ( mehr geschlossene Klammern als offene), ist val am Ende des Programms nicht 0,
# ist der String auch ungültig ( nicht gleich viel Klammern von jeder Sorte)
val = 0  
for i in range(len(string)): 
	if string[i:i+1] == "(": 
		val +=1 
	elif string[i:i+1] == ")":
		val -=1
	if val < 0:
		print "ungueltig"
		sys.exit(1)
if val != 0:
	print "ungueltig"
else:
	print "gueltig"
                

Lösung von: Name nicht veröffentlicht

"""Prog testet, ob die Anzahl der öffnenden Klammer gleich der Anzahl der schließenden Klammer ist"""

c = input ("Gib eine Aufgabe ein: ")

klammer_auf = 0
klammer_zu = 0

for i in c:
    if i =="(":
        klammer_auf+=1
    elif i ==")":
        klammer_zu+=1

if klammer_auf == klammer_zu:
    print(c, " ist gültig")
else:
    print(c, " ist ungültig")
                

Lösung von: Py Thon ()

// Autor:				Andy Großhennig
// Solution for task:	Klammernproblem (Schleifen)

#include <iostream>
#include <string>

using namespace std;

// Function: Check the clip setting as the function counts the opened and closed clips
string checkClips(string sInput)
{
	short shClipsOpen = 0;
	short shClipsClose = 0;

	// Loop: Go through the string and counts the clips
	for(int i = 0;i < sInput.size();i++)
	{
		if(sInput[i] == '(')
			shClipsOpen++;
		if(sInput[i] == ')')
			shClipsClose++;
	}

	// If: Compares the opened clips with the closed clips and return whether the different is zero or not
	if(shClipsOpen == shClipsClose)
		return "in Ordnung.";
	else
		return "nicht in Ordnung.";
}

// Function: Get a string, trade it and shows the result
void getString()
{
	string sInput;

	cout << "Geben sie einen Text zur Ueberpruefung der Klammersetzung ein:\n";
	getline(cin, sInput);

	cout << "Die Klammersetzung ist " << checkClips(sInput) << endl;
}

int main()
{
	getString();

	cout << "\n\n";
	system("Pause");
	return 0;
}
                

Lösung von: Andy Großhennig (Bundeswehr)

inp = input("Gib die Aufgabe ein: ")
gueltig = inp.count("(") == inp.count(")")
if gueltig:
    print("Gueltige Eingabe")
else:
    print("Ungueltige Eingabe")
                

Lösung von: Karl Welzel ()

use strict;

print checkClip("5 (( +3").$/;
print checkClip("5 )) +3").$/;
print checkClip("5 ((3 -) 8 (4 +) 7)").$/;

# check brackets
sub checkClip {
my $clipcount = 0;
    while($_[0] =~ /\G(.)/g) {
    ++$clipcount if($1 eq "(");
    --$clipcount if($1 eq ")");
    }
    if($clipcount == 0){
        return("seems good!");
    }elsif($clipcount > 0){
        return("there are $clipcount open cip too much!");
    }elsif($clipcount < 0){
        return("there are @{[$clipcount*-1]} close cip too much!");
    }
}
                

Lösung von: Paul Scheinast (http://scheinast.eu)

function testBrackets(str) {
  var chksum = 0;
  for (var i = 0; i < str.length; i++) {
    if (str[i] == "(") chksum++
    if (str[i] == ")") chksum--;
    if (chksum < 0) return false;
  }
  return (chksum == 0);
}

console.log(testBrackets(prompt("Eingabe:")));
                

Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)

// C++ 17

#include <iostream>

std::string compare_parentheses(const std::string& math_problem) {
    auto c{ 0 };
    for (const auto& chr : math_problem) {
        c += chr == '(';
        c -= chr == ')';
        if (c < 0) return "ungleich - vorzeitig festgestellt";
    }
    return c == 0 ? "gleich" : "ungleich";
}

int main() {
    std::cout << compare_parentheses("5 ((3 - ) 8 (4 + ) 7)") << std::endl;
    std::cout << compare_parentheses("5 ((3 -))) 8 (4 +) 7)") << std::endl;
}
                

Lösung von: Jens Kelm (@JKooP)

' VBA

Function CompareParentheses(problem$) As Boolean
    Dim c%
    For i% = 1 To Len(problem)
        c = c + (Abs(Mid(problem, i, 1) = "("))
        c = c + (Mid(problem, i, 1) = ")")
        If c < 0 Then Exit For
    Next
    CompareParentheses = (c = 0)
End Function

Sub Main()
    p1$ = "5 ((3 - ) 8 (4 + ) 7)"
    p2$ = "5 ((3 -))) 8 (4 +) 7)"
    Debug.Print CompareParentheses(p1)
    Debug.Print CompareParentheses(p2)
End Sub
                

Lösung von: Jens Kelm (@JKooP)

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>

bool compare_parentheses(const char* math_problem, size_t size) {
    int c = 0;
    for (size_t i = 0; i < size; i++) {
        c += math_problem[i] == '(';
        c -= math_problem[i] == ')';
        if (c < 0) return false;
    }
    return c == 0;
}

const char* bool2string(bool val){
    return val ? "gleich" : "ungleich";
}

int main() {
    const char* mp[2] = { "5 ((3 - ) 8 (4 + ) 7)", "5 ((3 -))) 8 (4 +) 7)" };
    for(size_t i = 0; i < 2; i++){
        bool res = compare_parentheses(mp[i], strlen(mp[i]));
        printf("%s -> Die Anzahl der Klammern sind %s\n", mp[i], bool2string(res));
    }
    return 0;
}
                

Lösung von: Jens Kelm (@JKooP)