A-M baby

Task/Balanced-brackets/Factor/balanced-brackets.factor

@@ -0,0 +1,22 @@
+USING: io formatting locals kernel math sequences unicode.case ;
+IN: balanced-brackets
+
+:: balanced ( str -- )
+   0 :> counter!
+   1 :> ok!
+   str
+   [ dup length 0 > ]
+   [ 1 cut swap
+     "[" = [ counter 1 + counter! ] [ counter 1 - counter! ] if
+     counter 0 < [ 0 ok! ] when
+   ]
+   while
+   drop
+   ok 0 =
+   [ "NO" ]
+   [ counter 0 > [ "NO" ] [ "YES" ] if ]
+   if
+   print ;
+
+readln
+balanced

Task/Balanced-brackets/Fantom/balanced-brackets.fantom

@@ -0,0 +1,39 @@
+class Main
+{
+  static Bool matchingBrackets (Str[] brackets)
+  {
+    Int opened := 0
+    Int i := 0
+    while (i < brackets.size)
+    {
+      if (brackets[i] == "[")
+        opened += 1
+      else
+        opened -= 1
+      if (opened < 0) return false
+      i += 1
+    }
+    return true
+  }
+
+  public static Void main (Str[] args)
+  {
+    if (args.size == 1 && Int.fromStr(args[0], 10, false) != null)
+    {
+      n := Int.fromStr(args[0])
+      Str[] brackets := [,]
+      20.times
+      {
+        brackets = [,]
+        // create a random set of brackets
+        n.times { brackets.addAll (["[", "]"]) }
+        n.times { brackets.swap(Int.random(0..<2*n), Int.random(0..<2*n)) }
+        // report if matching or not
+        if (matchingBrackets(brackets))
+          echo (brackets.join(" ") + " Matching")
+        else
+          echo (brackets.join(" ") + " not matching")
+      }
+    }
+  }
+}

Task/Balanced-brackets/GAP/balanced-brackets.gap

@@ -0,0 +1,36 @@
+Balanced := function(L)
+    local c, r;
+    r := 0;
+    for c in L do
+        if c = ']' then
+            r := r - 1;
+            if r < 0 then
+                return false;
+            fi;
+        elif c = '[' then
+            r := r + 1;
+        fi;
+    od;
+    return r = 0;
+end;
+
+Balanced("");
+# true
+
+Balanced("[");
+# false
+
+Balanced("]");
+# false
+
+Balanced("[]");
+# true
+
+Balanced("][");
+# false
+
+Balanced("[[][]]");
+# true
+
+Balanced("[[[]][]]]");
+# false

Task/Balanced-brackets/Groovy/balanced-brackets-1.groovy

@@ -0,0 +1,21 @@
+def random = new Random()
+
+def factorial = { (it > 1) ? (2..it).inject(1) { i, j -> i*j } : 1 }
+
+def makePermutation;
+makePermutation = { string, i ->
+    def n = string.size()
+    if (n < 2) return string
+    def fact = factorial(n-1)
+    assert i < fact*n
+
+    def index = i.intdiv(fact)
+    string[index] + makePermutation(string[0..<index] + string[(index+1)..<n], i % fact)
+}
+
+def randomBrackets = { n ->
+    if (n == 0) return ''
+    def base = '['*n + ']'*n
+    def p = random.nextInt(factorial(n*2))
+    makePermutation(base, p)
+}

Task/Balanced-brackets/Groovy/balanced-brackets-2.groovy

@@ -0,0 +1,11 @@
+boolean balancedBrackets(String brackets, int depth=0) {
+    if (brackets == null || brackets.empty) return depth == 0
+    switch (brackets[0]) {
+        case '[':
+            return brackets.size() > 1  &&  balancedBrackets(brackets[1..-1], depth + 1)
+        case ']':
+            return depth > 0  &&  (brackets.size() == 1  ||  balancedBrackets(brackets[1..-1], depth - 1))
+        default:
+            return brackets.size() == 1  ?  depth == 0  :  balancedBrackets(brackets[1..-1], depth)
+    }
+}

Task/Balanced-brackets/Groovy/balanced-brackets-3.groovy

@@ -0,0 +1,13 @@
+Set brackets = []
+(0..100).each {
+    (0..8).each { r ->
+        brackets << randomBrackets(r)
+    }
+}
+
+brackets.sort { a, b ->
+    a.size() <=> b.size() ?: a <=> b
+} .each {
+    def bal = balancedBrackets(it) ? "balanced:   " : "unbalanced: "
+    println "${bal} ${it}"
+}

Task/Balanced-brackets/Icon/balanced-brackets.icon

@@ -0,0 +1,15 @@
+procedure main(arglist)
+every s := genbs(!arglist) do
+   write(image(s), if isbalanced(s) then " is balanced." else " is unbalanced")
+end
+
+procedure isbalanced(s) # test if a string is balanced re: []
+return (s || " ") ? (bal(,'[',']') = *s+1)
+end
+
+procedure genbs(i)  # generate strings of i pairs of []
+s := ""
+every 1 to i do s ||:= "[]"       # generate i pairs
+every !s := ?s                    # shuffle
+return s
+end

Task/Balanced-brackets/J/balanced-brackets-1.j

