Balanced brackets: Difference between revisions

=={{header|11l}}==

{{trans|Python}}

V txt = [‘[’, ‘]’] * n

random:shuffle(&txt)

L(n) 0..9

V s = gen(n)

{{out}}

<pre>

 

=={{header|360 Assembly}}==

BALANCE CSECT

USING BALANCE,R13 base register and savearea pointer

XDEC DS CL12

REGS

{{out}}

<pre>

 

=={{header|ABAP}}==

CLASS lcl_balanced_brackets DEFINITION.

PUBLIC SECTION.

cl_demo_output=>display( ).

 

 

{{out}}

 

=={{header|Action!}}==

BYTE i,half

 

PrintE("balanced")

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Balanced_brackets.png Screenshot from Atari 8-bit computer]

Using #HASH-OFF

</pre>

FUNCTION bBRACKETS_MATCH(zStringWithBrackets: STRING): STRING

VAR sCount: SHORT

RETURN zOK

ENDFUNCTION

{{out}}

<pre>

=={{header|Ada}}==

brackets.adb:

with Ada.Text_IO;

with Ada.Strings.Fixed;

end loop;

end loop;

 

Output:

 

=={{header|Aime}}==

{

integer b, i;

 

0;

Sample output:

<pre> is balanced

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release 2.8.win32}}

# each type of brackets is speccified in length #

PROC get brackets = ( INT length ) STRING:

test check brackets( get brackets( length ) )

OD

{{out}}

<pre>

<br clear=both>

==={{header|Java}}===

grammar balancedBrackets ;

 

NEWLINE : '\r'? '\n'

;

Produces:

<pre>

and a function to check whether a given string of brackets is balanced.

 

 

Sample run for 0..N..10:

 

: Good

[]: Good

[[][[]]][[[[]]]]: Good

[[[]][[[[][]][]]]]: Good

 

=={{header|AppleScript}}==

(ES6 functionally composed version)

 

 

-- Zero-based index of the first problem (-1 if none found):

end script

end if

'''Sample output:'''

<pre>'][' problem

 

=={{header|ARM Assembly}}==

.data

 

mov pc, lr

 

 

=={{header|Arturo}}==

cnt: 0

if? isBalanced str -> print " OK"

else -> print " Not OK"

 

{{out}}

 

=={{header|AutoHotkey}}==

Loop, 5

{

}

Return "OK"

Output:

<pre>

 

A second example repeatedly replacing []:

