September Morn Update

Task/Balanced-brackets/00META.yaml

@@ -0,0 +1 @@
+--- {}

Task/Balanced-brackets/Aime/balanced-brackets.aime

@@ -1,54 +1,35 @@
-integer
 unbalanced(data s)
 {
     integer b, i;
 
-    b = 0;
-    i = 0;
-    while (i < b_length(s)) {
-        if (s[i] == '[') {
-            b += 1;
-        } else {
-            b -= 1;
-            if (b < 0) {
-                break;
-            }
-        }
-
-        i += 1;
+    b = i = 0;
+    while (i + ~s && -1 < b) {
+        b += s[i -= 1] == '[' ? -1 : 1;
     }
 
-    return b;
+    b;
 }
 
-text
-generate(integer d)
+generate(data b, integer d)
 {
-    list l;
-    data b;
-
-    l_pn_integer(l, 0, d, '[');
-    l_pn_integer(l, 0, d, ']');
-    l_rand(l);
-    l_ucall(l, b_append, 1, b);
-
-    return b;
+    if (d) {
+        d.times(l_bill, list(), -1, '[', ']').l_rand().ucall(b_append, 1, b);
+    }
 }
 
-integer
 main(void)
 {
     integer i;
 
     i = 0;
     while (i < 10) {
-        text s;
+        data s;
 
-        s = generate(i);
-        o_plan(s, " is ", unbalanced(s) ? "un" : "", "balanced\n");
+        generate(s, i);
+        o_(s, " is ", unbalanced(s) ? "un" : "", "balanced\n");
 
         i += 1;
     }
 
-    return 0;
+    0;
 }

Task/Balanced-brackets/Clojure/balanced-brackets-2.clj

@@ -0,0 +1,11 @@
+(defn balanced? [s]
+  (empty?
+    (reduce
+      (fn [stack first]
+        (case first
+          \[ (conj stack \[)
+          \] (if (seq stack)
+               (pop stack)
+               (reduced [:UNDERFLOW]))))
+      '()
+      s)))

Task/Balanced-brackets/Clojure/balanced-brackets-3.clj

@@ -0,0 +1,5 @@
+(defn balanced? [s]
+  (let [opens-closes (->> s
+                          (map {\[ 1, \] -1})
+                          (reductions + 0))]
+    (and (not-any? neg? opens-closes) (zero? (last opens-closes)))))

Task/Balanced-brackets/Common-Lisp/balanced-brackets.lisp

@@ -1,15 +1,15 @@
 (defun string-of-brackets (n)
-  (let ((result (make-string (* 2 n)))
-        (opening n)
-        (closing n))
-    (dotimes (i (* 2 n) result)
-      (setf (aref result i)
-            (cond
-              ((zerop opening) #\])
-              ((zerop closing) #\[)
-              (t (if (= (random 2) 0)
-                     (progn (decf opening) #\[)
-                     (progn (decf closing) #\]))))))))
+  (let* ((len (* 2 n))
+         (res (make-string len))
+         (opening (/ len 2))
+         (closing (/ len 2)))
+    (dotimes (i len res)
+      (setf (aref res i)
+            (cond ((zerop opening) #\])
+                  ((zerop closing) #\[)
+                  (t (if (= (random 2) 0)
+                         (progn (decf opening) #\[)
+                         (progn (decf closing) #\]))))))))
 
 (defun balancedp (string)
   (zerop (reduce (lambda (nesting bracket)

Task/Balanced-brackets/Elena/balanced-brackets.elena

@@ -1,43 +1,46 @@
-import system'routines.
-import extensions.
-import extensions'text.
+import system'routines;
+import extensions;
+import extensions'text;
 
 randomBrackets(len)
-[
+{
     if (0 == len)
-        [ ^emptyLiteral ];
-        [
-            var aBrackets :=
-                Array new(len); populate(:i)($91)
-                +
-                Array new(len); populate(:i)($93).
+    {
+        ^emptyString
+    }
+    else
+    {
+        var brackets :=
+            Array.allocate(len).populate:(i => $91)
+            +
+            Array.allocate(len).populate:(i => $93);
 
-            aBrackets := aBrackets randomize(len * 2).
+        brackets := brackets.randomize(len * 2);
 
-            ^ aBrackets summarize(StringWriter new); toLiteral
-        ]
-]
+        ^ brackets.summarize(new StringWriter()).toString()
+    }
+}
 
 extension op
 {
-    isBalanced
-    [
-        var aCounter := Integer new:0.
+    get isBalanced()
+    {
+        var counter := new Integer(0);
 
-        self seekEach(:aChar)(aCounter append((aChar==$91)iif (1,-1)) < 0).
+        self.seekEach:(ch => counter.append((ch==$91).iif(1,-1)) < 0);
 
-        ^ (0 == aCounter)
-    ]
+        ^ (0 == counter)
+    }
 }
 
-public program
-[
-    0 to:9 do(:len)
-    [
-        var str:= randomBrackets(len).
+public program()
+{
+    for(int len := 0, len < 9, len += 1)
+    {
+        var str := randomBrackets(len);
 
-        console printLine("""",str,"""",str isBalanced; iif(" is balanced"," is not balanced"))
-    ].
+        console.printLine("""",str,"""",str.isBalanced ? " is balanced" : " is not balanced")
+    };
 
-    console readChar
-]
+    console.readChar()
+}

Task/Balanced-brackets/Mercury/balanced-brackets.mercury

@@ -0,0 +1,40 @@
+:- module balancedbrackets.
+:- interface.
+
+:- import_module io.
+
+:- pred main(io::di, io::uo) is det.
+
+
+:- import_module list, random, char.
+
+:- pred brackets(int::in,list(char)::out,supply::mdi,supply::muo) is det.
+
+:- pred imbalance(list(char)::in,int::out) is semidet.
+:- pred balanced(list(char)::in) is semidet.
+
+:- implementation.
+
+:- import_module int.
+
+imbalance([],0).
+imbalance(['['|T],N) :- imbalance(T,N+1).
+imbalance([']'|T],N) :- N > 0, imbalance(T,N-1).
+
+balanced(S) :- imbalance(S,0).
+
+brackets(N,S,!RS) :-
+    (
+	N < 1 -> S is []
+    ;   random(0,2,R,!RS),
+	( R is 0 -> S is ['['|T], brackets(N-1,T,!RS)
+	; S is [']'|T], brackets(N-1,T,!RS))).
+
+main(!IO) :-
+    random.init(0,RS),
+    brackets(4,S,RS,_),
+    print(S,!IO),
+    (
+	balanced(S) -> print(" is balanced\n",!IO)
+    ;   print(" is unbalanced\n", !IO)
+    ).

Task/Balanced-brackets/Simula/balanced-brackets.simula

@@ -0,0 +1,46 @@
+BEGIN
+    INTEGER U;
+    U := ININT;
+    BEGIN
+
+        TEXT PROCEDURE GENERATE(N); INTEGER N;
+        BEGIN
+            INTEGER R;
+            TEXT T;
+            T :- NOTEXT;
+            WHILE N > 0 DO BEGIN
+                R := RANDINT(1,2,U);
+                T :- T & (IF R = 1 THEN "[" ELSE "]");
+                N := N - 1;
+            END;
+            GENERATE :- T;
+        END GENERATE;
+
+        BOOLEAN PROCEDURE BALANCED(T); TEXT T;
+        BEGIN
+            INTEGER LEVEL;
+            CHARACTER BRACE;
+            BOOLEAN DONE;
+            T.SETPOS(1);
+            WHILE T.MORE AND NOT DONE DO BEGIN
+                BRACE := T.GETCHAR;
+                IF BRACE = '[' THEN LEVEL := LEVEL + 1;
+                IF BRACE = ']' THEN LEVEL := LEVEL - 1;
+                IF LEVEL < 0 THEN DONE := TRUE;
+            END;
+            BALANCED := LEVEL = 0;
+        END BALANCED;
+
+        INTEGER I,M;
+        TEXT T;
+        FOR I := 1 STEP 1 UNTIL 40 DO BEGIN
+            M := RANDINT(0,10,U);
+            T :- GENERATE(M);
+            IF BALANCED(T) THEN OUTTEXT("    ") ELSE OUTTEXT(" NOT");
+            OUTTEXT(" BALANCED: ");
+            OUTTEXT(T);
+            OUTIMAGE;
+        END;
+
+    END;
+END