@@ -0,0 +1,3 @@
+bracketDepth    =:  '[]' -&(+/\)/@:(=/) ]
+checkBalanced   =:  _1 -.@e. bracketDepth
+genBracketPairs =:  (?~@# { ])@#"0 1&'[]'          NB. bracket pairs in arbitrary order

Task/Balanced-brackets/J/balanced-brackets-2.j

@@ -0,0 +1,11 @@
+   (,&' ' ,  ('bad';'OK') {::~ checkBalanced)"1 genBracketPairs i. 10
+                   OK
+][                 bad
+][[]               bad
+[[[]]]             OK
+[][[]][]           OK
+[][[[][]]]         OK
+[]][]][]][[[       bad
+[[]][[][][]][]     OK
+]]]][[][][[[[]][   bad
+[]]][][][[[[]][[]] bad

Task/Balanced-brackets/Liberty-BASIC/balanced-brackets.liberty

@@ -0,0 +1,62 @@
+print "Supplied examples"
+for i =1 to 7
+    read test$
+    print "The string '"; test$; "' is "; validString$( test$)
+next i
+print
+data "", "[]", "][","[][]","][][","[[][]]","[]][[]"
+
+print "Random generated examples"
+for example =1 to 10
+    test$ =generate$( int( 1 +10 *rnd(1)))
+    print "The string '"; test$; "' is "; validString$( test$)
+next example
+end
+
+function validString$( in$)
+    if left$( in$, 1) <>"[" and len( test$) <>0 then
+        validString$ ="not OK. Opens wrongly."
+        exit function
+    end if
+    paired =0
+    for i =1 to len( in$)
+        c$ =mid$( in$, i, 1)
+        if c$ ="[" then paired =paired +1
+        if c$ ="]" then paired =paired -1
+        if paired <0 then
+            exit for
+        end if
+    next i
+    if ( lBr =rBr) and ( paired >=0) then validString$ ="OK." else validString$ ="not OK. Unbalanced."
+end function
+
+function generate$( N)
+    lBr =0
+    rBr =0
+    '   choose at random until N of one type generated
+    while ( lBr <N) and ( rBr <N)
+        select case int( 1.5 +rnd( 1))
+            case 1
+                lBr =lBr +1
+                generate$ =generate$ +"["
+            case 2
+                rBr =rBr +1
+                generate$ =generate$ +"]"
+        end select
+    wend
+    '   now pad with the remaining other brackets
+    if lBr =N then
+        generate$ =generate$ +string$( N -rBr, "]")
+    else
+        generate$ =generate$ +string$( N -lBr, "[")
+    end if
+end function
+
+function string$( n, c$)
+    for i =1 to n
+        op$ =op$ +c$
+    next i
+    string$ =op$
+end function
+
+end

Task/Balanced-brackets/Maple/balanced-brackets-1.maple

@@ -0,0 +1,31 @@
+> use StringTools in
+>       IsBalanced( "", "[", "]" );
+>       IsBalanced( "[", "[", "]" );
+>       IsBalanced( "]", "[", "]" );
+>       IsBalanced( "[]", "[", "]" );
+>       IsBalanced( "][", "[", "]" );
+>       IsBalanced( "[][]", "[", "]" );
+>       IsBalanced( "[[][]]", "[", "]" );
+>       IsBalanced( "[[[]][]]]", "[", "]" );
+>       s := Random( 20, "[]" );
+>       IsBalanced( s, "[", "]" )
+> end use;
+                                  true
+
+                                 false
+
+                                 false
+
+                                  true
+
+                                 false
+
+                                  true
+
+                                  true
+
+                                 false
+
+                      s := "[[]][[[[[[[[[]][][]]"
+
+                                 false

Task/Balanced-brackets/Maple/balanced-brackets-2.maple

@@ -0,0 +1,2 @@
+> StringTools:-IsBalanced( "[()()]", "[(", "])" );
+                                  true

Task/Balanced-brackets/Mathematica/balanced-brackets.mathematica

@@ -0,0 +1,13 @@
+(* Generate open/close events. *)
+gen[n_] := RandomSample[Table[{1, -1}, {n}] // Flatten]
+
+(* Check balance. *)
+check[lst_] := And @@ (# >= 0 & /@ Accumulate[lst])
+
+(* Do task for string with n opening and n closing brackets. *)
+doString[n_] := (
+  lst = gen[n];
+  str = StringJoin[lst /. {1 -> "[", -1 -> "]"}];
+  Print[str <> If[match[lst, 0],
+     "  is balanced.",
+     "  is not balanced."]])

Task/Balanced-brackets/Maxima/balanced-brackets.maxima

@@ -0,0 +1,31 @@
+brack(s) := block(
+   [n: slength(s), r: 0, c],
+   catch(
+      for i thru n do (
+         if cequal(c: charat(s, i), "]") then (if (r: r - 1) < 0 then throw(false))
+         elseif cequal(c, "[") then r: r + 1
+      ),
+      is(r = 0)
+   )
+)$
+
+brack("");
+true
+
+brack("[");
+false
+
+brack("]");
+false
+
+brack("[]");
+true
+
+brack("][");
+false
+
+brack("[[][]]");
+true
+
+brack("[[[]][]]]");
+false