{

B = %A_Index%

StringReplace, Str, Str,[],,All

Return Str ? "False" : "True"

Sample output:

<pre>

 

=={{header|AutoIt}}==

#include <Array.au3>

Local $Array[1]

Return 1

EndFunc

 

=={{header|AWK}}==

BEGIN {

print isbb("[]")

return (s==0)

}

Output:

<pre>1

 

=={{header|BaCon}}==

 

str$ = ""

PRINT "BAD: ", str$

ENDIF

{{out}}

<pre>OK:

{{works with|QBasic}}

 

DECLARE FUNCTION generator$ (length AS INTEGER)

 

NEXT

generator$ = xx$

 

Sample output:

==={{header|Commodore BASIC}}===

Based on ZX Spectrum BASIC implementation

20 FOR N=1 TO 7

30 READ S$

1090 PRINT "NOT OK"

1100 RETURN

 

 

=={{header|BASIC256}}==

{{trans|Yabasic}}

print s$; " = ";

 

next i

return level = 0

 

 

=={{header|Batch File}}==

Uses the rewrite rule <code>"[]" -> null</code> to check if brackets are balanced.

:: Batch File Implementation

set "old=%new%"

set "new=%old:[]=%"

{{out}}

<pre>[][][[[[]]][]]]][[][ is NOT Balanced.

 

=={{header|BBC BASIC}}==

test$=FNgenerate(RND(10))

PRINT "Bracket string ";test$;" is ";FNvalid(test$)

IF count%<0 THEN ="not OK."

NEXT x%

<pre>Bracket string [[[][]]] is OK.

Bracket string [[[]][[[][[][]]]]] is OK.

{{works with|befungee}}

This code implements the second part of the task: it reads from standard input an arbitrary string of opening and closing brackets, and checks whether it's balanced or not.

> ~ : 25*- #v_ $ | > 25*, @

> "KO" ,, ^

> \ : 1991+*+- #v_v

\ $

 

=={{header|BQN}}==

This allows for a particular simple implementation:

 

Bal ← {

Mul ← {a‿b𝕊x‿y: ⟨a+0⌈x-b, y+0⌈b-x⟩}

0‿0 ≡ 0‿0("]["⊸=⊸Mul)´𝕩

 

{{out}}

=={{header|Bracmat}}==

Bracmat has no 'random' function, so the shuffle is a bit improvised. A variable <code>someNumber</code> is initialised with a big number is repeatedly divided by the number of '['s in the test string until zero. The remainders are used as index to partition and swap the first half of the test string. Then the second half and first half are also swapped. The test whether the test string is balanced is simple, but not very efficient.

& ( generate

= a j m n z N S someNumber

& !L+1:<11:?L

)

Output:

<pre>:Balanced

 

=={{header|Brat}}==

brackets = []

balanced = true

{ p "#{test} is balanced" }

{ p "#{test} is not balanced" }

 

Output:

 

=={{header|C}}==

#include<stdlib.h>

#include<string.h>

while(n<9) doSeq(n++);

return 0;

'[]': True

']][[': False

']]]][[[]][[[': False

']]]]]][][[[[[[': False

 

=={{header|C sharp|C#}}==

using System.Linq;

 

}

}

Sample output:

<pre>"" is balanced.

"[]]][][]][[][[" is not balanced.

"[]]][]]][[][[][[" is not balanced.</pre>

// simple solution

string input = Console.ReadLine();

Console.WriteLine("Not Okay");

 

 

=={{header|C++}}==

#include <iostream>

#include <string>

std::cout << (balanced(s) ? " ok: " : "bad: ") << s << "\n";

}

Output:

<pre> ok:

 

=={{header|Ceylon}}==

platformRandom,

Random

ints.filter((i) => i != 0)

.scan(0)(plus<Integer>)

 

Output:

 

=={{header|Clojure}}==

(->> (concat (repeat n \[) (repeat n \]))

shuffle

(when (= (peek stack) \[)

(recur coll (pop stack))))

 

There are other ways to express the <code>balanced?</code> function.

 

* We can use <code>reduce</code> to consume the sequence:

(empty?

(reduce

(reduced [:UNDERFLOW]))))

'()

 

* Only <code>[</code>s are put on the stack. We can just count the unmatched ones.

(let [opens-closes (->> s

(map {\[ 1, \] -1})

(reductions + 0))]

 

Output:

 

=={{header|CLU}}==

% "misc.lib" that comes with PCLU.

 

end

end

{{out}}

<pre>"": balanced

=={{header|COBOL}}==

{{works with|OpenCOBOL}}

PROGRAM-ID. test-balanced-brackets.

 

.

 

 

=={{header|CoffeeScript}}==

isBalanced = (brackets) ->

openCount = 0

for brackets in bracketsCombinations 4

console.log brackets, isBalanced brackets

output

> coffee balanced.coffee

[[[[ false

]]][ false

]]]] false

 

=={{header|Common Lisp}}==

(defun string-of-brackets (n)

(let* ((len (* 2 n))

(let ((s (string-of-brackets i)))

(format t "~3A: ~A~%" (balancedp s) s))))

 

Output:

=={{header|Component Pascal}}==

BlackBox Component Builder

MODULE Brackets;

IMPORT StdLog, Args, Stacks (* See Task Stacks *);

 

END Brackets.

Execute: ^Q Brackets.Do [] [][] [[][]] ][ ][][ []][[]~<br/>

Output:

 

=={{header|Crystal}}==

(['[',']'] * n).shuffle.join # Implicit return

end

str = generate(i)

puts "#{str}: #{is_balanced(str)}"

 

Output:

===Standard Version===

D standard library has a [http://www.digitalmars.com/d/2.0/phobos/std_algorithm.html#balancedParens function] for this.

 

void main() {

writeln(s.balancedParens('[', ']') ? " OK: " : "bad: ", s);

}

{{out}}

<pre> OK: []

===Imperative Version===

{{trans|Raku}}

 

bool isBalanced(in string txt) pure nothrow {

writeln(s.isBalanced ? " OK " : "Bad ", s);

}

The output is similar.

 

===Functional Style===

{{trans|Haskell}}

 

bool isBalanced(in string s, in char[2] pars="[]") pure nothrow @safe @nogc {

writeln(s.isBalanced ? " OK " : "Bad ", s);

}

 

=={{header|Delphi}}==

 

 

var BracketsStr : string;

writeln(BracketsStr+': not OK');

end;

 

<pre>

 

=={{header|Déjà Vu}}==

swap 0

for c in chars:

!. matching? "]["

!. matching? "][]["

{{out}}

<pre>true

 

=={{header|EchoLisp}}==

(define (balance str)

(for/fold (closed 0) ((par str))

❌ "[[][]]]["

 

=={{header|Elena}}==

ELENA 4.x :

import extensions;

import extensions'text;

 

console.readChar()

{{out}}

<pre>

{{trans|Erlang}}

{{works with|Elixir|1.1}}

def task do

Enum.each(0..5, fn n ->

end

 

 

{{out}}

 

=={{header|Erlang}}==

-module( balanced_brackets ).

-export( [generate/1, is_balanced/1, task/0] ).

task_balanced( true ) -> "OK";

task_balanced( false ) -> "NOT OK".

{{out}}

<pre>

 

=={{header|Euphoria}}==

integer level

level = 0

puts(1," NOT OK\n")

end if

 

Sample output:

 

{{Works with|Office 365 betas 2021}}

=LAMBDA(bracketPair,

LAMBDA(s,

)

)

 

and also assuming the following generic bindings in the Name Manager for the WorkBook:

 

=LAMBDA(xs,

LAMBDA(ys,

)

)

 

{{Out}}

 

=={{header|F_Sharp|F#}}==

let rec loop count = function

| ']'::_ when count = 0 -> false

for n in 1..10 do

let s = generate n

 

Output:

=={{header|Factor}}==

This code implements the second part of the task: it reads from standard input an arbitrary string of opening and closing brackets, and checks whether it's balanced or not.

IN: balanced-brackets

 

 

readln

 

Some more idiomatic solution might be as follows:

 

IN: balanced-brackets

 

-- Data stack:

t

 

=={{header|Fantom}}==

 

class Main

{

}

}

 

Output (for n=3):

=={{header|Forth}}==

{{works with|4tH|3.61.1}}

include lib/ctos.4th ( n -- a 1)

 

; \ evaluate string and print result

 

'''Examples''':<pre>[][[]] OK

[[[[]][[ NOT OK

=={{header|Fortran}}==

Please see the compilation and program execution result as comments at the top of this source:

! $ gfortran -g -O0 -std=f2008 -Wall f.f08 -o f.exe

! $ ./f

end subroutine generate

end program balanced_brackets

 

=={{header|FreeBASIC}}==

 

Function isBalanced(s As String) As Boolean

Print

Print "Press any key to quit"

Sample output (last 7 lines random) :

{{out}}

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=8960fb267af43f0549d2cfe04288a2d4 Click this link to run this code]'''

 

siNumberOfBrackets As Short = 20 'Maximum amount of brackets in a line

Return sBrk 'Return the sBrk array

 

Output:

<pre>

 

=={{header|GAP}}==

local c, r;

r := 0;

 

Balanced("[[[]][]]]");

 

=={{header|Go}}==

 

import (

}

testBalanced("()")

Output:

<pre>

=={{header|Groovy}}==

Generate Arbitrary String of Bracket Pairs:

 

def factorial = { (it > 1) ? (2..it).inject(1) { i, j -> i*j } : 1 }

def p = random.nextInt(factorial(n*2))

makePermutation(base, p)

 

Check Balance of Bracket String:

if (brackets == null || brackets.empty) return depth == 0

switch (brackets[0]) {

return brackets.size() == 1 ? depth == 0 : balancedBrackets(brackets[1..-1], depth)

}

 

Test:

(0..100).each {

(0..8).each { r ->

def bal = balancedBrackets(it) ? "balanced: " : "unbalanced: "

println "${bal} ${it}"

 

Output:

=={{header|Haskell}}==

The simplest solution exploits the idea of stack-based automaton, which could be implemented by a fold.

isMatching :: String -> Bool

isMatching = null . foldl aut []

-- aut ('{':s) '}' = s -- automaton could be extended

aut s x = x:s

 

This generates an infinite stream of correct balanced brackets expressions:

 

<pre>λ> take 10 brackets

["[]","{}","[[]]","[][]","[]{}","[{}]","{[]}","{{}}","{}[]","{}{}"]</pre>

In case the index of unmatched opening bracket is need to be found, following solution is suitable.

 

import Control.Monad

import System.Random

let bs = cycle "[]"

rs <- replicateM 10 newStdGen

We put our list shuffling function in a separate module. For efficiency we use ''mutable'' vectors, although for the short lists in our example it doesn't really matter.

( shuffle

) where

do v <- V.unsafeThaw $ V.fromList xs

mapM_ (uncurry $ M.swap v) $ pairs 0 (M.length v - 1) r

Here's some sample output.

<pre>

and '''scanl''' also yields a simple fit when we want the index of the tipping point:

 

import Data.List (findIndex, replicate, scanl)

import Data.List.Split (chunksOf)

bracket :: Int -> Char

bracket 0 = '['

{{Out}}

<pre>]][]][: Unmatched

 

=={{header|Icon}} and {{header|Unicon}}==

every s := genbs(!arglist) do

write(image(s), if isbalanced(s) then " is balanced." else " is unbalanced")

every !s := ?s # shuffle

return s

 

Output:<pre>

 

=={{header|J}}==

checkBalanced =: _1 -.@e. bracketDepth

OK

][ bad

[[]][[][][]][] OK

]]]][[][][[[[]][ bad

'''Comments''': This task highlights the versatility and usefulness of J's scanning modifiers, <code>/</code> and <code>\</code>.

 

=={{header|Java}}==

{{works with|Java|1.5+}}

 

public static boolean hasBalancedBrackets(String str) {

}

}

Sample output (generate uses random numbers, so it should not be the same every time):

<pre>: true

 

=== Extended ===

import java.util.Deque;

 

}

}

{{out}}

<pre>With areSquareBracketsBalanced:

====Iterative====

 

var a = str.split(''), b, c = a.length, d

while (c) b = Math.random() * c-- | 0, d = a[c], a[c] = a[b], a[b] = d

var N = Math.random() * 10 | 0, bs = shuffle('['.repeat(N) + ']'.repeat(N))

console.log('"' + bs + '" is ' + (isBalanced(bs) ? '' : 'un') + 'balanced')

 

Sample output:

==== Another solution ====

{{works with|Node.js}}

console.log("Supplied examples");

var tests = ["", "[]", "][", "[][]", "][][", "[[][]]", "[]][[]"];

return generated;

}

{{out}}

<pre>

====Functional====

With visual indication of where the balance fails:

'use strict';

 

// ---

return main();

{{Out}}

<pre>'' OK

 

=={{header|Julia}}==

 

function balancedbrackets(str::AbstractString)

for (test, pass) in map(x -> (x, balancedbrackets(x)), collect(brackets(i) for i = 0:8))

@printf("%22s%10s\n", test, pass ? "pass" : "fail")

 

{{out}}

 

'''One-line version''':

 

=={{header|K}}==

gen_brackets:{"[]"@x _draw 2}

check:{r:(-1;1)@"["=x; *(0=+/cs<'0)&(0=-1#cs:+\r)}

("][[][[]]][[]]]][][";0)

("]][[[[]]]][][][[]]]]";0))

 

=={{header|Klingphix}}==

 

%acc 0 !acc

print

 

 

=={{header|Kotlin}}==

{{trans|FreeBASIC}}

 

fun isBalanced(s: String): Boolean {

println("$s " + if (isBalanced(s)) "OK" else "NOT OK")

}

Sample output (last 7 lines random) :

{{out}}

 

=={{header|L++}}==

(defn bool balanced (std::string s)

(pr std::boolalpha)

(foreach x tests

 

=={{header|Lasso}}==

local(out) = array

 

with i in 1 to 10

let input = randomparens(#i)

 

{{out}}

 

=={{header|Liberty BASIC}}==

print "Supplied examples"

for i =1 to 7

 

end

Supplied examples

The string '' is OK.

 

=={{header|Lua}}==

function isBalanced(s)

--Lua pattern matching has a 'balanced' pattern that matches sets of balanced characters.

print(RS)

print(isBalanced(RS))

 

=={{header|Maple}}==

This functionality is provided by Maple.

> use StringTools in

> IsBalanced( "", "[", "]" );

 

false

Furthermore, Maple can check whether multiple fences are balanced in the same string.

> StringTools:-IsBalanced( "[()()]", "[(", "])" );

true

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

gen[n_] := RandomSample[Table[{1, -1}, {n}] // Flatten]

 

Print[str <> If[match[lst, 0],

" is balanced.",

 

=={{header|MATLAB}} / {{header|Octave}}==

t = cumsum((s=='[') - (s==']'));

x = all(t>=0) && (t(end)==0);

end;

Output:

<pre>

 

=={{header|Maxima}}==

[n: slength(s), r: 0, c],

catch(

 

brack("[[[]][]]]");

 

=={{header|Mercury}}==

:- module balancedbrackets.

:- interface.

; print(" is unbalanced\n", !IO)

).

 

=={{header|MiniScript}}==

We start by defining a function:

 

level = 0

for c in str

end for

return level == 0

 

We can evaluate the example strings with this code:

 

"",

"[]",

if balanced then outcome = "is OK" else outcome = "NOT OK"

print """" + str + """ " + outcome

 

{{out}}

{{works with|TopSpeed (JPI) Modula-2 under DOSBox-X}}

An interesting point is how to ensure that all strings of N left plus N right brackets are equally likely. The program below shows one way of doing this.

MODULE Brackets;

IMPORT IO, Lib;

END;

END Brackets.

{{out}}

<pre>

=={{header|Nanoquery}}==

{{trans|Python}}

 

def gen(N)

println format("%-22s is not balanced", txt)

end

{{out}}

<pre> is balanced

 

=={{header|Nim}}==

from random import random, randomize, shuffle

from strutils import repeat

for n in 0..9:

let s = gen(n)

Output:

<pre>'' is balanced

=={{header|Oberon-2}}==

{{works with|oo2c version 2}}

MODULE BalancedBrackets;

IMPORT

Do

END BalancedBrackets.

{{out}}

<pre>

 

=={{header|Objeck}}==

bundle Default {

class Balanced {

}

}

<pre>

: true

=={{header|OCaml}}==

 

let rec aux i acc =

if i <= 0 then acc else

List.iter print_char brk;

Printf.printf " %B\n" (is_balanced brk);

 

<pre>

=={{header|Oforth}}==

 

| c |

0 self forEach: c [

: genBrackets(n)

 

{{out}}

 

=={{header|ooRexx}}==

tests = .array~of("", "[]", "][", "[][]", "][][", "[[][]]", "[]][[]")

 

end

return answer~string

Sample output (uses randomly generated groupings, so it should be different on each run):

<pre>

 

=={{header|OxygenBasic}}==

'=======================================

sys co, le=len s

print CheckBrackets "[][]"'1

print CheckBrackets "][" '0

 

=={{header|PARI/GP}}==

my(n=0,v=Vecsmall(s));

for(i=1,#v,

};

rnd(n)=Strchr(vectorsmall(n,i,if(random(2),91,93)))

 

=={{header|Pascal}}==

Idiomatic solution, using a regex that performs subpattern recursion ''(works with Perl 5.10 and newer)'':

 

my $n = shift;

my $str = '[' x $n;

my $input = generate($_);

print balanced($input) ? " ok:" : "bad:", " '$input'\n";

 

{{out}}

If input strings are allowed to contain unrelated characters, this can be extended to:

 

shift =~ /^ ( [^\[\]]++ | \[ (?1)* \] )* $/x;

 

<code>Regexp::Common::balanced</code> can give such a regexp too (non-bracket chars allowed). Its recent versions use the subpattern recursion and are hence also only for Perl 5.10 and up.

 

my $re = qr/^$RE{balanced}{-parens=>'[]'}$/;

sub balanced {

return shift =~ $re;

 

Alternative implementation, using straightforward depth counting:

 

my $depth = 0;

for (split //, shift) {

}

return !$depth

 

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">check_brackets</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre>

 

=={{header|Phixmonti}}==

0 var acc

 

" is OK"

endif

 

=={{header|PHP}}==

The sample is given as unix shell script, you need to have ''php-cli'' (or what your package manager calls it) installed.

 

<?php

 

printf("%s\t%s%s", $s, printbool(isbalanced($s)), PHP_EOL);

}

Sample run:

<pre>

=={{header|Picat}}==

===Foreach loop===

tests(Tests),

member(Test,Tests),

"][][", "[]][[]", "[][][][][][][][][][]",

"[[[[[[[]]]]]]]", "[[[[[[[]]]]]]",

 

{{out}}

===DCG===

Here is an implementation using DCG (Definite Clause Grammars).

tests(Tests),

foreach(Test in Tests)

 

balanced --> "".

 

=={{header|PicoLisp}}==

 

(de generateBrackets (N)

 

(for N 10

Output:

<pre>[] OK

 

=={{header|PL/I}}==

cb: Proc Options(main);

/* PL/I program to check for balanced brackets [] ********************

End;

 

Output:

<pre> balanced ''

=={{header|PowerShell}}==

{{works with|PowerShell|2}}

function Get-BalanceStatus ( $String )

{

return $Status

}

# Test

$Strings = @( "" )

$String.PadRight( 12, " " ) + (Get-BalanceStatus $String)

}

{{out}}

<pre>

 

===PowerShell (Regex Version)===

function Test-BalancedBracket

{

"{0}: {1}" -f $s.PadRight(8), "$(if (Test-BalancedBracket Brace $s) {'Is balanced.'} else {'Is not balanced.'})"

}

{{Out}}

<pre>

=={{header|Prolog}}==

DCG are very usefull for this kind of exercice !

test_brackets([]),

test_brackets(['[',']']),

bracket(0) --> ['['].

bracket(1) --> [']'].

Sample output :

<pre> ?- balanced_brackets.

 

=={{header|PureBasic}}==

For i=1 To N

sample$+"[]"

PrintN(" is not balanced")

EndIf

Output sample

<pre>

=={{header|Python}}==

===Procedural===

... txt = ['[', ']'] * N

... random.shuffle( txt )

'[[]]]]][]][[[[' is not balanced

'[[[[]][]]][[][]]' is balanced

 

=== Functional ===

Rather than explicitly track the count, we can just write the per-element test and use stdlib functions to turn it into a whole-sequence test. It's straightforwardly declarative, and hard to get wrong, but whether it's actually easier to understand depends on how familiar the reader is with thinking in `itertools` style.

 

>>> from random import shuffle

>>> def gen(n):

'][]][][[]][[][' is not balanced

'][[]]][][[]][[[]' is not balanced

 

=== Array Programming ===

The numpy library gives us a way to write just the elementwise tests and automatically turn them into whole-sequence tests, although it can be a bit clumsy to use for character rather than numeric operations. The simplicity of the final expression probably doesn't make up for all that extra clumsiness in this case.

 

>>> from random import shuffle

>>> def gen(n):

'[][[[]][[]]][]' is balanced

'[[][][[]]][[[]]]' is balanced

 

=={{header|Qi}}==

 

[] 0 -> true

[] _ -> false

(balanced-brackets "[]][[]")

 

 

=={{header|Quackery}}==

 

swap

char ] swap of

[ say "un" ]

say "balanced."

 

{{out}}

=={{header|R}}==

 

str <- strsplit(str, "")[[1]]

str <- ifelse(str=='[', 1, -1)

all(cumsum(str) >= 0) && sum(str) == 0

 

Alternately, using perl 5.10-compatible regexps,

 

regexpr('^(\\[(?1)*\\])*$', str, perl=TRUE) > -1

 

To generate some some examples:

 

 

as.data.frame(within(list(), {

parens <- replicate(10, rand.parens(sample.int(10,size=1)))

balanced <- sapply(parens, balanced)

 

Output:

1 FALSE ][][

2 FALSE [][[]]][[]][]]][[[

8 FALSE []]]][[[]][[[]

9 TRUE [[[[][[][]]]]]

 

=={{header|Racket}}==

 

#lang racket

 

 

(for ([n 10]) (try n))

 

=={{header|Raku}}==

{{works with|Rakudo|2015.12}}

 

my $l = 0;

for $s.comb {

my $n = prompt "Number of brackets";

my $s = (<[ ]> xx $n).flat.pick(*).join;

 

===FP oriented===

Here's a more idiomatic solution using a hyperoperator to compare all the characters to a backslash (which is between the brackets in ASCII), a triangle reduction to return the running sum, a <tt>given</tt> to make that list the topic, and then a topicalized junction and a topicalized subscript to test the criteria for balance.

.none < 0 and .[*-1] == 0

given ([\+] '\\' «leg« $s.comb).cache;

my $n = prompt "Number of bracket pairs: ";

my $s = <[ ]>.roll($n*2).join;

 

===String munging===

Of course, a Perl 5 programmer might just remove as many inner balanced pairs as possible and then see what's left.

{{works with|Rakudo|2015.12}}

Nil while s:g/'[]'//;

$_ eq '';

my $n = prompt "Number of bracket pairs: ";

my $s = <[ ]>.roll($n*2).join;

 

===Parsing with a grammar===

{{works with|Rakudo|2015.12}}

 

my $n = prompt "Number of bracket pairs: ";

my $s = ('[' xx $n, ']' xx $n).flat.pick(*).join;

 

=={{header|Red}}==

balanced-brackets: [#"[" any balanced-brackets #"]"]

rule: [any balanced-brackets end]

str: random copy/part "[][][][][][][][][][]" i * 2

print [mold str "is" either balanced? str ["balanced"]["unbalanced"]]

 

=={{header|REXX}}==

===with 40 examples===

parse arg seed . /*obtain optional argument from the CL.*/

if datatype(seed,'W') then call random ,,seed /*if specified, then use as RANDOM seed*/

else do; !=!-1; if !<0 then return 0; end

end /*j*/

'''output''' &nbsp; using the (some internal, others random) expressions:

<pre>

 

===with examples + 30 permutations===

/*REXX program to check for balanced brackets [] **********************

* test strings and random string generation copied from Version 1

end

return nest=0 /* nest=0 -> balanced */

{{out}}

<pre>

Naturally, each of the one hundred thousand character strings aren't displayed (for balanced/not-balanced),

<br>but a count is displayed, as anyone can generate the same strings in other languages and compare results.

bals=0

#=0; do j=1 until L>20 /*generate lots of bracket permutations*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

countStr: procedure; parse arg n,h,s; if s=='' then s=1; w=length(n)

'''output''' &nbsp; when using the default input:

<pre>

 

=={{header|Ring}}==

nr = 0

while nr < 10

next

return "ok."

Output:

<pre>

{{trans|D}}

{{works with|Ruby|1.9}}

(?<bb> # begin capture group <bb>

\[ # literal [

t = s.gsub(/[^\[\]]/, "")

puts (t =~ re ? " OK: " : "bad: ") + s

 

One output: <pre>

 

=={{header|Run BASIC}}==

brk$(1) = "[[[][]]]"

brk$(2) = "[[[]][[[][[][]]]]]"

if trim$(b$) = "" then print " OK "; else print "Not OK ";

print brk$(i)

 

One output: <pre> OK

 

{{libheader|rand}}

 

trait Balanced {

println!("{} {}", brackets, brackets.is_balanced())

}

Output: <pre>

true

=== Scala Version 1 ===

{{works with|Scala|2.9.1}}

import scala.util.Random

 

println("\n"+"check all permutations of given length:")

(1 to 5).map(generate(_)).flatten.map(s=>Pair(s,checkBalance(s))).foreach(p=>println((if(p._2) "balanced: " else "unbalanced: ")+p._1))

 

<pre style="height:30ex;overflow:scroll">arbitrary random order:

=== Scala Version 2 ===

{{works with|Scala|2.10.1}}

 

object BalancedBracketsApp extends App {

}

 

 

Alternate implementation of "isBalanced" using tail-recursion instead of var and return:

 

import scala.annotation.tailrec

 

isBalanced(rest, newBalance)

}

 

Slightly modified implementation of "isBalanced" using tail-recursion

{{works with|Scala|2.11.7}}

@scala.annotation.tailrec

final def isBalanced(

}

}

 

Sample output:

 

=={{header|Scheme}}==

(define (b chars sum)

(cond ((< sum 0)

(balanced-brackets "][][")

(balanced-brackets "[]][[]")

 

=={{header|Scilab}}==

{{trans|MATLAB}}

st=strsplit(s);

t=cumsum((st=='[')-(st==']'));

balanced=and(t>=0) & t(length(t))==0;

varargout=list(balanced)

{{out}}

The following code was used to generate random strings of length 5, 16, and 22 chars. It also displays the generated string, and the output (true of false) of <code>isbb()</code>.

s=[];

for i=1:j

x=isbb(s);

disp(x);

Console output:

<pre> ][]][

 

=={{header|Seed7}}==

 

const func string: generateBrackets (in integer: count) is func

end for;

end for;

 

Output:

 

=={{header|Sidef}}==

 

var depth = 0

for str [']','[','[[]','][]','[[]]','[[]]]][][]]','x[ y [ [] z ]][ 1 ][]abcd'] {

printf("%sbalanced\t: %s\n", balanced(str) ? "" : "NOT ", str)

 

{{out}}

 

=={{header|Simula}}==

INTEGER U;

U := ININT;

 

END;

{{in}}

<pre>710</pre>

{{works with|PolyML}}

 

and checkBrackets 0 [] = true

| checkBrackets _ [] = false

| checkBrackets counter (#"["::rest) = checkBrackets (counter + 1) rest

| checkBrackets counter (#"]"::rest) = checkBrackets (counter - 1) rest

 

An example of usage

 

List.app print

(List.map

(* A set of strings to test *)

["", "[]", "[][]", "[[][]]", "][", "][][", "[]][[]"]

 

Output:

=={{header|Stata}}==

 

function random_brackets(n) {

return(invtokens(("[","]")[runiformint(1,2*n,1,2)],""))

return(all(a:>=0) & a[n]==0)

}

 

'''Test'''

Checks balance function:

 

 

func isBal(str: String) -> Bool {

}

isBal("[[[]]]") // true

 

isBal("[]][[]") // false

 

 

func randBrack(n: Int) -> String {

}

 

 

randBrack(2) // "]][["

 

 

func randIsBal(n: Int) {

randIsBal(4)

 

 

// ][ is unbalanced

// []][[] is unbalanced

//

 

=={{header|Tcl}}==

if {!$n} return

set l [lrepeat $n "\[" "\]"]

set s [generate $i]

puts "\"$s\"\t-> [expr {[balanced $s] ? {OK} : {NOT OK}}]"

Sample output:

<pre>

===Constructing correctly balanced strings===

It is, of course, possible to directly construct such a balanced string, this being much more useful as the length of the string to generate grows longer. This is done by conceptually building a random tree (or forest) and then walking the tree, with open brackets being appended when a node is entered from its root and close brackets being appended when a node is left for its root. This is equivalent to inserting a balanced pair of brackets at a random place in an initially-empty string <math>n</math> times, which might be done like this:

set s ""

for {set i 0} {$i < $n} {incr i} {

}

return $s

As noted, because the generated string is guaranteed to be balanced, it requires no further filtering and this results in much more efficient generation of balanced strings at longer lengths (because there's no need to backtrack).

 

 

Generation program in Unix TMG:

loop: parse(render) [--n>0?]/done loop;

render: random(i, 15) [i = (i+1)*2] loop2 = { 1 * };

>>;

 

 

Sample output:

 

Analysis can be done easily using grammar specification, rather than counting brackets:

corr: brkts * = { < OK: > 1 * };

brkts: brkt/null brkts = { 2 1 };

 

nonl: !<<

 

Sample output:

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

 

PRINT b," ",status

ENDLOOP

Output:

<pre>

=={{header|TXR}}==

 

@(do (defvar r (make-random-state nil))

 

@{parens 15} @{matched 15} @{mismatched 15}

@ (end)

 

The recursive pattern function <code>@(paren)</code> gives rise to a grammar which matches parentheses:

== {{header|TypeScript}} ==

{{trans|JavaScript}}

 

function isStringBalanced(str: string): bool {

console.log(`The string '${test}' is ${(isStringBalanced(test) ? "OK." : "not OK.")}`);

}

{{out}}

<pre>

=={{header|UNIX Shell}}==

{{works with|bash}}

local b=()

local i j tmp

balanced "$test" && result=OK || result="NOT OK"

printf "%s\t%s\n" "$test" "$result"

 

{{output}}

=={{header|Ursala}}==

 

#import nat

 

#cast %bm

 

output:

<pre><

 

=={{header|VBA}}==

Public Function checkBrackets(s As String) As Boolean

'function checks strings for balanced brackets

Next

End Sub

 

sample output:

 

=={{header|VBScript}}==

sequence = Generate_Sequence(n)

WScript.Echo sequence & " is " & Check_Balance(sequence) & "."

Check_Balance = "Balanced"

End If

 

{{out}}

 

Antother version not using libraries. The generator works as intended (more difficult to do than the checking)

option explicit

 

& s & vbtab & " Checks as " & iif(bb,"","un")&"balanced"

next

Sample run

<pre>

 

=={{header|Visual Basic .NET}}==

 

Private rand As New Random

Return numOpen = numClosed

End Function

 

{{out}}

 

=={{header|Vlang}}==

 

fn is_valid(bracket string) bool {

println('$b ${is_valid(b)}')

}

 

{{out}}

=={{header|Wren}}==

{{trans|Kotlin}}

 

var isBalanced = Fn.new { |s|

for (j in 1..8) s = s + ((rand.int(2) == 0) ? "[" : "]")

System.print("%(s) %(isBalanced.call(s) ? "OK" : "NOT OK")")

 

{{out}}

 

=={{header|X86 Assembly}}==

section .data

 

syscall

ret

 

=={{header|XBasic}}==

{{trans|JavaScript}}

{{works with|Windows XBasic}}

PROGRAM "balancedbrackets"

VERSION "0.001"

 

END PROGRAM

{{out}}

<pre>

 

=={{header|XBS}}==

func GenerateString(Amount:number=4):string{

set Result:string = "";

set s = GenerateString(math.random(2,4)*2);

log(`{s}: {IsBalanced(s)}`);

{{out}}

<pre>

 

=={{header|XPL0}}==

 

int N, I, C, Nest;

Text(0,"OK

");

 

Example output:

 

=={{header|Ya}}==

 

// all types are prefixed by `

//@Std/StdIO/ is used here to use Print function; else it maybe changed to Use @Std/StdIO at global level before this For loop

@Std/StdIO/Print(; "%s : %s\n" ;`Char[=] \brackets = MakeNew_[]s(10) /* all bracket strings are of length 10 */; AreBalanced(brackets) ? "Ok" : "bad")

 

=={{header|Yabasic}}==

local level, i

 

if not check_brackets(s$) print "not ";

 

=={{header|zkl}}==

The span method finds the start and length of a balanced span. This algorithm assumes the string only contains brackets; a matched span is chopped off the front of the string and a new balanced span is searched for. Stops when the string is empty or unbalanced (span returns Void).

<pre>

=={{header|ZX Spectrum Basic}}==

{{trans|AWK}}

20 READ s$

25 PRINT "The sequence ";s$;" is ";

1100 RETURN

2000 DATA "[]","][","][][","[][]","[][][]","[]][[]","[[[[[]]]]][][][]][]["