Balanced brackets: Difference between revisions
Content added Content deleted
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
Thundergnat (talk | contribs) m (Automated syntax highlighting fixup (second round - minor fixes)) |
||
Line 19: | Line 19: | ||
=={{header|11l}}== |
=={{header|11l}}== |
||
{{trans|Python}} |
{{trans|Python}} |
||
<syntaxhighlight lang=11l>F gen(n) |
<syntaxhighlight lang="11l">F gen(n) |
||
V txt = [‘[’, ‘]’] * n |
V txt = [‘[’, ‘]’] * n |
||
random:shuffle(&txt) |
random:shuffle(&txt) |
||
Line 53: | Line 53: | ||
=={{header|360 Assembly}}== |
=={{header|360 Assembly}}== |
||
<syntaxhighlight lang=360asm>* Balanced brackets 28/04/2016 |
<syntaxhighlight lang="360asm">* Balanced brackets 28/04/2016 |
||
BALANCE CSECT |
BALANCE CSECT |
||
USING BALANCE,R13 base register and savearea pointer |
USING BALANCE,R13 base register and savearea pointer |
||
Line 179: | Line 179: | ||
=={{header|ABAP}}== |
=={{header|ABAP}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="abap"> |
||
CLASS lcl_balanced_brackets DEFINITION. |
CLASS lcl_balanced_brackets DEFINITION. |
||
PUBLIC SECTION. |
PUBLIC SECTION. |
||
Line 303: | Line 303: | ||
=={{header|Action!}}== |
=={{header|Action!}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="action!">PROC Generate(BYTE size CHAR ARRAY s) |
||
BYTE i,half |
BYTE i,half |
||
Line 395: | Line 395: | ||
Using #HASH-OFF |
Using #HASH-OFF |
||
</pre> |
</pre> |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="acurity architect"> |
||
FUNCTION bBRACKETS_MATCH(zStringWithBrackets: STRING): STRING |
FUNCTION bBRACKETS_MATCH(zStringWithBrackets: STRING): STRING |
||
VAR sCount: SHORT |
VAR sCount: SHORT |
||
Line 426: | Line 426: | ||
=={{header|Ada}}== |
=={{header|Ada}}== |
||
brackets.adb: |
brackets.adb: |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="ada">with Ada.Numerics.Discrete_Random; |
||
with Ada.Text_IO; |
with Ada.Text_IO; |
||
with Ada.Strings.Fixed; |
with Ada.Strings.Fixed; |
||
Line 503: | Line 503: | ||
=={{header|Aime}}== |
=={{header|Aime}}== |
||
<syntaxhighlight lang=aime>unbalanced(data s) |
<syntaxhighlight lang="aime">unbalanced(data s) |
||
{ |
{ |
||
integer b, i; |
integer b, i; |
||
Line 552: | Line 552: | ||
=={{header|ALGOL 68}}== |
=={{header|ALGOL 68}}== |
||
{{works with|ALGOL 68G|Any - tested with release 2.8.win32}} |
{{works with|ALGOL 68G|Any - tested with release 2.8.win32}} |
||
<syntaxhighlight lang=algol68># generates a string of random opening and closing brackets. The number of # |
<syntaxhighlight lang="algol68"># generates a string of random opening and closing brackets. The number of # |
||
# each type of brackets is speccified in length # |
# each type of brackets is speccified in length # |
||
PROC get brackets = ( INT length ) STRING: |
PROC get brackets = ( INT length ) STRING: |
||
Line 649: | Line 649: | ||
<br clear=both> |
<br clear=both> |
||
==={{header|Java}}=== |
==={{header|Java}}=== |
||
<syntaxhighlight lang=text> |
<syntaxhighlight lang="text"> |
||
grammar balancedBrackets ; |
grammar balancedBrackets ; |
||
Line 694: | Line 694: | ||
and a function to check whether a given string of brackets is balanced. |
and a function to check whether a given string of brackets is balanced. |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="apl">gen ← (⊂+?+)⍨ ⌷ ('[]'/⍨⊢) |
||
bal ← (((|≡⊢)+\) ∧ 0=+/)(+⌿1 ¯1×[1]'[]'∘.=⊢)</syntaxhighlight> |
bal ← (((|≡⊢)+\) ∧ 0=+/)(+⌿1 ¯1×[1]'[]'∘.=⊢)</syntaxhighlight> |
||
Sample run for 0..N..10: |
Sample run for 0..N..10: |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="apl"> ↑{br←gen ⍵ ⋄ br,': ',(1+bal br)⊃'Bad' 'Good'}¨0,⍳10 |
||
: Good |
: Good |
||
[]: Good |
[]: Good |
||
Line 717: | Line 717: | ||
(ES6 functionally composed version) |
(ES6 functionally composed version) |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="applescript">-- CHECK NESTING OF SQUARE BRACKET SEQUENCES --------------------------------- |
||
-- Zero-based index of the first problem (-1 if none found): |
-- Zero-based index of the first problem (-1 if none found): |
||
Line 914: | Line 914: | ||
=={{header|ARM Assembly}}== |
=={{header|ARM Assembly}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="arm_assembly"> |
||
.data |
.data |
||
Line 977: | Line 977: | ||
=={{header|Arturo}}== |
=={{header|Arturo}}== |
||
<syntaxhighlight lang=rebol>isBalanced: function [s][ |
<syntaxhighlight lang="rebol">isBalanced: function [s][ |
||
cnt: 0 |
cnt: 0 |
||
Line 1,016: | Line 1,016: | ||
=={{header|AutoHotkey}}== |
=={{header|AutoHotkey}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="autohotkey">; Generate 10 strings with equal left and right brackets |
||
Loop, 5 |
Loop, 5 |
||
{ |
{ |
||
Line 1,063: | Line 1,063: | ||
A second example repeatedly replacing []: |
A second example repeatedly replacing []: |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="autohotkey">Loop, 5 |
||
{ |
{ |
||
B = %A_Index% |
B = %A_Index% |
||
Line 1,101: | Line 1,101: | ||
=={{header|AutoIt}}== |
=={{header|AutoIt}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="autoit"> |
||
#include <Array.au3> |
#include <Array.au3> |
||
Local $Array[1] |
Local $Array[1] |
||
Line 1,134: | Line 1,134: | ||
=={{header|AWK}}== |
=={{header|AWK}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="awk">#!/usr/bin/awk -f |
||
BEGIN { |
BEGIN { |
||
print isbb("[]") |
print isbb("[]") |
||
Line 1,165: | Line 1,165: | ||
=={{header|BaCon}}== |
=={{header|BaCon}}== |
||
<syntaxhighlight lang=bacon>FOR len = 0 TO 18 STEP 2 |
<syntaxhighlight lang="bacon">FOR len = 0 TO 18 STEP 2 |
||
str$ = "" |
str$ = "" |
||
Line 1,203: | Line 1,203: | ||
{{works with|QBasic}} |
{{works with|QBasic}} |
||
<syntaxhighlight lang=qbasic>DECLARE FUNCTION checkBrackets% (brackets AS STRING) |
<syntaxhighlight lang="qbasic">DECLARE FUNCTION checkBrackets% (brackets AS STRING) |
||
DECLARE FUNCTION generator$ (length AS INTEGER) |
DECLARE FUNCTION generator$ (length AS INTEGER) |
||
Line 1,277: | Line 1,277: | ||
==={{header|Commodore BASIC}}=== |
==={{header|Commodore BASIC}}=== |
||
Based on ZX Spectrum BASIC implementation |
Based on ZX Spectrum BASIC implementation |
||
<syntaxhighlight lang=basic>10 PRINT CHR$(147): REM CLEAR SCREEN |
<syntaxhighlight lang="basic">10 PRINT CHR$(147): REM CLEAR SCREEN |
||
20 FOR N=1 TO 7 |
20 FOR N=1 TO 7 |
||
30 READ S$ |
30 READ S$ |
||
Line 1,302: | Line 1,302: | ||
=={{header|BASIC256}}== |
=={{header|BASIC256}}== |
||
{{trans|Yabasic}} |
{{trans|Yabasic}} |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="basic256">s$ = "[[]][]" |
||
print s$; " = "; |
print s$; " = "; |
||
Line 1,327: | Line 1,327: | ||
=={{header|Batch File}}== |
=={{header|Batch File}}== |
||
Uses the rewrite rule <code>"[]" -> null</code> to check if brackets are balanced. |
Uses the rewrite rule <code>"[]" -> null</code> to check if brackets are balanced. |
||
<syntaxhighlight lang=dos>:: Balanced Brackets Task from Rosetta Code |
<syntaxhighlight lang="dos">:: Balanced Brackets Task from Rosetta Code |
||
:: Batch File Implementation |
:: Batch File Implementation |
||
Line 1,404: | Line 1,404: | ||
=={{header|BBC BASIC}}== |
=={{header|BBC BASIC}}== |
||
<syntaxhighlight lang=bbcbasic>FOR x%=1 TO 10 |
<syntaxhighlight lang="bbcbasic">FOR x%=1 TO 10 |
||
test$=FNgenerate(RND(10)) |
test$=FNgenerate(RND(10)) |
||
PRINT "Bracket string ";test$;" is ";FNvalid(test$) |
PRINT "Bracket string ";test$;" is ";FNvalid(test$) |
||
Line 1,447: | Line 1,447: | ||
{{works with|befungee}} |
{{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. |
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. |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="befunge">v > "KO TON" ,,,,,, v |
||
> ~ : 25*- #v_ $ | > 25*, @ |
> ~ : 25*- #v_ $ | > 25*, @ |
||
> "KO" ,, ^ |
> "KO" ,, ^ |
||
Line 1,462: | Line 1,462: | ||
This allows for a particular simple implementation: |
This allows for a particular simple implementation: |
||
<syntaxhighlight lang=bqn>Gen ← (•rand.Deal⊏⥊⟜"[]") 2⊸× |
<syntaxhighlight lang="bqn">Gen ← (•rand.Deal⊏⥊⟜"[]") 2⊸× |
||
Bal ← { |
Bal ← { |
||
Mul ← {a‿b𝕊x‿y: ⟨a+0⌈x-b, y+0⌈b-x⟩} |
Mul ← {a‿b𝕊x‿y: ⟨a+0⌈x-b, y+0⌈b-x⟩} |
||
Line 1,480: | Line 1,480: | ||
=={{header|Bracmat}}== |
=={{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. |
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. |
||
<syntaxhighlight lang=bracmat>( (bal=|"[" !bal "]" !bal) |
<syntaxhighlight lang="bracmat">( (bal=|"[" !bal "]" !bal) |
||
& ( generate |
& ( generate |
||
= a j m n z N S someNumber |
= a j m n z N S someNumber |
||
Line 1,521: | Line 1,521: | ||
=={{header|Brat}}== |
=={{header|Brat}}== |
||
<syntaxhighlight lang=brat>string.prototype.balanced? = { |
<syntaxhighlight lang="brat">string.prototype.balanced? = { |
||
brackets = [] |
brackets = [] |
||
balanced = true |
balanced = true |
||
Line 1,566: | Line 1,566: | ||
=={{header|C}}== |
=={{header|C}}== |
||
<syntaxhighlight lang=c>#include<stdio.h> |
<syntaxhighlight lang="c">#include<stdio.h> |
||
#include<stdlib.h> |
#include<stdlib.h> |
||
#include<string.h> |
#include<string.h> |
||
Line 1,608: | Line 1,608: | ||
while(n<9) doSeq(n++); |
while(n<9) doSeq(n++); |
||
return 0; |
return 0; |
||
}</syntaxhighlight>result:<syntaxhighlight lang=text>'': True |
}</syntaxhighlight>result:<syntaxhighlight lang="text">'': True |
||
'[]': True |
'[]': True |
||
']][[': False |
']][[': False |
||
Line 1,619: | Line 1,619: | ||
=={{header|C sharp|C#}}== |
=={{header|C sharp|C#}}== |
||
<syntaxhighlight lang=csharp>using System; |
<syntaxhighlight lang="csharp">using System; |
||
using System.Linq; |
using System.Linq; |
||
Line 1,671: | Line 1,671: | ||
"[]]][][]][[][[" is not balanced. |
"[]]][][]][[][[" is not balanced. |
||
"[]]][]]][[][[][[" is not balanced.</pre> |
"[]]][]]][[][[][[" is not balanced.</pre> |
||
<syntaxhighlight lang=csharp> |
<syntaxhighlight lang="csharp"> |
||
// simple solution |
// simple solution |
||
string input = Console.ReadLine(); |
string input = Console.ReadLine(); |
||
Line 1,699: | Line 1,699: | ||
=={{header|C++}}== |
=={{header|C++}}== |
||
<syntaxhighlight lang=cpp>#include <algorithm> |
<syntaxhighlight lang="cpp">#include <algorithm> |
||
#include <iostream> |
#include <iostream> |
||
#include <string> |
#include <string> |
||
Line 1,745: | Line 1,745: | ||
=={{header|Ceylon}}== |
=={{header|Ceylon}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="ceylon">import com.vasileff.ceylon.random.api { |
||
platformRandom, |
platformRandom, |
||
Random |
Random |
||
Line 1,788: | Line 1,788: | ||
=={{header|Clojure}}== |
=={{header|Clojure}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="clojure">(defn gen-brackets [n] |
||
(->> (concat (repeat n \[) (repeat n \])) |
(->> (concat (repeat n \[) (repeat n \])) |
||
shuffle |
shuffle |
||
Line 1,806: | Line 1,806: | ||
* We can use <code>reduce</code> to consume the sequence: |
* We can use <code>reduce</code> to consume the sequence: |
||
:<syntaxhighlight lang= |
:<syntaxhighlight lang="clojure">(defn balanced? [s] |
||
(empty? |
(empty? |
||
(reduce |
(reduce |
||
Line 1,819: | Line 1,819: | ||
* Only <code>[</code>s are put on the stack. We can just count the unmatched ones. |
* Only <code>[</code>s are put on the stack. We can just count the unmatched ones. |
||
:<syntaxhighlight lang= |
:<syntaxhighlight lang="clojure">(defn balanced? [s] |
||
(let [opens-closes (->> s |
(let [opens-closes (->> s |
||
(map {\[ 1, \] -1}) |
(map {\[ 1, \] -1}) |
||
Line 1,843: | Line 1,843: | ||
=={{header|CLU}}== |
=={{header|CLU}}== |
||
<syntaxhighlight lang=clu>% This program needs the random number generator from |
<syntaxhighlight lang="clu">% This program needs the random number generator from |
||
% "misc.lib" that comes with PCLU. |
% "misc.lib" that comes with PCLU. |
||
Line 1,909: | Line 1,909: | ||
=={{header|COBOL}}== |
=={{header|COBOL}}== |
||
{{works with|OpenCOBOL}} |
{{works with|OpenCOBOL}} |
||
<syntaxhighlight lang=cobol> IDENTIFICATION DIVISION. |
<syntaxhighlight lang="cobol"> IDENTIFICATION DIVISION. |
||
PROGRAM-ID. test-balanced-brackets. |
PROGRAM-ID. test-balanced-brackets. |
||
Line 2,009: | Line 2,009: | ||
=={{header|CoffeeScript}}== |
=={{header|CoffeeScript}}== |
||
<syntaxhighlight lang=coffeescript> |
<syntaxhighlight lang="coffeescript"> |
||
isBalanced = (brackets) -> |
isBalanced = (brackets) -> |
||
openCount = 0 |
openCount = 0 |
||
Line 2,027: | Line 2,027: | ||
</syntaxhighlight> |
</syntaxhighlight> |
||
output |
output |
||
<syntaxhighlight lang=text> |
<syntaxhighlight lang="text"> |
||
> coffee balanced.coffee |
> coffee balanced.coffee |
||
[[[[ false |
[[[[ false |
||
Line 2,048: | Line 2,048: | ||
=={{header|Common Lisp}}== |
=={{header|Common Lisp}}== |
||
<syntaxhighlight lang=lisp> |
<syntaxhighlight lang="lisp"> |
||
(defun string-of-brackets (n) |
(defun string-of-brackets (n) |
||
(let* ((len (* 2 n)) |
(let* ((len (* 2 n)) |
||
Line 2,096: | Line 2,096: | ||
=={{header|Component Pascal}}== |
=={{header|Component Pascal}}== |
||
BlackBox Component Builder |
BlackBox Component Builder |
||
<syntaxhighlight lang=oberon2> |
<syntaxhighlight lang="oberon2"> |
||
MODULE Brackets; |
MODULE Brackets; |
||
IMPORT StdLog, Args, Stacks (* See Task Stacks *); |
IMPORT StdLog, Args, Stacks (* See Task Stacks *); |
||
Line 2,170: | Line 2,170: | ||
=={{header|Crystal}}== |
=={{header|Crystal}}== |
||
<syntaxhighlight lang=ruby>def generate(n : Int) |
<syntaxhighlight lang="ruby">def generate(n : Int) |
||
(['[',']'] * n).shuffle.join # Implicit return |
(['[',']'] * n).shuffle.join # Implicit return |
||
end |
end |
||
Line 2,213: | Line 2,213: | ||
===Standard Version=== |
===Standard Version=== |
||
D standard library has a [http://www.digitalmars.com/d/2.0/phobos/std_algorithm.html#balancedParens function] for this. |
D standard library has a [http://www.digitalmars.com/d/2.0/phobos/std_algorithm.html#balancedParens function] for this. |
||
<syntaxhighlight lang=d>import std.stdio, std.algorithm, std.random, std.range; |
<syntaxhighlight lang="d">import std.stdio, std.algorithm, std.random, std.range; |
||
void main() { |
void main() { |
||
Line 2,233: | Line 2,233: | ||
===Imperative Version=== |
===Imperative Version=== |
||
{{trans|Raku}} |
{{trans|Raku}} |
||
<syntaxhighlight lang=d>import std.stdio, std.random, std.range, std.algorithm; |
<syntaxhighlight lang="d">import std.stdio, std.random, std.range, std.algorithm; |
||
bool isBalanced(in string txt) pure nothrow { |
bool isBalanced(in string txt) pure nothrow { |
||
Line 2,260: | Line 2,260: | ||
===Functional Style=== |
===Functional Style=== |
||
{{trans|Haskell}} |
{{trans|Haskell}} |
||
<syntaxhighlight lang=d>import std.stdio, std.random, std.range, std.algorithm; |
<syntaxhighlight lang="d">import std.stdio, std.random, std.range, std.algorithm; |
||
bool isBalanced(in string s, in char[2] pars="[]") pure nothrow @safe @nogc { |
bool isBalanced(in string s, in char[2] pars="[]") pure nothrow @safe @nogc { |
||
Line 2,282: | Line 2,282: | ||
=={{header|Delphi}}== |
=={{header|Delphi}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="delphi">procedure Balanced_Brackets; |
||
var BracketsStr : string; |
var BracketsStr : string; |
||
Line 2,327: | Line 2,327: | ||
=={{header|Déjà Vu}}== |
=={{header|Déjà Vu}}== |
||
<syntaxhighlight lang=dejavu>matching?: |
<syntaxhighlight lang="dejavu">matching?: |
||
swap 0 |
swap 0 |
||
for c in chars: |
for c in chars: |
||
Line 2,356: | Line 2,356: | ||
=={{header|EchoLisp}}== |
=={{header|EchoLisp}}== |
||
<syntaxhighlight lang=scheme> |
<syntaxhighlight lang="scheme"> |
||
(define (balance str) |
(define (balance str) |
||
(for/fold (closed 0) ((par str)) |
(for/fold (closed 0) ((par str)) |
||
Line 2,389: | Line 2,389: | ||
=={{header|Elena}}== |
=={{header|Elena}}== |
||
ELENA 4.x : |
ELENA 4.x : |
||
<syntaxhighlight lang=elena>import system'routines; |
<syntaxhighlight lang="elena">import system'routines; |
||
import extensions; |
import extensions; |
||
import extensions'text; |
import extensions'text; |
||
Line 2,452: | Line 2,452: | ||
{{trans|Erlang}} |
{{trans|Erlang}} |
||
{{works with|Elixir|1.1}} |
{{works with|Elixir|1.1}} |
||
<syntaxhighlight lang=elixir>defmodule Balanced_brackets do |
<syntaxhighlight lang="elixir">defmodule Balanced_brackets do |
||
def task do |
def task do |
||
Enum.each(0..5, fn n -> |
Enum.each(0..5, fn n -> |
||
Line 2,491: | Line 2,491: | ||
=={{header|Erlang}}== |
=={{header|Erlang}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="erlang"> |
||
-module( balanced_brackets ). |
-module( balanced_brackets ). |
||
-export( [generate/1, is_balanced/1, task/0] ). |
-export( [generate/1, is_balanced/1, task/0] ). |
||
Line 2,534: | Line 2,534: | ||
=={{header|Euphoria}}== |
=={{header|Euphoria}}== |
||
<syntaxhighlight lang=euphoria>function check_brackets(sequence s) |
<syntaxhighlight lang="euphoria">function check_brackets(sequence s) |
||
integer level |
integer level |
||
level = 0 |
level = 0 |
||
Line 2,600: | Line 2,600: | ||
{{Works with|Office 365 betas 2021}} |
{{Works with|Office 365 betas 2021}} |
||
<syntaxhighlight lang=lisp>bracketReport |
<syntaxhighlight lang="lisp">bracketReport |
||
=LAMBDA(bracketPair, |
=LAMBDA(bracketPair, |
||
LAMBDA(s, |
LAMBDA(s, |
||
Line 2,689: | Line 2,689: | ||
and also assuming the following generic bindings in the Name Manager for the WorkBook: |
and also assuming the following generic bindings in the Name Manager for the WorkBook: |
||
<syntaxhighlight lang=lisp>APPENDCOLS |
<syntaxhighlight lang="lisp">APPENDCOLS |
||
=LAMBDA(xs, |
=LAMBDA(xs, |
||
LAMBDA(ys, |
LAMBDA(ys, |
||
Line 2,913: | Line 2,913: | ||
=={{header|F_Sharp|F#}}== |
=={{header|F_Sharp|F#}}== |
||
<syntaxhighlight lang=fsharp>let isBalanced str = |
<syntaxhighlight lang="fsharp">let isBalanced str = |
||
let rec loop count = function |
let rec loop count = function |
||
| ']'::_ when count = 0 -> false |
| ']'::_ when count = 0 -> false |
||
Line 2,950: | Line 2,950: | ||
=={{header|Factor}}== |
=={{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. |
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. |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="factor">USING: io formatting locals kernel math sequences unicode.case ; |
||
IN: balanced-brackets |
IN: balanced-brackets |
||
Line 2,975: | Line 2,975: | ||
Some more idiomatic solution might be as follows: |
Some more idiomatic solution might be as follows: |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="factor">USING: io formatting locals kernel math sequences unicode.case ; |
||
IN: balanced-brackets |
IN: balanced-brackets |
||
Line 2,999: | Line 2,999: | ||
=={{header|Fantom}}== |
=={{header|Fantom}}== |
||
<syntaxhighlight lang=fantom> |
<syntaxhighlight lang="fantom"> |
||
class Main |
class Main |
||
{ |
{ |
||
Line 3,067: | Line 3,067: | ||
=={{header|Forth}}== |
=={{header|Forth}}== |
||
{{works with|4tH|3.61.1}} |
{{works with|4tH|3.61.1}} |
||
<syntaxhighlight lang=forth>include lib/choose.4th ( n1 -- n2) |
<syntaxhighlight lang="forth">include lib/choose.4th ( n1 -- n2) |
||
include lib/ctos.4th ( n -- a 1) |
include lib/ctos.4th ( n -- a 1) |
||
Line 3,105: | Line 3,105: | ||
=={{header|Fortran}}== |
=={{header|Fortran}}== |
||
Please see the compilation and program execution result as comments at the top of this source: |
Please see the compilation and program execution result as comments at the top of this source: |
||
<syntaxhighlight lang=fortran> |
<syntaxhighlight lang="fortran"> |
||
! $ gfortran -g -O0 -std=f2008 -Wall f.f08 -o f.exe |
! $ gfortran -g -O0 -std=f2008 -Wall f.f08 -o f.exe |
||
! $ ./f |
! $ ./f |
||
Line 3,206: | Line 3,206: | ||
=={{header|FreeBASIC}}== |
=={{header|FreeBASIC}}== |
||
<syntaxhighlight lang=freebasic>' FB 1.05.0 Win64 |
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64 |
||
Function isBalanced(s As String) As Boolean |
Function isBalanced(s As String) As Boolean |
||
Line 3,272: | Line 3,272: | ||
=={{header|Gambas}}== |
=={{header|Gambas}}== |
||
'''[https://gambas-playground.proko.eu/?gist=8960fb267af43f0549d2cfe04288a2d4 Click this link to run this code]''' |
'''[https://gambas-playground.proko.eu/?gist=8960fb267af43f0549d2cfe04288a2d4 Click this link to run this code]''' |
||
<syntaxhighlight lang=gambas>'Altered to prevent lines starting with ']' or ending with '[' being generated as they can't work |
<syntaxhighlight lang="gambas">'Altered to prevent lines starting with ']' or ending with '[' being generated as they can't work |
||
siNumberOfBrackets As Short = 20 'Maximum amount of brackets in a line |
siNumberOfBrackets As Short = 20 'Maximum amount of brackets in a line |
||
Line 3,366: | Line 3,366: | ||
=={{header|GAP}}== |
=={{header|GAP}}== |
||
<syntaxhighlight lang=gap>Balanced := function(L) |
<syntaxhighlight lang="gap">Balanced := function(L) |
||
local c, r; |
local c, r; |
||
r := 0; |
r := 0; |
||
Line 3,404: | Line 3,404: | ||
=={{header|Go}}== |
=={{header|Go}}== |
||
<syntaxhighlight lang=go>package main |
<syntaxhighlight lang="go">package main |
||
import ( |
import ( |
||
Line 3,475: | Line 3,475: | ||
=={{header|Groovy}}== |
=={{header|Groovy}}== |
||
Generate Arbitrary String of Bracket Pairs: |
Generate Arbitrary String of Bracket Pairs: |
||
<syntaxhighlight lang=groovy>def random = new Random() |
<syntaxhighlight lang="groovy">def random = new Random() |
||
def factorial = { (it > 1) ? (2..it).inject(1) { i, j -> i*j } : 1 } |
def factorial = { (it > 1) ? (2..it).inject(1) { i, j -> i*j } : 1 } |
||
Line 3,498: | Line 3,498: | ||
Check Balance of Bracket String: |
Check Balance of Bracket String: |
||
<syntaxhighlight lang=groovy>boolean balancedBrackets(String brackets, int depth=0) { |
<syntaxhighlight lang="groovy">boolean balancedBrackets(String brackets, int depth=0) { |
||
if (brackets == null || brackets.empty) return depth == 0 |
if (brackets == null || brackets.empty) return depth == 0 |
||
switch (brackets[0]) { |
switch (brackets[0]) { |
||
Line 3,511: | Line 3,511: | ||
Test: |
Test: |
||
<syntaxhighlight lang=groovy>Set brackets = [] |
<syntaxhighlight lang="groovy">Set brackets = [] |
||
(0..100).each { |
(0..100).each { |
||
(0..8).each { r -> |
(0..8).each { r -> |
||
Line 3,722: | Line 3,722: | ||
=={{header|Haskell}}== |
=={{header|Haskell}}== |
||
The simplest solution exploits the idea of stack-based automaton, which could be implemented by a fold. |
The simplest solution exploits the idea of stack-based automaton, which could be implemented by a fold. |
||
<syntaxhighlight lang=haskell> |
<syntaxhighlight lang="haskell"> |
||
isMatching :: String -> Bool |
isMatching :: String -> Bool |
||
isMatching = null . foldl aut [] |
isMatching = null . foldl aut [] |
||
Line 3,733: | Line 3,733: | ||
This generates an infinite stream of correct balanced brackets expressions: |
This generates an infinite stream of correct balanced brackets expressions: |
||
<syntaxhighlight lang=haskell>brackets = filter isMatching |
<syntaxhighlight lang="haskell">brackets = filter isMatching |
||
$ [1.. ] >>= (`replicateM` "[]{}") </syntaxhighlight> |
$ [1.. ] >>= (`replicateM` "[]{}") </syntaxhighlight> |
||
<pre>λ> take 10 brackets |
<pre>λ> take 10 brackets |
||
Line 3,740: | Line 3,740: | ||
In case the index of unmatched opening bracket is need to be found, following solution is suitable. |
In case the index of unmatched opening bracket is need to be found, following solution is suitable. |
||
<syntaxhighlight lang=haskell> |
<syntaxhighlight lang="haskell"> |
||
import Control.Monad |
import Control.Monad |
||
import System.Random |
import System.Random |
||
Line 3,773: | Line 3,773: | ||
zipWithM_ (\n r -> check $ shuffle (take n bs) r) [0,2 ..] rs</syntaxhighlight> |
zipWithM_ (\n r -> check $ shuffle (take n bs) r) [0,2 ..] rs</syntaxhighlight> |
||
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. |
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. |
||
<syntaxhighlight lang=haskell>module VShuffle |
<syntaxhighlight lang="haskell">module VShuffle |
||
( shuffle |
( shuffle |
||
) where |
) where |
||
Line 3,827: | Line 3,827: | ||
and '''scanl''' also yields a simple fit when we want the index of the tipping point: |
and '''scanl''' also yields a simple fit when we want the index of the tipping point: |
||
<syntaxhighlight lang=haskell>import Control.Applicative ((<|>)) |
<syntaxhighlight lang="haskell">import Control.Applicative ((<|>)) |
||
import Data.List (findIndex, replicate, scanl) |
import Data.List (findIndex, replicate, scanl) |
||
import Data.List.Split (chunksOf) |
import Data.List.Split (chunksOf) |
||
Line 3,891: | Line 3,891: | ||
=={{header|Icon}} and {{header|Unicon}}== |
=={{header|Icon}} and {{header|Unicon}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="icon">procedure main(arglist) |
||
every s := genbs(!arglist) do |
every s := genbs(!arglist) do |
||
write(image(s), if isbalanced(s) then " is balanced." else " is unbalanced") |
write(image(s), if isbalanced(s) then " is balanced." else " is unbalanced") |
||
Line 3,923: | Line 3,923: | ||
=={{header|J}}== |
=={{header|J}}== |
||
'''Solution''': <syntaxhighlight lang=j>bracketDepth =: '[]' -&(+/\)/@:(=/) ] |
'''Solution''': <syntaxhighlight lang="j">bracketDepth =: '[]' -&(+/\)/@:(=/) ] |
||
checkBalanced =: _1 -.@e. bracketDepth |
checkBalanced =: _1 -.@e. bracketDepth |
||
genBracketPairs =: (?~@# { ])@#"0 1&'[]' NB. bracket pairs in arbitrary order</syntaxhighlight> |
genBracketPairs =: (?~@# { ])@#"0 1&'[]' NB. bracket pairs in arbitrary order</syntaxhighlight> |
||
'''Examples''':<syntaxhighlight lang=j> (, ' ' , ('bad';'OK') {::~ checkBalanced)"1 genBracketPairs i. 10 |
'''Examples''':<syntaxhighlight lang="j"> (, ' ' , ('bad';'OK') {::~ checkBalanced)"1 genBracketPairs i. 10 |
||
OK |
OK |
||
][ bad |
][ bad |
||
Line 3,943: | Line 3,943: | ||
=={{header|Java}}== |
=={{header|Java}}== |
||
{{works with|Java|1.5+}} |
{{works with|Java|1.5+}} |
||
<syntaxhighlight lang=java5>public class BalancedBrackets { |
<syntaxhighlight lang="java5">public class BalancedBrackets { |
||
public static boolean hasBalancedBrackets(String str) { |
public static boolean hasBalancedBrackets(String str) { |
||
Line 4,011: | Line 4,011: | ||
=== Extended === |
=== Extended === |
||
<syntaxhighlight lang=java>import java.util.ArrayDeque; |
<syntaxhighlight lang="java">import java.util.ArrayDeque; |
||
import java.util.Deque; |
import java.util.Deque; |
||
Line 4,101: | Line 4,101: | ||
====Iterative==== |
====Iterative==== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="javascript">function shuffle(str) { |
||
var a = str.split(''), b, c = a.length, d |
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 |
while (c) b = Math.random() * c-- | 0, d = a[c], a[c] = a[b], a[b] = d |
||
Line 4,144: | Line 4,144: | ||
==== Another solution ==== |
==== Another solution ==== |
||
{{works with|Node.js}} |
{{works with|Node.js}} |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="javascript"> |
||
console.log("Supplied examples"); |
console.log("Supplied examples"); |
||
var tests = ["", "[]", "][", "[][]", "][][", "[[][]]", "[]][[]"]; |
var tests = ["", "[]", "][", "[][]", "][][", "[[][]]", "[]][[]"]; |
||
Line 4,229: | Line 4,229: | ||
====Functional==== |
====Functional==== |
||
With visual indication of where the balance fails: |
With visual indication of where the balance fails: |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="javascript">(() => { |
||
'use strict'; |
'use strict'; |
||
Line 4,348: | Line 4,348: | ||
=={{header|Julia}}== |
=={{header|Julia}}== |
||
<syntaxhighlight lang=julia>using Printf |
<syntaxhighlight lang="julia">using Printf |
||
function balancedbrackets(str::AbstractString) |
function balancedbrackets(str::AbstractString) |
||
Line 4,377: | Line 4,377: | ||
'''One-line version''': |
'''One-line version''': |
||
<syntaxhighlight lang=julia>balancedbrackets(str::AbstractString) = foldl((x, y) -> x < 0 ? -1 : x + y, collect((x == '[') - (x == ']') for x in str), init = 0) == 0</syntaxhighlight> |
<syntaxhighlight lang="julia">balancedbrackets(str::AbstractString) = foldl((x, y) -> x < 0 ? -1 : x + y, collect((x == '[') - (x == ']') for x in str), init = 0) == 0</syntaxhighlight> |
||
=={{header|K}}== |
=={{header|K}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="k"> |
||
gen_brackets:{"[]"@x _draw 2} |
gen_brackets:{"[]"@x _draw 2} |
||
check:{r:(-1;1)@"["=x; *(0=+/cs<'0)&(0=-1#cs:+\r)} |
check:{r:(-1;1)@"["=x; *(0=+/cs<'0)&(0=-1#cs:+\r)} |
||
Line 4,398: | Line 4,398: | ||
=={{header|Klingphix}}== |
=={{header|Klingphix}}== |
||
<syntaxhighlight lang=text>"[[]][]]" |
<syntaxhighlight lang="text">"[[]][]]" |
||
%acc 0 !acc |
%acc 0 !acc |
||
Line 4,419: | Line 4,419: | ||
=={{header|Kotlin}}== |
=={{header|Kotlin}}== |
||
{{trans|FreeBASIC}} |
{{trans|FreeBASIC}} |
||
<syntaxhighlight lang=scala>import java.util.Random |
<syntaxhighlight lang="scala">import java.util.Random |
||
fun isBalanced(s: String): Boolean { |
fun isBalanced(s: String): Boolean { |
||
Line 4,474: | Line 4,474: | ||
=={{header|L++}}== |
=={{header|L++}}== |
||
<syntaxhighlight lang=lisp>(include "string") |
<syntaxhighlight lang="lisp">(include "string") |
||
(defn bool balanced (std::string s) |
(defn bool balanced (std::string s) |
||
Line 4,491: | Line 4,491: | ||
=={{header|Lasso}}== |
=={{header|Lasso}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="lasso">define randomparens(num::integer,open::string='[',close::string=']') => { |
||
local(out) = array |
local(out) = array |
||
Line 4,526: | Line 4,526: | ||
=={{header|Liberty BASIC}}== |
=={{header|Liberty BASIC}}== |
||
<syntaxhighlight lang=lb> |
<syntaxhighlight lang="lb"> |
||
print "Supplied examples" |
print "Supplied examples" |
||
for i =1 to 7 |
for i =1 to 7 |
||
Line 4,612: | Line 4,612: | ||
=={{header|Lua}}== |
=={{header|Lua}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="lua"> |
||
function isBalanced(s) |
function isBalanced(s) |
||
--Lua pattern matching has a 'balanced' pattern that matches sets of balanced characters. |
--Lua pattern matching has a 'balanced' pattern that matches sets of balanced characters. |
||
Line 4,637: | Line 4,637: | ||
=={{header|Maple}}== |
=={{header|Maple}}== |
||
This functionality is provided by Maple. |
This functionality is provided by Maple. |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="maple"> |
||
> use StringTools in |
> use StringTools in |
||
> IsBalanced( "", "[", "]" ); |
> IsBalanced( "", "[", "]" ); |
||
Line 4,671: | Line 4,671: | ||
</syntaxhighlight> |
</syntaxhighlight> |
||
Furthermore, Maple can check whether multiple fences are balanced in the same string. |
Furthermore, Maple can check whether multiple fences are balanced in the same string. |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="maple"> |
||
> StringTools:-IsBalanced( "[()()]", "[(", "])" ); |
> StringTools:-IsBalanced( "[()()]", "[(", "])" ); |
||
true |
true |
||
Line 4,677: | Line 4,677: | ||
=={{header|Mathematica}}/{{header|Wolfram Language}}== |
=={{header|Mathematica}}/{{header|Wolfram Language}}== |
||
<syntaxhighlight lang=mathematica>(* Generate open/close events. *) |
<syntaxhighlight lang="mathematica">(* Generate open/close events. *) |
||
gen[n_] := RandomSample[Table[{1, -1}, {n}] // Flatten] |
gen[n_] := RandomSample[Table[{1, -1}, {n}] // Flatten] |
||
Line 4,693: | Line 4,693: | ||
=={{header|MATLAB}} / {{header|Octave}}== |
=={{header|MATLAB}} / {{header|Octave}}== |
||
<syntaxhighlight lang=matlab>function x = isbb(s) |
<syntaxhighlight lang="matlab">function x = isbb(s) |
||
t = cumsum((s=='[') - (s==']')); |
t = cumsum((s=='[') - (s==']')); |
||
x = all(t>=0) && (t(end)==0); |
x = all(t>=0) && (t(end)==0); |
||
Line 4,715: | Line 4,715: | ||
=={{header|Maxima}}== |
=={{header|Maxima}}== |
||
<syntaxhighlight lang=maxima>brack(s) := block( |
<syntaxhighlight lang="maxima">brack(s) := block( |
||
[n: slength(s), r: 0, c], |
[n: slength(s), r: 0, c], |
||
catch( |
catch( |
||
Line 4,748: | Line 4,748: | ||
=={{header|Mercury}}== |
=={{header|Mercury}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="mercury"> |
||
:- module balancedbrackets. |
:- module balancedbrackets. |
||
:- interface. |
:- interface. |
||
Line 4,795: | Line 4,795: | ||
We start by defining a function: |
We start by defining a function: |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="miniscript">isBalanced = function(str) |
||
level = 0 |
level = 0 |
||
for c in str |
for c in str |
||
Line 4,807: | Line 4,807: | ||
We can evaluate the example strings with this code: |
We can evaluate the example strings with this code: |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="miniscript">examples = [ |
||
"", |
"", |
||
"[]", |
"[]", |
||
Line 4,836: | Line 4,836: | ||
{{works with|TopSpeed (JPI) Modula-2 under DOSBox-X}} |
{{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. |
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. |
||
<syntaxhighlight lang=modula2> |
<syntaxhighlight lang="modula2"> |
||
MODULE Brackets; |
MODULE Brackets; |
||
IMPORT IO, Lib; |
IMPORT IO, Lib; |
||
Line 4,901: | Line 4,901: | ||
=={{header|Nanoquery}}== |
=={{header|Nanoquery}}== |
||
{{trans|Python}} |
{{trans|Python}} |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="nanoquery">import Nanoquery.Util |
||
def gen(N) |
def gen(N) |
||
Line 4,948: | Line 4,948: | ||
=={{header|Nim}}== |
=={{header|Nim}}== |
||
<syntaxhighlight lang=nim> |
<syntaxhighlight lang="nim"> |
||
from random import random, randomize, shuffle |
from random import random, randomize, shuffle |
||
from strutils import repeat |
from strutils import repeat |
||
Line 4,987: | Line 4,987: | ||
=={{header|Oberon-2}}== |
=={{header|Oberon-2}}== |
||
{{works with|oo2c version 2}} |
{{works with|oo2c version 2}} |
||
<syntaxhighlight lang=oberon2> |
<syntaxhighlight lang="oberon2"> |
||
MODULE BalancedBrackets; |
MODULE BalancedBrackets; |
||
IMPORT |
IMPORT |
||
Line 5,102: | Line 5,102: | ||
=={{header|Objeck}}== |
=={{header|Objeck}}== |
||
<syntaxhighlight lang=objeck> |
<syntaxhighlight lang="objeck"> |
||
bundle Default { |
bundle Default { |
||
class Balanced { |
class Balanced { |
||
Line 5,148: | Line 5,148: | ||
=={{header|OCaml}}== |
=={{header|OCaml}}== |
||
<syntaxhighlight lang=ocaml>let generate_brackets n = |
<syntaxhighlight lang="ocaml">let generate_brackets n = |
||
let rec aux i acc = |
let rec aux i acc = |
||
if i <= 0 then acc else |
if i <= 0 then acc else |
||
Line 5,183: | Line 5,183: | ||
=={{header|Oforth}}== |
=={{header|Oforth}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="oforth">String method: isBalanced |
||
| c | |
| c | |
||
0 self forEach: c [ |
0 self forEach: c [ |
||
Line 5,211: | Line 5,211: | ||
=={{header|ooRexx}}== |
=={{header|ooRexx}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="oorexx"> |
||
tests = .array~of("", "[]", "][", "[][]", "][][", "[[][]]", "[]][[]") |
tests = .array~of("", "[]", "][", "[][]", "][][", "[[][]]", "[]][[]") |
||
Line 5,280: | Line 5,280: | ||
=={{header|OxygenBasic}}== |
=={{header|OxygenBasic}}== |
||
<syntaxhighlight lang=oxygenbasic>function CheckBrackets(string s) as bool |
<syntaxhighlight lang="oxygenbasic">function CheckBrackets(string s) as bool |
||
'======================================= |
'======================================= |
||
sys co, le=len s |
sys co, le=len s |
||
Line 5,310: | Line 5,310: | ||
=={{header|PARI/GP}}== |
=={{header|PARI/GP}}== |
||
<syntaxhighlight lang=parigp>balanced(s)={ |
<syntaxhighlight lang="parigp">balanced(s)={ |
||
my(n=0,v=Vecsmall(s)); |
my(n=0,v=Vecsmall(s)); |
||
for(i=1,#v, |
for(i=1,#v, |
||
Line 5,331: | Line 5,331: | ||
Idiomatic solution, using a regex that performs subpattern recursion ''(works with Perl 5.10 and newer)'': |
Idiomatic solution, using a regex that performs subpattern recursion ''(works with Perl 5.10 and newer)'': |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="perl">sub generate { |
||
my $n = shift; |
my $n = shift; |
||
my $str = '[' x $n; |
my $str = '[' x $n; |
||
Line 5,362: | Line 5,362: | ||
If input strings are allowed to contain unrelated characters, this can be extended to: |
If input strings are allowed to contain unrelated characters, this can be extended to: |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="perl">sub balanced { |
||
shift =~ /^ ( [^\[\]]++ | \[ (?1)* \] )* $/x; |
shift =~ /^ ( [^\[\]]++ | \[ (?1)* \] )* $/x; |
||
}</syntaxhighlight> |
}</syntaxhighlight> |
||
Line 5,368: | Line 5,368: | ||
<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. |
<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. |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="perl">use Regexp::Common 'balanced'; |
||
my $re = qr/^$RE{balanced}{-parens=>'[]'}$/; |
my $re = qr/^$RE{balanced}{-parens=>'[]'}$/; |
||
sub balanced { |
sub balanced { |
||
Line 5,376: | Line 5,376: | ||
Alternative implementation, using straightforward depth counting: |
Alternative implementation, using straightforward depth counting: |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="perl">sub balanced { |
||
my $depth = 0; |
my $depth = 0; |
||
for (split //, shift) { |
for (split //, shift) { |
||
Line 5,386: | Line 5,386: | ||
=={{header|Phix}}== |
=={{header|Phix}}== |
||
<!--<syntaxhighlight lang= |
<!--<syntaxhighlight lang="phix">(phixonline)--> |
||
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span> |
<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;">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> |
||
Line 5,435: | Line 5,435: | ||
=={{header|Phixmonti}}== |
=={{header|Phixmonti}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="phixmonti">"[[]][]" |
||
0 var acc |
0 var acc |
||
Line 5,456: | Line 5,456: | ||
The sample is given as unix shell script, you need to have ''php-cli'' (or what your package manager calls it) installed. |
The sample is given as unix shell script, you need to have ''php-cli'' (or what your package manager calls it) installed. |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="php">#!/usr/bin/php |
||
<?php |
<?php |
||
Line 5,507: | Line 5,507: | ||
=={{header|Picat}}== |
=={{header|Picat}}== |
||
===Foreach loop=== |
===Foreach loop=== |
||
<syntaxhighlight lang=picat>go1 ?=> |
<syntaxhighlight lang="picat">go1 ?=> |
||
tests(Tests), |
tests(Tests), |
||
member(Test,Tests), |
member(Test,Tests), |
||
Line 5,550: | Line 5,550: | ||
===DCG=== |
===DCG=== |
||
Here is an implementation using DCG (Definite Clause Grammars). |
Here is an implementation using DCG (Definite Clause Grammars). |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="picat">go_dcg ?=> |
||
tests(Tests), |
tests(Tests), |
||
foreach(Test in Tests) |
foreach(Test in Tests) |
||
Line 5,567: | Line 5,567: | ||
=={{header|PicoLisp}}== |
=={{header|PicoLisp}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="picolisp">(load "@lib/simul.l") # For 'shuffle' |
||
(de generateBrackets (N) |
(de generateBrackets (N) |
||
Line 5,597: | Line 5,597: | ||
=={{header|PL/I}}== |
=={{header|PL/I}}== |
||
<syntaxhighlight lang=pli>*process m or(!) s attributes source; |
<syntaxhighlight lang="pli">*process m or(!) s attributes source; |
||
cb: Proc Options(main); |
cb: Proc Options(main); |
||
/* PL/I program to check for balanced brackets [] ******************** |
/* PL/I program to check for balanced brackets [] ******************** |
||
Line 5,689: | Line 5,689: | ||
=={{header|PowerShell}}== |
=={{header|PowerShell}}== |
||
{{works with|PowerShell|2}} |
{{works with|PowerShell|2}} |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="powershell"> |
||
function Get-BalanceStatus ( $String ) |
function Get-BalanceStatus ( $String ) |
||
{ |
{ |
||
Line 5,709: | Line 5,709: | ||
} |
} |
||
</syntaxhighlight> |
</syntaxhighlight> |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="powershell"> |
||
# Test |
# Test |
||
$Strings = @( "" ) |
$Strings = @( "" ) |
||
Line 5,731: | Line 5,731: | ||
===PowerShell (Regex Version)=== |
===PowerShell (Regex Version)=== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="powershell"> |
||
function Test-BalancedBracket |
function Test-BalancedBracket |
||
{ |
{ |
||
Line 5,803: | Line 5,803: | ||
=={{header|Prolog}}== |
=={{header|Prolog}}== |
||
DCG are very usefull for this kind of exercice ! |
DCG are very usefull for this kind of exercice ! |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="prolog">rosetta_brackets :- |
||
test_brackets([]), |
test_brackets([]), |
||
test_brackets(['[',']']), |
test_brackets(['[',']']), |
||
Line 5,882: | Line 5,882: | ||
=={{header|PureBasic}}== |
=={{header|PureBasic}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="purebasic">Procedure.s Generate(N) |
||
For i=1 To N |
For i=1 To N |
||
sample$+"[]" |
sample$+"[]" |
||
Line 5,937: | Line 5,937: | ||
=={{header|Python}}== |
=={{header|Python}}== |
||
===Procedural=== |
===Procedural=== |
||
<syntaxhighlight lang=python>>>> def gen(N): |
<syntaxhighlight lang="python">>>> def gen(N): |
||
... txt = ['[', ']'] * N |
... txt = ['[', ']'] * N |
||
... random.shuffle( txt ) |
... random.shuffle( txt ) |
||
Line 5,969: | Line 5,969: | ||
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. |
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. |
||
<syntaxhighlight lang=python>>>> from itertools import accumulate |
<syntaxhighlight lang="python">>>> from itertools import accumulate |
||
>>> from random import shuffle |
>>> from random import shuffle |
||
>>> def gen(n): |
>>> def gen(n): |
||
Line 5,998: | Line 5,998: | ||
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. |
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. |
||
<syntaxhighlight lang=python>>>> import numpy as np |
<syntaxhighlight lang="python">>>> import numpy as np |
||
>>> from random import shuffle |
>>> from random import shuffle |
||
>>> def gen(n): |
>>> def gen(n): |
||
Line 6,026: | Line 6,026: | ||
=={{header|Qi}}== |
=={{header|Qi}}== |
||
<syntaxhighlight lang=qi>(define balanced-brackets-0 |
<syntaxhighlight lang="qi">(define balanced-brackets-0 |
||
[] 0 -> true |
[] 0 -> true |
||
[] _ -> false |
[] _ -> false |
||
Line 6,052: | Line 6,052: | ||
=={{header|Quackery}}== |
=={{header|Quackery}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="quackery"> [ char [ over of |
||
swap |
swap |
||
char ] swap of |
char ] swap of |
||
Line 6,091: | Line 6,091: | ||
=={{header|R}}== |
=={{header|R}}== |
||
<syntaxhighlight lang=r>balanced <- function(str){ |
<syntaxhighlight lang="r">balanced <- function(str){ |
||
str <- strsplit(str, "")[[1]] |
str <- strsplit(str, "")[[1]] |
||
str <- ifelse(str=='[', 1, -1) |
str <- ifelse(str=='[', 1, -1) |
||
Line 6,099: | Line 6,099: | ||
Alternately, using perl 5.10-compatible regexps, |
Alternately, using perl 5.10-compatible regexps, |
||
<syntaxhighlight lang=r>balanced <- function(str) { |
<syntaxhighlight lang="r">balanced <- function(str) { |
||
regexpr('^(\\[(?1)*\\])*$', str, perl=TRUE) > -1 |
regexpr('^(\\[(?1)*\\])*$', str, perl=TRUE) > -1 |
||
}</syntaxhighlight> |
}</syntaxhighlight> |
||
Line 6,105: | Line 6,105: | ||
To generate some some examples: |
To generate some some examples: |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="r">rand.parens <- function(n) paste(sample(c("[","]"),2*n,replace=T),collapse="") |
||
as.data.frame(within(list(), { |
as.data.frame(within(list(), { |
||
Line 6,113: | Line 6,113: | ||
Output: |
Output: |
||
<syntaxhighlight lang=r> balanced parens |
<syntaxhighlight lang="r"> balanced parens |
||
1 FALSE ][][ |
1 FALSE ][][ |
||
2 FALSE [][[]]][[]][]]][[[ |
2 FALSE [][[]]][[]][]]][[[ |
||
Line 6,127: | Line 6,127: | ||
=={{header|Racket}}== |
=={{header|Racket}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="racket"> |
||
#lang racket |
#lang racket |
||
Line 6,154: | Line 6,154: | ||
{{works with|Rakudo|2015.12}} |
{{works with|Rakudo|2015.12}} |
||
<syntaxhighlight lang=raku |
<syntaxhighlight lang="raku" line>sub balanced($s) { |
||
my $l = 0; |
my $l = 0; |
||
for $s.comb { |
for $s.comb { |
||
Line 6,174: | Line 6,174: | ||
===FP oriented=== |
===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. |
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. |
||
<syntaxhighlight lang=raku |
<syntaxhighlight lang="raku" line>sub balanced($s) { |
||
.none < 0 and .[*-1] == 0 |
.none < 0 and .[*-1] == 0 |
||
given ([\+] '\\' «leg« $s.comb).cache; |
given ([\+] '\\' «leg« $s.comb).cache; |
||
Line 6,186: | Line 6,186: | ||
Of course, a Perl 5 programmer might just remove as many inner balanced pairs as possible and then see what's left. |
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}} |
{{works with|Rakudo|2015.12}} |
||
<syntaxhighlight lang=raku |
<syntaxhighlight lang="raku" line>sub balanced($_ is copy) { |
||
Nil while s:g/'[]'//; |
Nil while s:g/'[]'//; |
||
$_ eq ''; |
$_ eq ''; |
||
Line 6,197: | Line 6,197: | ||
===Parsing with a grammar=== |
===Parsing with a grammar=== |
||
{{works with|Rakudo|2015.12}} |
{{works with|Rakudo|2015.12}} |
||
<syntaxhighlight lang=raku |
<syntaxhighlight lang="raku" line>grammar BalBrack { token TOP { '[' <TOP>* ']' } } |
||
my $n = prompt "Number of bracket pairs: "; |
my $n = prompt "Number of bracket pairs: "; |
||
Line 6,204: | Line 6,204: | ||
=={{header|Red}}== |
=={{header|Red}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="red">; Functional code |
||
balanced-brackets: [#"[" any balanced-brackets #"]"] |
balanced-brackets: [#"[" any balanced-brackets #"]"] |
||
rule: [any balanced-brackets end] |
rule: [any balanced-brackets end] |
||
Line 6,229: | Line 6,229: | ||
=={{header|REXX}}== |
=={{header|REXX}}== |
||
===with 40 examples=== |
===with 40 examples=== |
||
<syntaxhighlight lang=rexx>/*REXX program checks for balanced brackets [ ] ─── some fixed, others random.*/ |
<syntaxhighlight lang="rexx">/*REXX program checks for balanced brackets [ ] ─── some fixed, others random.*/ |
||
parse arg seed . /*obtain optional argument from the CL.*/ |
parse arg seed . /*obtain optional argument from the CL.*/ |
||
if datatype(seed,'W') then call random ,,seed /*if specified, then use as RANDOM seed*/ |
if datatype(seed,'W') then call random ,,seed /*if specified, then use as RANDOM seed*/ |
||
Line 6,313: | Line 6,313: | ||
===with examples + 30 permutations=== |
===with examples + 30 permutations=== |
||
<syntaxhighlight lang=rexx> |
<syntaxhighlight lang="rexx"> |
||
/*REXX program to check for balanced brackets [] ********************** |
/*REXX program to check for balanced brackets [] ********************** |
||
* test strings and random string generation copied from Version 1 |
* test strings and random string generation copied from Version 1 |
||
Line 6,430: | Line 6,430: | ||
Naturally, each of the one hundred thousand character strings aren't displayed (for balanced/not-balanced), |
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. |
<br>but a count is displayed, as anyone can generate the same strings in other languages and compare results. |
||
<syntaxhighlight lang=rexx>/*REXX program checks for around 125,000 generated balanced brackets expressions [ ] */ |
<syntaxhighlight lang="rexx">/*REXX program checks for around 125,000 generated balanced brackets expressions [ ] */ |
||
bals=0 |
bals=0 |
||
#=0; do j=1 until L>20 /*generate lots of bracket permutations*/ |
#=0; do j=1 until L>20 /*generate lots of bracket permutations*/ |
||
Line 6,457: | Line 6,457: | ||
=={{header|Ring}}== |
=={{header|Ring}}== |
||
<syntaxhighlight lang=ring> |
<syntaxhighlight lang="ring"> |
||
nr = 0 |
nr = 0 |
||
while nr < 10 |
while nr < 10 |
||
Line 6,502: | Line 6,502: | ||
{{trans|D}} |
{{trans|D}} |
||
{{works with|Ruby|1.9}} |
{{works with|Ruby|1.9}} |
||
<syntaxhighlight lang=ruby>re = /\A # beginning of string |
<syntaxhighlight lang="ruby">re = /\A # beginning of string |
||
(?<bb> # begin capture group <bb> |
(?<bb> # begin capture group <bb> |
||
\[ # literal [ |
\[ # literal [ |
||
Line 6,537: | Line 6,537: | ||
=={{header|Run BASIC}}== |
=={{header|Run BASIC}}== |
||
<syntaxhighlight lang=runbasic>dim brk$(10) |
<syntaxhighlight lang="runbasic">dim brk$(10) |
||
brk$(1) = "[[[][]]]" |
brk$(1) = "[[[][]]]" |
||
brk$(2) = "[[[]][[[][[][]]]]]" |
brk$(2) = "[[[]][[[][[][]]]]]" |
||
Line 6,575: | Line 6,575: | ||
{{libheader|rand}} |
{{libheader|rand}} |
||
<syntaxhighlight lang=rust>extern crate rand; |
<syntaxhighlight lang="rust">extern crate rand; |
||
trait Balanced { |
trait Balanced { |
||
Line 6,634: | Line 6,634: | ||
=== Scala Version 1 === |
=== Scala Version 1 === |
||
{{works with|Scala|2.9.1}} |
{{works with|Scala|2.9.1}} |
||
<syntaxhighlight lang=scala>import scala.collection.mutable.ListBuffer |
<syntaxhighlight lang="scala">import scala.collection.mutable.ListBuffer |
||
import scala.util.Random |
import scala.util.Random |
||
Line 7,045: | Line 7,045: | ||
=== Scala Version 2 === |
=== Scala Version 2 === |
||
{{works with|Scala|2.10.1}} |
{{works with|Scala|2.10.1}} |
||
<syntaxhighlight lang=scala>import scala.util.Random.shuffle |
<syntaxhighlight lang="scala">import scala.util.Random.shuffle |
||
object BalancedBracketsApp extends App { |
object BalancedBracketsApp extends App { |
||
Line 7,076: | Line 7,076: | ||
Alternate implementation of "isBalanced" using tail-recursion instead of var and return: |
Alternate implementation of "isBalanced" using tail-recursion instead of var and return: |
||
<syntaxhighlight lang=scala>import scala.util.Random.shuffle |
<syntaxhighlight lang="scala">import scala.util.Random.shuffle |
||
import scala.annotation.tailrec |
import scala.annotation.tailrec |
||
Line 7,099: | Line 7,099: | ||
Slightly modified implementation of "isBalanced" using tail-recursion |
Slightly modified implementation of "isBalanced" using tail-recursion |
||
{{works with|Scala|2.11.7}} |
{{works with|Scala|2.11.7}} |
||
<syntaxhighlight lang=scala> |
<syntaxhighlight lang="scala"> |
||
@scala.annotation.tailrec |
@scala.annotation.tailrec |
||
final def isBalanced( |
final def isBalanced( |
||
Line 7,135: | Line 7,135: | ||
=={{header|Scheme}}== |
=={{header|Scheme}}== |
||
<syntaxhighlight lang=scheme>(define (balanced-brackets string) |
<syntaxhighlight lang="scheme">(define (balanced-brackets string) |
||
(define (b chars sum) |
(define (b chars sum) |
||
(cond ((< sum 0) |
(cond ((< sum 0) |
||
Line 7,164: | Line 7,164: | ||
=={{header|Scilab}}== |
=={{header|Scilab}}== |
||
{{trans|MATLAB}} |
{{trans|MATLAB}} |
||
<syntaxhighlight lang=text>function varargout=isbb(s) |
<syntaxhighlight lang="text">function varargout=isbb(s) |
||
st=strsplit(s); |
st=strsplit(s); |
||
t=cumsum((st=='[')-(st==']')); |
t=cumsum((st=='[')-(st==']')); |
||
Line 7,172: | Line 7,172: | ||
{{out}} |
{{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>. |
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>. |
||
<syntaxhighlight lang=text>for j=[5 16 22] |
<syntaxhighlight lang="text">for j=[5 16 22] |
||
s=[]; |
s=[]; |
||
for i=1:j |
for i=1:j |
||
Line 7,200: | Line 7,200: | ||
=={{header|Seed7}}== |
=={{header|Seed7}}== |
||
<syntaxhighlight lang=seed7>$ include "seed7_05.s7i"; |
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i"; |
||
const func string: generateBrackets (in integer: count) is func |
const func string: generateBrackets (in integer: count) is func |
||
Line 7,274: | Line 7,274: | ||
=={{header|Sidef}}== |
=={{header|Sidef}}== |
||
<syntaxhighlight lang=ruby>func balanced (str) { |
<syntaxhighlight lang="ruby">func balanced (str) { |
||
var depth = 0 |
var depth = 0 |
||
Line 7,301: | Line 7,301: | ||
=={{header|Simula}}== |
=={{header|Simula}}== |
||
<syntaxhighlight lang=simula>BEGIN |
<syntaxhighlight lang="simula">BEGIN |
||
INTEGER U; |
INTEGER U; |
||
U := ININT; |
U := ININT; |
||
Line 7,396: | Line 7,396: | ||
{{works with|PolyML}} |
{{works with|PolyML}} |
||
<syntaxhighlight lang=sml>fun isBalanced s = checkBrackets 0 (String.explode s) |
<syntaxhighlight lang="sml">fun isBalanced s = checkBrackets 0 (String.explode s) |
||
and checkBrackets 0 [] = true |
and checkBrackets 0 [] = true |
||
| checkBrackets _ [] = false |
| checkBrackets _ [] = false |
||
Line 7,406: | Line 7,406: | ||
An example of usage |
An example of usage |
||
<syntaxhighlight lang=sml>val () = |
<syntaxhighlight lang="sml">val () = |
||
List.app print |
List.app print |
||
(List.map |
(List.map |
||
Line 7,431: | Line 7,431: | ||
=={{header|Stata}}== |
=={{header|Stata}}== |
||
<syntaxhighlight lang=stata>mata |
<syntaxhighlight lang="stata">mata |
||
function random_brackets(n) { |
function random_brackets(n) { |
||
return(invtokens(("[","]")[runiformint(1,2*n,1,2)],"")) |
return(invtokens(("[","]")[runiformint(1,2*n,1,2)],"")) |
||
Line 7,469: | Line 7,469: | ||
Checks balance function: |
Checks balance function: |
||
<syntaxhighlight lang=swift>import Foundation |
<syntaxhighlight lang="swift">import Foundation |
||
func isBal(str: String) -> Bool { |
func isBal(str: String) -> Bool { |
||
Line 7,478: | Line 7,478: | ||
} |
} |
||
</syntaxhighlight>output:<syntaxhighlight lang=swift> |
</syntaxhighlight>output:<syntaxhighlight lang="swift"> |
||
isBal("[[[]]]") // true |
isBal("[[[]]]") // true |
||
isBal("[]][[]") // false |
isBal("[]][[]") // false |
||
</syntaxhighlight>Random Bracket function:<syntaxhighlight lang=swift> |
</syntaxhighlight>Random Bracket function:<syntaxhighlight lang="swift"> |
||
func randBrack(n: Int) -> String { |
func randBrack(n: Int) -> String { |
||
Line 7,499: | Line 7,499: | ||
} |
} |
||
</syntaxhighlight>output:<syntaxhighlight lang=swift> |
</syntaxhighlight>output:<syntaxhighlight lang="swift"> |
||
randBrack(2) // "]][[" |
randBrack(2) // "]][[" |
||
</syntaxhighlight>Random check balance function:<syntaxhighlight lang=swift> |
</syntaxhighlight>Random check balance function:<syntaxhighlight lang="swift"> |
||
func randIsBal(n: Int) { |
func randIsBal(n: Int) { |
||
Line 7,518: | Line 7,518: | ||
randIsBal(4) |
randIsBal(4) |
||
</syntaxhighlight>output:<syntaxhighlight lang=swift> |
</syntaxhighlight>output:<syntaxhighlight lang="swift"> |
||
// ][ is unbalanced |
// ][ is unbalanced |
||
Line 7,529: | Line 7,529: | ||
=={{header|Tcl}}== |
=={{header|Tcl}}== |
||
<syntaxhighlight lang=tcl>proc generate {n} { |
<syntaxhighlight lang="tcl">proc generate {n} { |
||
if {!$n} return |
if {!$n} return |
||
set l [lrepeat $n "\[" "\]"] |
set l [lrepeat $n "\[" "\]"] |
||
Line 7,577: | Line 7,577: | ||
===Constructing correctly balanced strings=== |
===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: |
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: |
||
<syntaxhighlight lang=tcl>proc constructBalancedString {n} { |
<syntaxhighlight lang="tcl">proc constructBalancedString {n} { |
||
set s "" |
set s "" |
||
for {set i 0} {$i < $n} {incr i} { |
for {set i 0} {$i < $n} {incr i} { |
||
Line 7,591: | Line 7,591: | ||
Generation program in Unix TMG: |
Generation program in Unix TMG: |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="unixtmg">program: readint(n) [n>0] readint(seed) |
||
loop: parse(render) [--n>0?]/done loop; |
loop: parse(render) [--n>0?]/done loop; |
||
render: random(i, 15) [i = (i+1)*2] loop2 = { 1 * }; |
render: random(i, 15) [i = (i+1)*2] loop2 = { 1 * }; |
||
Line 7,619: | Line 7,619: | ||
Analysis can be done easily using grammar specification, rather than counting brackets: |
Analysis can be done easily using grammar specification, rather than counting brackets: |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="unixtmg">loop: parse(corr)\loop parse(incorr)\loop; |
||
corr: brkts * = { < OK: > 1 * }; |
corr: brkts * = { < OK: > 1 * }; |
||
brkts: brkt/null brkts = { 2 1 }; |
brkts: brkt/null brkts = { 2 1 }; |
||
Line 7,642: | Line 7,642: | ||
=={{header|TUSCRIPT}}== |
=={{header|TUSCRIPT}}== |
||
<syntaxhighlight lang=tuscript> |
<syntaxhighlight lang="tuscript"> |
||
$$ MODE TUSCRIPT |
$$ MODE TUSCRIPT |
||
Line 7,692: | Line 7,692: | ||
=={{header|TXR}}== |
=={{header|TXR}}== |
||
<syntaxhighlight lang=txr>@(define paren)@(maybe)[@(coll)@(paren)@(until)]@(end)]@(end)@(end) |
<syntaxhighlight lang="txr">@(define paren)@(maybe)[@(coll)@(paren)@(until)]@(end)]@(end)@(end) |
||
@(do (defvar r (make-random-state nil)) |
@(do (defvar r (make-random-state nil)) |
||
Line 7,751: | Line 7,751: | ||
== {{header|TypeScript}} == |
== {{header|TypeScript}} == |
||
{{trans|JavaScript}} |
{{trans|JavaScript}} |
||
<syntaxhighlight lang=javascript>// Balanced brackets |
<syntaxhighlight lang="javascript">// Balanced brackets |
||
function isStringBalanced(str: string): bool { |
function isStringBalanced(str: string): bool { |
||
Line 7,822: | Line 7,822: | ||
=={{header|UNIX Shell}}== |
=={{header|UNIX Shell}}== |
||
{{works with|bash}} |
{{works with|bash}} |
||
<syntaxhighlight lang=bash>generate() { |
<syntaxhighlight lang="bash">generate() { |
||
local b=() |
local b=() |
||
local i j tmp |
local i j tmp |
||
Line 7,876: | Line 7,876: | ||
=={{header|Ursala}}== |
=={{header|Ursala}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="ursala">#import std |
||
#import nat |
#import nat |
||
Line 7,903: | Line 7,903: | ||
=={{header|VBA}}== |
=={{header|VBA}}== |
||
<syntaxhighlight lang=vb> |
<syntaxhighlight lang="vb"> |
||
Public Function checkBrackets(s As String) As Boolean |
Public Function checkBrackets(s As String) As Boolean |
||
'function checks strings for balanced brackets |
'function checks strings for balanced brackets |
||
Line 7,987: | Line 7,987: | ||
"]][][[[][]]][][[][][": Not OK |
"]][][[[][]]][][[][][": Not OK |
||
</pre> |
</pre> |
||
⚫ | |||
=={{header|VBScript}}== |
=={{header|VBScript}}== |
||
<syntaxhighlight lang=vb>For n = 1 To 10 |
<syntaxhighlight lang="vb">For n = 1 To 10 |
||
sequence = Generate_Sequence(n) |
sequence = Generate_Sequence(n) |
||
WScript.Echo sequence & " is " & Check_Balance(sequence) & "." |
WScript.Echo sequence & " is " & Check_Balance(sequence) & "." |
||
Line 8,042: | Line 8,041: | ||
Antother version not using libraries. The generator works as intended (more difficult to do than the checking) |
Antother version not using libraries. The generator works as intended (more difficult to do than the checking) |
||
<syntaxhighlight lang=vb> |
<syntaxhighlight lang="vb"> |
||
option explicit |
option explicit |
||
Line 8,099: | Line 8,098: | ||
=={{header|Visual Basic .NET}}== |
=={{header|Visual Basic .NET}}== |
||
<syntaxhighlight lang=vbnet>Module Module1 |
<syntaxhighlight lang="vbnet">Module Module1 |
||
Private rand As New Random |
Private rand As New Random |
||
Line 8,159: | Line 8,158: | ||
=={{header|Vlang}}== |
=={{header|Vlang}}== |
||
<syntaxhighlight lang=vlang>import datatypes as dt |
<syntaxhighlight lang="vlang">import datatypes as dt |
||
fn is_valid(bracket string) bool { |
fn is_valid(bracket string) bool { |
||
Line 8,198: | Line 8,197: | ||
=={{header|Wren}}== |
=={{header|Wren}}== |
||
{{trans|Kotlin}} |
{{trans|Kotlin}} |
||
<syntaxhighlight lang=ecmascript>import "random" for Random |
<syntaxhighlight lang="ecmascript">import "random" for Random |
||
var isBalanced = Fn.new { |s| |
var isBalanced = Fn.new { |s| |
||
Line 8,251: | Line 8,250: | ||
=={{header|X86 Assembly}}== |
=={{header|X86 Assembly}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="x86assembly"> |
||
section .data |
section .data |
||
Line 8,323: | Line 8,322: | ||
{{trans|JavaScript}} |
{{trans|JavaScript}} |
||
{{works with|Windows XBasic}} |
{{works with|Windows XBasic}} |
||
<syntaxhighlight lang=xbasic>' Balanced brackets |
<syntaxhighlight lang="xbasic">' Balanced brackets |
||
PROGRAM "balancedbrackets" |
PROGRAM "balancedbrackets" |
||
VERSION "0.001" |
VERSION "0.001" |
||
Line 8,448: | Line 8,447: | ||
=={{header|XBS}}== |
=={{header|XBS}}== |
||
<syntaxhighlight lang=xbs>const Chars:[string] = ["[","]"]; |
<syntaxhighlight lang="xbs">const Chars:[string] = ["[","]"]; |
||
func GenerateString(Amount:number=4):string{ |
func GenerateString(Amount:number=4):string{ |
||
set Result:string = ""; |
set Result:string = ""; |
||
Line 8,480: | Line 8,479: | ||
=={{header|XPL0}}== |
=={{header|XPL0}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="xpl0">include c:\cxpl\codes; \intrinsic code declarations |
||
int N, I, C, Nest; |
int N, I, C, Nest; |
||
Line 8,517: | Line 8,516: | ||
=={{header|Ya}}== |
=={{header|Ya}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="ya">@Balanced[]s // each source must be started by specifying its file name; std extension .Ya could be ommitted and auto added by compiler |
||
// all types are prefixed by ` |
// all types are prefixed by ` |
||
Line 8,556: | Line 8,555: | ||
=={{header|Yabasic}}== |
=={{header|Yabasic}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="yabasic">sub check_brackets(s$) |
||
local level, i |
local level, i |
||
Line 8,576: | Line 8,575: | ||
=={{header|zkl}}== |
=={{header|zkl}}== |
||
<syntaxhighlight lang=zkl>fcn bb(bs){ while(a:=bs.span("[","]")) {bs=bs[a[1],*]} (Void!=a) }</syntaxhighlight> |
<syntaxhighlight lang="zkl">fcn bb(bs){ while(a:=bs.span("[","]")) {bs=bs[a[1],*]} (Void!=a) }</syntaxhighlight> |
||
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). |
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> |
<pre> |
||
Line 8,597: | Line 8,596: | ||
=={{header|ZX Spectrum Basic}}== |
=={{header|ZX Spectrum Basic}}== |
||
{{trans|AWK}} |
{{trans|AWK}} |
||
<syntaxhighlight lang=zxbasic>10 FOR n=1 TO 7 |
<syntaxhighlight lang="zxbasic">10 FOR n=1 TO 7 |
||
20 READ s$ |
20 READ s$ |
||
25 PRINT "The sequence ";s$;" is "; |
25 PRINT "The sequence ";s$;" is "; |
||
Line 8,615: | Line 8,614: | ||
2000 DATA "[]","][","][][","[][]","[][][]","[]][[]","[[[[[]]]]][][][]][][" |
2000 DATA "[]","][","][][","[][]","[][][]","[]][[]","[[[[[]]]]][][][]][][" |
||
</syntaxhighlight> |
</syntaxhighlight> |
||
⚫ |