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}}==