aparler/RosettaCodeData
1
0
Fork 0
Code Issues 12 Pull requests 3 Projects Releases Packages Wiki Activity Actions

Data commit

Browse source
This commit is contained in:
Ingy döt Net 2023-07-01 11:58:00 -04:00
parent 7387c8f97b
commit cb5bb5e222
199093 changed files with 3378972 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Task/Balanced-brackets/00-META.yaml Normal file
View file

@ -0,0 +1,2 @@
---
from: http://rosettacode.org/wiki/Balanced_brackets

16
Task/Balanced-brackets/00-TASK.txt Normal file
View file

@ -0,0 +1,16 @@
'''Task''':
* Generate a string with &nbsp; '''N''' &nbsp; opening brackets &nbsp; <big>'''['''</big> &nbsp; and with &nbsp; '''N''' &nbsp; closing brackets &nbsp; <big>''']'''</big>, &nbsp; in some arbitrary order.
* Determine whether the generated string is ''balanced''; that is, whether it consists entirely of pairs of opening/closing brackets (in that order), none of which mis-nest.
;Examples:
(empty) OK
[] OK
[][] OK
[[][]] OK
][ NOT OK
][][ NOT OK
[]][[] NOT OK
<br><br>

19
Task/Balanced-brackets/11l/balanced-brackets.11l Normal file
View file

@ -0,0 +1,19 @@
F gen(n)
V txt = [‘[’, ‘]’] * n
random:shuffle(&txt)
R txt.join(‘’)
F is_balanced(s)
V nesting_level = 0
L(c) s
S c
‘[’
nesting_level++
‘]’
I --nesting_level < 0
R 0B
R 1B
L(n) 0..9
V s = gen(n)
print(s‘’(‘ ’ * (20 - s.len))‘is ’(I is_balanced(s) {‘balanced’} E ‘not balanced’))

101
Task/Balanced-brackets/360-Assembly/balanced-brackets.360 Normal file
View file

@ -0,0 +1,101 @@
* Balanced brackets 28/04/2016
BALANCE CSECT
USING BALANCE,R13 base register and savearea pointer
SAVEAREA B STM-SAVEAREA(R15)
DC 17F'0'
STM STM R14,R12,12(R13)
ST R13,4(R15)
ST R15,8(R13)
LR R13,R15 establish addressability
LA R8,1 i=1
LOOPI C R8,=F'20' do i=1 to 20
BH ELOOPI
MVC C(20),=CL20' ' c=' '
LA R1,1
LA R2,10
BAL R14,RANDOMX
LR R11,R0 l=randomx(1,10)
SLA R11,1 l=l*2
LA R10,1 j=1
LOOPJ CR R10,R11 do j=1 to 2*l
BH ELOOPJ
LA R1,0
LA R2,1
BAL R14,RANDOMX
LR R12,R0 m=randomx(0,1)
LTR R12,R12 if m=0
BNZ ELSEM
MVI Q,C'[' q='['
B EIFM
ELSEM MVI Q,C']' q=']'
EIFM LA R14,C-1(R10) @c(j)
MVC 0(1,R14),Q c(j)=q
LA R10,1(R10) j=j+1
B LOOPJ
ELOOPJ BAL R14,CHECKBAL
LR R2,R0
C R2,=F'1' if checkbal=1
BNE ELSEC
MVC PG+24(2),=C'ok' rep='ok'
B EIFC
ELSEC MVC PG+24(2),=C'? ' rep='? '
EIFC XDECO R8,XDEC i
MVC PG+0(2),XDEC+10
MVC PG+3(20),C
XPRNT PG,26
LA R8,1(R8) i=i+1
B LOOPI
ELOOPI L R13,4(0,R13)
LM R14,R12,12(R13)
XR R15,R15 set return code to 0
BR R14 -------------- end
CHECKBAL CNOP 0,4 -------------- checkbal
SR R6,R6 n=0
LA R7,1 k=1
LOOPK C R7,=F'20' do k=1 to 20
BH ELOOPK
LR R1,R7 k
LA R4,C-1(R1) @c(k)
MVC CI(1),0(R4) ci=c(k)
CLI CI,C'[' if ci='['
BNE NOT1
LA R6,1(R6) n=n+1
NOT1 CLI CI,C']' if ci=']'
BNE NOT2
BCTR R6,0 n=n-1
NOT2 LTR R6,R6 if n<0
BNM NSUP0
SR R0,R0 return(0)
B RETCHECK
NSUP0 LA R7,1(R7) k=k+1
B LOOPK
ELOOPK LTR R6,R6 if n=0
BNZ ELSEN
LA R0,1 return(1)
B RETCHECK
ELSEN SR R0,R0 return(0)
RETCHECK BR R14 -------------- end checkbal
RANDOMX CNOP 0,4 -------------- randomx
LR R3,R2 i2
SR R3,R1 ii=i2-i1
L R5,SEED
M R4,=F'1103515245'
A R5,=F'12345'
SRDL R4,1 shift to improve the algorithm
ST R5,SEED seed=(seed*1103515245+12345)>>1
LR R6,R3 ii
LA R6,1(R6) ii+1
L R5,SEED seed
LA R4,0 clear
DR R4,R6 seed//(ii+1)
AR R4,R1 +i1
LR R0,R4 return(seed//(ii+1)+i1)
BR R14 -------------- end randomx
SEED DC F'903313037'
C DS 20CL1
Q DS CL1
CI DS CL1
PG DC CL80' '
XDEC DS CL12
REGS
END BALANCE

218
Task/Balanced-brackets/AArch64-Assembly/balanced-brackets.aarch64 Normal file
View file

@ -0,0 +1,218 @@
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program balencebrac64.s */
/************************************/
/* Constantes */
/************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
/*********************************/
/* Initialized data */
/*********************************/
.data
szMessResult: .asciz "Expression : "
szMessBalenced: .asciz " balanced"
szMessNotBalenced: .asciz " not balanced"
szMessStart: .asciz "Program 64 bits start.\n"
szCarriageReturn: .asciz "\n"
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
sZoneConv: .skip 24 // conversion buffer
sBuffer: .skip 80
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: // entry of program
ldr x0,qAdrszMessStart
bl affichageMess
mov x0,0b111000 // bit 1 = open bracket bit 0 = close bracket
bl testBalanced
mov x0,0b110100
bl testBalanced
mov x0,0b11001001
bl testBalanced
mov x19,10 // number random test
1:
mov x0,1 // mini number
mov x1,10000 // maxi random number
bl extRandom // generate random number
bl testBalanced
subs x19,x19,1
bge 1b
100: // standard end of the program
mov x0, #0 // return code
mov x8,EXIT
svc #0 // perform the system call
qAdrszCarriageReturn: .quad szCarriageReturn
qAdrszMessResult: .quad szMessResult
qAdrszMessNotBalenced: .quad szMessNotBalenced
qAdrszMessBalenced: .quad szMessBalenced
qAdrszMessStart: .quad szMessStart
qAdrsBuffer: .quad sBuffer
/***************************************************/
/* routine to test expression */
/***************************************************/
/* x0 expression */
testBalanced:
stp x1,lr,[sp,-16]! // save registres
stp x2,x3,[sp,-16]! // save registres
ldr x1,qAdrsBuffer
bl isBalanced
cmp x0,0
ldr x3,qAdrszMessNotBalenced
ldr x4,qAdrszMessBalenced
csel x3,x3,x4,eq
mov x0,#4 // string number to display
ldr x1,qAdrszMessResult
ldr x2,qAdrsBuffer
ldr x4,qAdrszCarriageReturn
bl displayStrings // display message
100:
ldp x2,x3,[sp],16 // restaur registres
ldp x1,lr,[sp],16 // restaur registres
ret
/***************************************************/
/* control if expression is balenced */
/***************************************************/
/* x0 expression */
/* x1 buffer address */
/* x0 return 1 if balanced else zero */
isBalanced:
stp x1,lr,[sp,-16]! // save registres
stp x2,x3,[sp,-16]! // save registres
mov x3,63
clz x2,x0 // number of zeros on the left
sub x2,x3,x2 // so many useful numbers right
mov x4,1 // mask to test bit
lsl x4,x4,x2 // shift left begin expression
mov x3,0 // top if right bracket > left bracket
mov x7,0 // indice display buffer expression
mov x5,0 // counter brackets
1: // begin loop to test bits
tst x0,x4
beq 2f // bit = 0
mov x6,'(' // else bit = 1 -> open bracket
strb w6,[x1,x7] // store in buffer
add x7,x7,1 // increment indice
add x5,x5,1 // increment open bracket
b 3f
2: // bit = 0
mov x6,')' // close bracket
strb w6,[x1,x7] // store in buffer
add x7,x7,1 // increment indice
subs x5,x5,1 // decrement open bracket
bge 3f // if negative
mov x3,1 // top error
3:
lsr x4,x4,1 // shift mask right
cbnz x4,1b // and loop if not zero
strb wzr,[x1,x7] // zero final on buffer
cmp x5,0 // right bracket <> left bracket -> error
bne 4f
cmp x3,0 // in expression left bracket > right bracket
bne 4f
mov x0,1 // balanced
b 100f
4:
mov x0,0 // not balanced
100:
ldp x2,x3,[sp],16 // restaur registres
ldp x1,lr,[sp],16 // restaur registres
ret
/***************************************************/
/* display multi strings */
/* new version 24/05/2023 */
/***************************************************/
/* x0 contains number strings address */
/* x1 address string1 */
/* x2 address string2 */
/* x3 address string3 */
/* x4 address string4 */
/* x5 address string5 */
/* x6 address string5 */
/* x7 address string6 */
displayStrings: // INFO: displayStrings
stp x8,lr,[sp,-16]! // save registers
stp x2,fp,[sp,-16]! // save registers
add fp,sp,#32 // save paraméters address (4 registers saved * 8 bytes)
mov x8,x0 // save strings number
cmp x8,#0 // 0 string -> end
ble 100f
mov x0,x1 // string 1
bl affichageMess
cmp x8,#1 // number > 1
ble 100f
mov x0,x2
bl affichageMess
cmp x8,#2
ble 100f
mov x0,x3
bl affichageMess
cmp x8,#3
ble 100f
mov x0,x4
bl affichageMess
cmp x8,#4
ble 100f
mov x0,x5
bl affichageMess
cmp x8,#5
ble 100f
mov x0,x6
bl affichageMess
cmp x8,#6
ble 100f
mov x0,x7
bl affichageMess
100:
ldp x2,fp,[sp],16 // restaur registers
ldp x8,lr,[sp],16 // restaur registers
ret
/******************************************************************/
/* random number */
/******************************************************************/
/* x0 contains inferior value */
/* x1 contains maxi value */
/* x0 return random number */
extRandom:
stp x1,lr,[sp,-16]! // save registers
stp x2,x8,[sp,-16]! // save registers
stp x19,x20,[sp,-16]! // save registers
sub sp,sp,16 // reserve 16 octets on stack
mov x19,x0
add x20,x1,1
mov x0,sp // store result on stack
mov x1,8 // length 8 bytes
mov x2,0
mov x8,278 // call system Linux 64 bits Urandom
svc 0
mov x0,sp // load résult on stack
ldr x0,[x0]
sub x2,x20,x19 // calculation of the range of values
udiv x1,x0,x2 // calculation range modulo
msub x0,x1,x2,x0
add x0,x0,x19 // and add inferior value
100:
add sp,sp,16 // alignement stack
ldp x19,x20,[sp],16 // restaur 2 registers
ldp x2,x8,[sp],16 // restaur 2 registers
ldp x1,lr,[sp],16 // restaur 2 registers
ret // retour adresse lr x30
/***************************************************/
/* ROUTINES INCLUDE */
/***************************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeARM64.inc"

95
Task/Balanced-brackets/ABAP/balanced-brackets.abap Normal file
View file

@ -0,0 +1,95 @@
CLASS lcl_balanced_brackets DEFINITION.
PUBLIC SECTION.
CLASS-METHODS:
class_constructor,
are_brackets_balanced
IMPORTING
seq TYPE string
RETURNING
VALUE(r_are_brackets_balanced) TYPE abap_bool,
get_random_brackets_seq
IMPORTING
n TYPE i
RETURNING
VALUE(r_bracket_seq) TYPE string.
PRIVATE SECTION.
CLASS-DATA: random_int TYPE REF TO cl_abap_random_int.
CLASS-METHODS:
_split_string
IMPORTING
i_text TYPE string
RETURNING
VALUE(r_chars) TYPE stringtab,
_rand_bool
RETURNING
VALUE(r_bool) TYPE i.
ENDCLASS.
CLASS lcl_balanced_brackets IMPLEMENTATION.
METHOD class_constructor.
random_int = cl_abap_random_int=>create( seed = CONV #( sy-uzeit )
min = 0
max = 1 ).
ENDMETHOD.
METHOD are_brackets_balanced.
DATA: open_bracket_count TYPE i.
DATA(chars) = _split_string( seq ).
r_are_brackets_balanced = abap_false.
LOOP AT chars ASSIGNING FIELD-SYMBOL(<c>).
IF <c> = ']' AND open_bracket_count = 0.
RETURN.
ENDIF.
IF <c> = ']'.
open_bracket_count = open_bracket_count - 1.
ENDIF.
IF <c> = '['.
open_bracket_count = open_bracket_count + 1.
ENDIF.
ENDLOOP.
IF open_bracket_count > 0.
RETURN.
ENDIF.
r_are_brackets_balanced = abap_true.
ENDMETHOD.
METHOD get_random_brackets_seq.
DATA(itab) = VALUE stringtab( FOR i = 1 THEN i + 1 WHILE i <= n
( COND #( WHEN _rand_bool( ) = 0 THEN '['
ELSE ']' ) ) ).
r_bracket_seq = concat_lines_of( itab ).
ENDMETHOD.
METHOD _rand_bool.
r_bool = random_int->get_next( ).
ENDMETHOD.
METHOD _split_string.
DATA: off TYPE i VALUE 0.
DO strlen( i_text ) TIMES.
INSERT i_text+off(1) INTO TABLE r_chars.
off = off + 1.
ENDDO.
ENDMETHOD.
ENDCLASS.
START-OF-SELECTION.
DO 10 TIMES.
DATA(seq) = lcl_balanced_brackets=>get_random_brackets_seq( 10 ).
cl_demo_output=>write( |{ seq } => { COND string( WHEN lcl_balanced_brackets=>are_brackets_balanced( seq ) = abap_true THEN 'OK'
ELSE 'NOT OK' ) }| ).
ENDDO.
cl_demo_output=>display( ).

63
Task/Balanced-brackets/ALGOL-68/balanced-brackets.alg Normal file
View file

@ -0,0 +1,63 @@
# generates a string of random opening and closing brackets. The number of #
# each type of brackets is speccified in length #
PROC get brackets = ( INT length ) STRING:
BEGIN
INT result length = length * 2;
[ 1 : result length ]CHAR result;
# initialise the brackets to all open brackets #
FOR char pos TO result length DO result[ char pos ] := "[" OD;
# set half of the brackets to close brackets #
INT close count := 0;
WHILE close count < length
DO
INT random pos = 1 + ENTIER ( next random * result length );
IF result[ random pos ] = "["
THEN
close count +:= 1;
result[ random pos ] := "]"
FI
OD;
result
END # get brackets # ;
# returns TRUE if the brackets string contains a correctly nested sequence #
# of brackets, FALSE otherwise #
PROC check brackets = ( STRING brackets ) BOOL:
BEGIN
INT depth := 0;
FOR char pos FROM LWB brackets TO UPB brackets
WHILE
IF brackets[ char pos ] = "["
THEN
depth +:= 1
ELSE
depth -:= 1
FI;
depth >= 0
DO
SKIP
OD;
# depth will be 0 if we reached the end of the string and it was #
# correct, non-0 otherwise #
depth = 0
END # check brackets # ;
# procedure to test check brackets #
PROC test check brackets = ( STRING brackets ) VOID:
print( ( ( brackets
+ ": "
+ IF check brackets( brackets ) THEN "ok" ELSE "not ok" FI
)
, newline
)
) ;
# test the bracket generation and checking PROCs #
test check brackets( get brackets( 0 ) );
FOR length TO 12
DO
TO 2
DO
test check brackets( get brackets( length ) )
OD
OD

2
Task/Balanced-brackets/APL/balanced-brackets-1.apl Normal file
View file

@ -0,0 +1,2 @@
gen ← (⊂+?+)⍨ ⌷ ('[]'/⍨⊢)
bal ← (((|≡⊢)+\) ∧ 0=+/)(+⌿1 ¯1×[1]'[]'∘.=⊢)

12
Task/Balanced-brackets/APL/balanced-brackets-2.apl Normal file
View file

@ -0,0 +1,12 @@
↑{br←gen ⍵ ⋄ br,': ',(1+bal br)⊃'Bad' 'Good'}¨0,⍳10
: Good
[]: Good
][][: Bad
[][[]]: Good
[]]][[][: Bad
][][[[[]]]: Bad
][][][][][[]: Bad
][[[][[][]][]]: Bad
[[][[]]][[[[]]]]: Good
[[[]][[[[][]][]]]]: Good
]][][][][[][][]][[[]: Bad

58
Task/Balanced-brackets/ARM-Assembly/balanced-brackets.arm Normal file
View file

@ -0,0 +1,58 @@
.data
balanced_message:
.ascii "OK\n"
unbalanced_message:
.ascii "NOT OK\n"
.text
.equ balanced_msg_len, 3
.equ unbalanced_msg_len, 7
BalancedBrackets:
mov r1, #0
mov r2, #0
mov r3, #0
process_bracket:
ldrb r2, [r0, r1]
cmp r2, #0
beq evaluate_balance
cmp r2, #'['
addeq r3, r3, #1
cmp r2, #']'
subeq r3, r3, #1
cmp r3, #0
blt unbalanced
add r1, r1, #1
b process_bracket
evaluate_balance:
cmp r3, #0
beq balanced
unbalanced:
ldr r1, =unbalanced_message
mov r2, #unbalanced_msg_len
b display_result
balanced:
ldr r1, =balanced_message
mov r2, #balanced_msg_len
display_result:
mov r7, #4
mov r0, #1
svc #0
mov pc, lr

21
Task/Balanced-brackets/AWK/balanced-brackets.awk Normal file
View file

@ -0,0 +1,21 @@
#!/usr/bin/awk -f
BEGIN {
print isbb("[]")
print isbb("][")
print isbb("][][")
print isbb("[][]")
print isbb("[][][]")
print isbb("[]][[]")
}
function isbb(x) {
s = 0
for (k=1; k<=length(x); k++) {
c = substr(x,k,1)
if (c=="[") {s++}
else { if (c=="]") s-- }
if (s<0) {return 0}
}
return (s==0)
}

72
Task/Balanced-brackets/Action-/balanced-brackets.action Normal file
View file

@ -0,0 +1,72 @@
PROC Generate(BYTE size CHAR ARRAY s)
BYTE i,half
s(0)=size
half=size RSH 1
FOR i=1 TO half
DO s(i)='[ OD
FOR i=half+1 TO size
DO s(i)='] OD
RETURN
PROC Shuffle(CHAR ARRAY s)
BYTE i,j,k,n,len,tmp
len=s(0)
n=Rand(len+1)
FOR k=1 TO n
DO
i=Rand(len)+1
j=Rand(len)+1
tmp=s(i)
s(i)=s(j)
s(j)=tmp
OD
RETURN
BYTE FUNC Balanced(CHAR ARRAY s)
INT i,lev
lev=0
FOR i=1 TO s(0)
DO
IF s(i)='[ THEN
lev==+1
ELSE
lev==-1
FI
IF lev<0 THEN
RETURN (0)
FI
OD
IF lev#0 THEN
RETURN (0)
FI
RETURN (1)
PROC Main()
CHAR ARRAY s(20)
BYTE i,b
FOR i=0 TO 20 STEP 2
DO
Generate(i,s)
Shuffle(s)
b=Balanced(s)
IF s(0)=0 THEN
Print("(empty)")
ELSE
Print(s)
FI
Print(" is ")
IF b=0 THEN
Print("not ")
FI
PrintE("balanced")
OD
RETURN

19
Task/Balanced-brackets/Acurity-Architect/balanced-brackets.acurity Normal file
View file

@ -0,0 +1,19 @@
FUNCTION bBRACKETS_MATCH(zStringWithBrackets: STRING): STRING
VAR sCount: SHORT
VAR sBracketCounter: SHORT
VAR zOK: STRING
//
SET zOK = "NOT OK"
DO sCount = 1 TO LENGTH(zStringWithBrackets)
CASE SUBSTR(zStringWithBrackets, sCount, 1)
VALUE "["
SET sBracketCounter = sBracketCounter + 1
VALUE "]"
SET sBracketCounter = sBracketCounter - 1
ENDCASE
ENDDO
IF sBracketCounter = 0
SET zOK = "OK"
ENDIF
RETURN zOK
ENDFUNCTION

57
Task/Balanced-brackets/Ada/balanced-brackets.ada Normal file
View file

@ -0,0 +1,57 @@
with Ada.Numerics.Discrete_Random;
with Ada.Text_IO;
with Ada.Strings.Fixed;
procedure Brackets is
package Random_Positive is new Ada.Numerics.Discrete_Random (Positive);
Positive_Generator : Random_Positive.Generator;
procedure Swap (Left, Right : in out Character) is
Temp : constant Character := Left;
begin
Left := Right;
Right := Temp;
end Swap;
function Generate_Brackets (Bracket_Count : Natural;
Opening_Bracket : Character := '[';
Closing_Bracket : Character := ']')
return String is
use Ada.Strings.Fixed;
All_Brackets : String := Bracket_Count * Opening_Bracket & Bracket_Count * Closing_Bracket;
begin
for I in All_Brackets'Range loop
Swap (All_Brackets (I), All_Brackets (Random_Positive.Random (Positive_Generator) mod (Bracket_Count * 2) + 1));
end loop;
return All_Brackets;
end Generate_Brackets;
function Check_Brackets (Test : String;
Opening_Bracket : Character := '[';
Closing_Bracket : Character := ']')
return Boolean is
Open : Natural := 0;
begin
for I in Test'Range loop
if Test (I) = Opening_Bracket then
Open := Open + 1;
elsif Test (I) = Closing_Bracket then
if Open = 0 then
return False;
else
Open := Open - 1;
end if;
end if;
end loop;
return True;
end Check_Brackets;
begin
Random_Positive.Reset (Positive_Generator);
Ada.Text_IO.Put_Line ("Brackets");
for I in 0 .. 4 loop
for J in 0 .. I loop
declare
My_String : constant String := Generate_Brackets (I);
begin
Ada.Text_IO.Put_Line (My_String & ": " & Boolean'Image (Check_Brackets (My_String)));
end;
end loop;
end loop;
end Brackets;

35
Task/Balanced-brackets/Aime/balanced-brackets.aime Normal file
View file

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

183
Task/Balanced-brackets/AppleScript/balanced-brackets.applescript Normal file
View file

@ -0,0 +1,183 @@
-- CHECK NESTING OF SQUARE BRACKET SEQUENCES ---------------------------------
-- Zero-based index of the first problem (-1 if none found):
-- imbalance :: String -> Integer
on imbalance(strBrackets)
script
on errorIndex(xs, iDepth, iIndex)
set lngChars to length of xs
if lngChars > 0 then
set iNext to iDepth + cond(item 1 of xs = "[", 1, -1)
if iNext < 0 then -- closing bracket unmatched
iIndex
else
if lngChars > 1 then -- continue recursively
errorIndex(items 2 thru -1 of xs, iNext, iIndex + 1)
else -- end of string
cond(iNext = 0, -1, iIndex)
end if
end if
else
cond(iDepth = 0, -1, iIndex)
end if
end errorIndex
end script
result's errorIndex(characters of strBrackets, 0, 0)
end imbalance
-- TEST ----------------------------------------------------------------------
-- Random bracket sequences for testing
-- brackets :: Int -> String
on randomBrackets(n)
-- bracket :: () -> String
script bracket
on |λ|(_)
cond((random number) < 0.5, "[", "]")
end |λ|
end script
intercalate("", map(bracket, enumFromTo(1, n)))
end randomBrackets
on run
set nPairs to 6
-- report :: Int -> String
script report
property strPad : concat(replicate(nPairs * 2 + 4, space))
on |λ|(n)
set w to n * 2
set s to randomBrackets(w)
set i to imbalance(s)
set blnOK to (i = -1)
set strStatus to cond(blnOK, "OK", "problem")
set strLine to "'" & s & "'" & ¬
(items (w + 2) thru -1 of strPad) & strStatus
set strPointer to cond(blnOK, ¬
"", linefeed & concat(replicate(i + 1, space)) & "^")
intercalate("", {strLine, strPointer})
end |λ|
end script
linefeed & ¬
intercalate(linefeed, ¬
map(report, enumFromTo(1, nPairs))) & linefeed
end run
-- GENERIC FUNCTIONS ---------------------------------------------------------
-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
tell mReturn(f)
set lng to length of xs
set lst to {}
repeat with i from 1 to lng
set end of lst to |λ|(item i of xs, i, xs)
end repeat
return lst
end tell
end map
-- foldl :: (a -> b -> a) -> a -> [b] -> a
on foldl(f, startValue, xs)
tell mReturn(f)
set v to startValue
set lng to length of xs
repeat with i from 1 to lng
set v to |λ|(v, item i of xs, i, xs)
end repeat
return v
end tell
end foldl
-- Text -> [Text] -> Text
on intercalate(strText, lstText)
set {dlm, my text item delimiters} to {my text item delimiters, strText}
set strJoined to lstText as text
set my text item delimiters to dlm
return strJoined
end intercalate
-- concat :: [[a]] -> [a] | [String] -> String
on concat(xs)
script append
on |λ|(a, b)
a & b
end |λ|
end script
if length of xs > 0 and class of (item 1 of xs) is string then
set empty to ""
else
set empty to {}
end if
foldl(append, empty, xs)
end concat
-- Egyptian multiplication - progressively doubling a list, appending
-- stages of doubling to an accumulator where needed for binary
-- assembly of a target length
-- replicate :: Int -> a -> [a]
on replicate(n, a)
set out to {}
if n < 1 then return out
set dbl to {a}
repeat while (n > 1)
if (n mod 2) > 0 then set out to out & dbl
set n to (n div 2)
set dbl to (dbl & dbl)
end repeat
return out & dbl
end replicate
-- Value of one of two expressions
-- cond :: Bool -> a -> b -> c
on cond(bln, f, g)
if bln then
set e to f
else
set e to g
end if
if class of e is handler then
mReturn(e)'s |λ|()
else
e
end if
end cond
-- enumFromTo :: Int -> Int -> [Int]
on enumFromTo(m, n)
if m > n then
set d to -1
else
set d to 1
end if
set lst to {}
repeat with i from m to n by d
set end of lst to i
end repeat
return lst
end enumFromTo
-- Lift 2nd class handler function into 1st class script wrapper
-- mReturn :: Handler -> Script
on mReturn(f)
if class of f is script then
f
else
script
property |λ| : f
end script
end if
end mReturn

24
Task/Balanced-brackets/Arturo/balanced-brackets.arturo Normal file
View file

@ -0,0 +1,24 @@
isBalanced: function [s][
cnt: 0
loop split s [ch][
if? ch="]" [
cnt: cnt-1
if cnt<0 -> return false
]
else [
if ch="[" -> cnt: cnt+1
]
]
cnt=0
]
loop 1..10 'i [
str: join map 0..(2*i)-1 [x][ sample ["[" "]"]]
prints str
if? isBalanced str -> print " OK"
else -> print " Not OK"
]

32
Task/Balanced-brackets/AutoHotkey/balanced-brackets-1.ahk Normal file
View file

@ -0,0 +1,32 @@
; Generate 10 strings with equal left and right brackets
Loop, 5
{
B = %A_Index%
loop 2
{
String =
Loop % B
String .= "[`n"
Loop % B
String .= "]`n"
Sort, String, Random
StringReplace, String, String,`n,,All
Example .= String " - " IsBalanced(String) "`n"
}
}
MsgBox % Example
return
IsBalanced(Str)
{
Loop, PARSE, Str
{
If A_LoopField = [
i++
Else if A_LoopField = ]
i--
If i < 0
return "NOT OK"
}
Return "OK"
}

23
Task/Balanced-brackets/AutoHotkey/balanced-brackets-2.ahk Normal file
View file

@ -0,0 +1,23 @@
Loop, 5
{
B = %A_Index%
loop 2
{
String =
Loop % B
String .= "[`n"
Loop % B
String .= "]`n"
Sort, String, Random
StringReplace, String, String,`n,,All
Example .= String " - " IsBalanced(String) "`n"
}
}
MsgBox % Example
return
IsBalanced(Str){
While (Instr(Str,"[]"))
StringReplace, Str, Str,[],,All
Return Str ? "False" : "True"
}

28
Task/Balanced-brackets/AutoIt/balanced-brackets.autoit Normal file
View file

@ -0,0 +1,28 @@
#include <Array.au3>
Local $Array[1]
_ArrayAdd($Array, "[]")
_ArrayAdd($Array, "[][]")
_ArrayAdd($Array, "[[][]]")
_ArrayAdd($Array, "][")
_ArrayAdd($Array, "][][")
_ArrayAdd($Array, "[]][[]")
For $i = 0 To UBound($Array) -1
Balanced_Brackets($Array[$i])
If @error Then
ConsoleWrite($Array[$i] &" = NOT OK"&@CRLF)
Else
ConsoleWrite($Array[$i] &" = OK"&@CRLF)
EndIf
Next
Func Balanced_Brackets($String)
Local $cnt = 0
$Split = Stringsplit($String, "")
For $i = 1 To $Split[0]
If $split[$i] = "[" Then $cnt += 1
If $split[$i] = "]" Then $cnt -= 1
If $cnt < 0 Then Return SetError(1,0,0)
Next
Return 1
EndFunc

57
Task/Balanced-brackets/BASIC/balanced-brackets.basic Normal file
View file

@ -0,0 +1,57 @@
DECLARE FUNCTION checkBrackets% (brackets AS STRING)
DECLARE FUNCTION generator$ (length AS INTEGER)
RANDOMIZE TIMER
DO
x$ = generator$ (10)
PRINT x$,
IF checkBrackets(x$) THEN
PRINT "OK"
ELSE
PRINT "NOT OK"
END IF
LOOP WHILE LEN(x$)
FUNCTION checkBrackets% (brackets AS STRING)
'returns -1 (TRUE) if everything's ok, 0 (FALSE) if not
DIM L0 AS INTEGER, sum AS INTEGER
FOR L0 = 1 TO LEN(brackets)
SELECT CASE MID$(brackets, L0, 1)
CASE "["
sum = sum + 1
CASE "]"
sum = sum - 1
END SELECT
IF sum < 0 THEN
checkBrackets% = 0
EXIT FUNCTION
END IF
NEXT
IF 0 = sum THEN
checkBrackets% = -1
ELSE
checkBrackets% = 0
END IF
END FUNCTION
FUNCTION generator$ (length AS INTEGER)
z = INT(RND * length)
IF z < 1 THEN generator$ = "": EXIT FUNCTION
REDIM x(z * 2) AS STRING
FOR i = 0 TO z STEP 2
x(i) = "["
x(i + 1) = "]"
NEXT
FOR i = 1 TO UBOUND(x)
z = INT(RND * 2)
IF z THEN SWAP x(i), x(i - 1)
NEXT
xx$ = ""
FOR i = 0 TO UBOUND(x)
xx$ = xx$ + x(i)
NEXT
generator$ = xx$
END FUNCTION

21
Task/Balanced-brackets/BASIC256/balanced-brackets.basic Normal file
View file

@ -0,0 +1,21 @@
s$ = "[[]][]"
print s$; " = ";
if not check_brackets(s$) then print "not ";
print "ok"
end
function check_brackets(s$)
level = 0
for i = 1 to length(s$)
c$ = mid(s$, i, 1)
begin case
case c$ = "["
level = level + 1
case c$ = "]"
level = level - 1
if level < 0 then exit for
end case
next i
return level = 0
end function

29
Task/Balanced-brackets/BBC-BASIC/balanced-brackets.basic Normal file
View file

@ -0,0 +1,29 @@
FOR x%=1 TO 10
test$=FNgenerate(RND(10))
PRINT "Bracket string ";test$;" is ";FNvalid(test$)
NEXT x%
END
:
DEFFNgenerate(n%)
LOCAL l%,r%,t%,output$
WHILE l%<n% AND r%<n%
CASE RND(2) OF
WHEN 1:
l%+=1
output$+="["
WHEN 2:
r%+=1
output$+="]"
ENDCASE
ENDWHILE
IF l%=n% THEN output$+=STRING$(n%-r%,"]") ELSE output$+=STRING$(n%-l%,"[")
=output$
:
DEFFNvalid(q$)
LOCAL x%,count%
IF LEN(q$)=0 THEN ="OK."
FOR x%=1 TO LEN(q$)
IF MID$(q$,x%,1)="[" THEN count%+=1 ELSE count%-=1
IF count%<0 THEN ="not OK."
NEXT x%
="OK."

5
Task/Balanced-brackets/BQN/balanced-brackets.bqn Normal file
View file

@ -0,0 +1,5 @@
Gen ← (•rand.Deal⊏⥊⟜"[]") 2⊸×
Bal ← {
Mul ← {a‿b𝕊x‿y: ⟨a+0⌈x-b, y+0⌈b-x⟩}
0‿0 ≡ 0‿0("]["⊸=⊸Mul)´𝕩
}

23
Task/Balanced-brackets/BaCon/balanced-brackets.bacon Normal file
View file

@ -0,0 +1,23 @@
FOR len = 0 TO 18 STEP 2
str$ = ""
DOTIMES len
str$ = str$ & CHR$(IIF(RANDOM(2) = 0, 91, 93))
DONE
status = 0
FOR x = 1 TO LEN(str$)
IF MID$(str$, x, 1) = "[" THEN
INCR status
ELSE
DECR status
FI
IF status < 0 THEN BREAK
NEXT
IF status = 0 THEN
PRINT "OK: ", str$
ELSE
PRINT "BAD: ", str$
ENDIF
NEXT

53
Task/Balanced-brackets/Batch-File/balanced-brackets.bat Normal file
View file

@ -0,0 +1,53 @@
:: Balanced Brackets Task from Rosetta Code
:: Batch File Implementation
@echo off
setlocal enabledelayedexpansion
set "num_pairs=10"
set "num_strings=10"
:: the main thing
for /l %%s in (1, 1, %num_strings%) do (
call :generate
call :check
)
echo(
pause
exit /b 0
:: generate strings of brackets
:generate
set "string="
rem put %num_pairs% number of "[" in string
for /l %%c in (1, 1, %num_pairs%) do set "string=!string!["
rem put %num_pairs% number of "]" in random spots of string
set "ctr=%num_pairs%"
for /l %%c in (1, 1, %num_pairs%) do (
set /a "rnd=!random! %% (!ctr! + 1)"
for %%x in (!rnd!) do (
set "left=!string:~0,%%x!"
set "right=!string:~%%x!"
)
set "string=!left!]!right!"
set /a "ctr+=1"
)
goto :EOF
:: check for balance
:check
set "new=%string%"
:check_loop
if "%new%" equ "" (
echo(
echo(%string% is Balanced.
goto :EOF
) else if "%old%" equ "%new%" ( %== unchangeable already? ==%
echo(
echo(%string% is NOT Balanced.
goto :EOF
)
rem apply rewrite rule "[]" -> null
set "old=%new%"
set "new=%old:[]=%"
goto check_loop

7
Task/Balanced-brackets/Befunge/balanced-brackets.bf Normal file
View file

@ -0,0 +1,7 @@
v > "KO TON" ,,,,,, v
> ~ : 25*- #v_ $ | > 25*, @
> "KO" ,, ^
> : 1991+*+- #v_ v
> \ : 1991+*+- #v_v
\ $
^ < <$<

27
Task/Balanced-brackets/Bracmat/balanced-brackets.bracmat Normal file
View file

@ -0,0 +1,27 @@
( (bal=|"[" !bal "]" !bal)
& ( generate
= a j m n z N S someNumber
. !arg:<1&
| 11^123+13^666+17^321:?someNumber
& (!arg:?n)+1:?N
& :?S
& whl
' (!n+-1:~<0:?n&"[" "]" !S:?S)
& whl
' ( !someNumber:>0
& mod$(!someNumber.!N):?j
& div$(!someNumber.!N):?someNumber
& !S:?a [!j ?m [!N ?z
& !z !m !a:?S
)
& !S
)
& 0:?L
& whl
' ( generate$!L:?S
& put$(str$(!S ":"))
& out
$ (!S:!bal&Balanced|"Not balanced")
& !L+1:<11:?L
)
);

31
Task/Balanced-brackets/Brat/balanced-brackets.brat Normal file
View file

@ -0,0 +1,31 @@
string.prototype.balanced? = {
brackets = []
balanced = true
my.dice.each_while { c |
true? c == "["
{ brackets << c }
{ true? c == "]"
{ last = brackets.pop
false? last == "["
{ balanced = false }
}
}
balanced
}
true? brackets.empty?
{ balanced }
{ false }
}
generate_brackets = { n | (n.of("[") + n.of("]")).shuffle.join }
1.to 10 { n |
test = generate_brackets n
true? test.balanced?
{ p "#{test} is balanced" }
{ p "#{test} is not balanced" }
}

33
Task/Balanced-brackets/C++/balanced-brackets.cpp Normal file
View file

@ -0,0 +1,33 @@
#include <algorithm>
#include <iostream>
#include <string>
std::string generate(int n, char left = '[', char right = ']')
{
std::string str(std::string(n, left) + std::string(n, right));
std::random_shuffle(str.begin(), str.end());
return str;
}
bool balanced(const std::string &str, char left = '[', char right = ']')
{
int count = 0;
for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
{
if (*it == left)
count++;
else if (*it == right)
if (--count < 0) return false;
}
return count == 0;
}
int main()
{
srand(time(NULL)); // seed rng
for (int i = 0; i < 9; ++i)
{
std::string s(generate(i));
std::cout << (balanced(s) ? " ok: " : "bad: ") << s << "\n";
}
}

42
Task/Balanced-brackets/C-sharp/balanced-brackets-1.cs Normal file
View file

@ -0,0 +1,42 @@
using System;
using System.Linq;
class Program
{
static bool IsBalanced(string text, char open = '[', char close = ']')
{
var level = 0;
foreach (var character in text)
{
if (character == close)
{
if (level == 0)
{
return false;
}
level--;
}
if (character == open)
{
level++;
}
}
return level == 0;
}
static string RandomBrackets(int count, char open = '[', char close = ']')
{
var random = new Random();
return string.Join(string.Empty,
(new string(open, count) + new string(close, count)).OrderBy(c => random.Next()));
}
static void Main()
{
for (var count = 0; count < 9; count++)
{
var text = RandomBrackets(count);
Console.WriteLine("\"{0}\" is {1}balanced.", text, IsBalanced(text) ? string.Empty : "not ");
}
}
}

23
Task/Balanced-brackets/C-sharp/balanced-brackets-2.cs Normal file
View file

@ -0,0 +1,23 @@
// simple solution
string input = Console.ReadLine();
if (input.Length % 2 != 0)
{
Console.WriteLine("Not Okay");
return;
}
for (int i = 0; i < input.Length; i++)
{
if (i < input.Length - 1)
{
if (input[i] == '[' && input[i + 1] == ']')
{
input = input.Remove(i, 2);
i = -1;
}
}
}
if (input.Length == 0)
Console.WriteLine("Okay");
else
Console.WriteLine("Not Okay");

43
Task/Balanced-brackets/C/balanced-brackets-1.c Normal file
View file

@ -0,0 +1,43 @@
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int isBal(const char*s,int l){
signed c=0;
while(l--)
if(s[l]==']') ++c;
else if(s[l]=='[') if(--c<0) break;
return !c;
}
void shuffle(char*s,int h){
int x,t,i=h;
while(i--){
t=s[x=rand()%h];
s[x]=s[i];
s[i]=t;
}
}
void genSeq(char*s,int n){
if(n){
memset(s,'[',n);
memset(s+n,']',n);
shuffle(s,n*2);
}
s[n*2]=0;
}
void doSeq(int n){
char s[64];
const char *o="False";
genSeq(s,n);
if(isBal(s,n*2)) o="True";
printf("'%s': %s\n",s,o);
}
int main(){
int n=0;
while(n<9) doSeq(n++);
return 0;
}

9
Task/Balanced-brackets/C/balanced-brackets-2.c Normal file
View file

@ -0,0 +1,9 @@
'': True
'[]': True
']][[': False
'[][][]': True
'[]][[]][': False
'[]][[[[]]]': False
']]]][[[]][[[': False
']]]]]][][[[[[[': False
'[][]][[][[[]]][]': False

51
Task/Balanced-brackets/CLU/balanced-brackets.clu Normal file
View file

@ -0,0 +1,51 @@
% This program needs the random number generator from
% "misc.lib" that comes with PCLU.
shuffle = proc [T: type] (a: array[t])
aT = array[t]
for i: int in int$from_to_by(aT$size(a)-1,0,-1) do
x: int := aT$low(a) + i
y: int := aT$low(a) + random$next(i+1)
temp: T := a[x]
a[x] := a[y]
a[y] := temp
end
end shuffle
brackets = proc (n: int) returns (string)
br: array[char] := array[char]$[]
for i: int in int$from_to(1,2*n) do
if i<=n then array[char]$addh(br, '[')
else array[char]$addh(br, ']')
end
end
shuffle[char](br)
return(string$ac2s(br))
end brackets
balanced = proc (br: string) returns (bool)
depth: int := 0
for c: char in string$chars(br) do
if c='[' then depth := depth + 1
elseif c=']' then depth := depth - 1
end
if depth<0 then return(false) end
end
return(depth = 0)
end balanced
start_up = proc ()
po: stream := stream$primary_output()
d: date := now()
random$seed(d.second + 60*(d.minute + 60*d.hour))
for size: int in int$from_to(0, 10) do
b: string := brackets(size)
stream$puts(po, "\"" || b || "\": ")
if balanced(b) then
stream$putl(po, "balanced")
else
stream$putl(po, "not balanced")
end
end
end start_up

98
Task/Balanced-brackets/COBOL/balanced-brackets.cobol Normal file
View file

@ -0,0 +1,98 @@
IDENTIFICATION DIVISION.
PROGRAM-ID. test-balanced-brackets.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 True-Val CONSTANT 0.
01 False-Val CONSTANT 1.
LOCAL-STORAGE SECTION.
01 current-time PIC 9(10).
01 bracket-type PIC 9.
88 add-open-bracket VALUE 1.
01 bracket-string-area.
03 bracket-string PIC X(10) OCCURS 10 TIMES.
01 i PIC 999.
01 j PIC 999.
PROCEDURE DIVISION.
*> Seed RANDOM().
MOVE FUNCTION CURRENT-DATE (7:10) TO current-time
MOVE FUNCTION RANDOM(current-time) TO current-time
*> Generate random strings of brackets.
PERFORM VARYING i FROM 1 BY 1 UNTIL 10 < i
PERFORM VARYING j FROM 1 BY 1 UNTIL i < j
COMPUTE bracket-type =
FUNCTION REM(FUNCTION RANDOM * 1000, 2)
IF add-open-bracket
MOVE "[" TO bracket-string (i) (j:1)
ELSE
MOVE "]" TO bracket-string (i) (j:1)
END-IF
END-PERFORM
END-PERFORM
*> Display if the strings are balanced or not.
PERFORM VARYING i FROM 1 BY 1 UNTIL 10 < i
CALL "check-if-balanced" USING bracket-string (i)
IF RETURN-CODE = True-Val
DISPLAY FUNCTION TRIM(bracket-string (i))
" is balanced."
ELSE
DISPLAY FUNCTION TRIM(bracket-string (i))
" is not balanced."
END-IF
END-PERFORM
GOBACK
.
END PROGRAM test-balanced-brackets.
IDENTIFICATION DIVISION.
PROGRAM-ID. check-if-balanced.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 True-Val CONSTANT 0.
01 False-Val CONSTANT 1.
LOCAL-STORAGE SECTION.
01 nesting-level PIC S999.
01 i PIC 999.
LINKAGE SECTION.
01 bracket-string PIC X(100).
PROCEDURE DIVISION USING bracket-string.
PERFORM VARYING i FROM 1 BY 1
UNTIL (100 < i)
OR (bracket-string (i:1) = SPACE)
OR (nesting-level < 0)
IF bracket-string (i:1) = "["
ADD 1 TO nesting-level
ELSE
SUBTRACT 1 FROM nesting-level
IF nesting-level < 0
MOVE False-Val TO RETURN-CODE
GOBACK
END-IF
END-IF
END-PERFORM
IF nesting-level = 0
MOVE True-Val TO RETURN-CODE
ELSE
MOVE False-Val TO RETURN-CODE
END-IF
GOBACK
.
END PROGRAM check-if-balanced.

27
Task/Balanced-brackets/Ceylon/balanced-brackets.ceylon Normal file
View file

@ -0,0 +1,27 @@
import com.vasileff.ceylon.random.api {
platformRandom,
Random
}
"""Run the example code for Rosetta Code ["Balanced brackets" task] (http://rosettacode.org/wiki/Balanced_brackets)."""
shared void run() {
value rnd = platformRandom();
for (len in (0..10)) {
value c = generate(rnd, len);
print("``c.padTrailing(20)`` - ``if (balanced(c)) then "OK" else "NOT OK" ``");
}
}
String generate(Random rnd, Integer count)
=> if (count == 0) then ""
else let(length = 2*count,
brackets = zipEntries(rnd.integers(length).take(length),
"[]".repeat(count))
.sort((a,b) => a.key<=>b.key)
.map(Entry.item))
String(brackets);
Boolean balanced(String input)
=> let (value ints = { for (c in input) if (c == '[') then 1 else -1 })
ints.filter((i) => i != 0)
.scan(0)(plus<Integer>)
.every((i) => i >= 0);

14
Task/Balanced-brackets/Clojure/balanced-brackets-1.clj Normal file
View file

@ -0,0 +1,14 @@
(defn gen-brackets [n]
(->> (concat (repeat n \[) (repeat n \]))
shuffle
(apply str ,)))
(defn balanced? [s]
(loop [[first & coll] (seq s)
stack '()]
(if first
(if (= first \[)
(recur coll (conj stack \[))
(when (= (peek stack) \[)
(recur coll (pop stack))))
(zero? (count stack)))))

11
Task/Balanced-brackets/Clojure/balanced-brackets-2.clj Normal file
View file

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

5
Task/Balanced-brackets/Clojure/balanced-brackets-3.clj Normal file
View file

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

15
Task/Balanced-brackets/CoffeeScript/balanced-brackets-1.coffee Normal file
View file

@ -0,0 +1,15 @@
isBalanced = (brackets) ->
openCount = 0
for bracket in brackets
openCount += if bracket is '[' then 1 else -1
return false if openCount < 0
openCount is 0
bracketsCombinations = (n) ->
for i in [0...Math.pow 2, n]
str = i.toString 2
str = '0' + str while str.length < n
str.replace(/0/g, '[').replace(/1/g, ']')
for brackets in bracketsCombinations 4
console.log brackets, isBalanced brackets

17
Task/Balanced-brackets/CoffeeScript/balanced-brackets-2.coffee Normal file
View file

@ -0,0 +1,17 @@
> coffee balanced.coffee
[[[[ false
[[[] false
[[][ false
[[]] true
[][[ false
[][] true
[]][ false
[]]] false
][[[ false
][[] false
][][ false
][]] false
]][[ false
]][] false
]]][ false
]]]] false

21
Task/Balanced-brackets/Commodore-BASIC/balanced-brackets.basic Normal file
View file

@ -0,0 +1,21 @@
10 PRINT CHR$(147): REM CLEAR SCREEN
20 FOR N=1 TO 7
30 READ S$
40 IF S$="" THEN PRINT"(EMPTY)";: GOTO 60
50 PRINT S$;
60 PRINT TAB(20);
70 GOSUB 1000
80 NEXT N
90 END
100 REM ********************************
1000 S = 0
1010 FOR K=1 TO LEN(S$)
1020 C$ = MID$(S$,K,1)
1030 IF C$="[" THEN S = S+1
1040 IF C$="]" THEN S = S-1
1050 IF S<0 THEN PRINT "NOT OK": RETURN
1060 NEXT K
1070 IF S=0 THEN PRINT "OK": RETURN
1090 PRINT "NOT OK"
1100 RETURN
2000 DATA , [], ][, [][], ][][, [[][]], []][[]

27
Task/Balanced-brackets/Common-Lisp/balanced-brackets.lisp Normal file
View file

@ -0,0 +1,27 @@
(defun string-of-brackets (n)
(let* ((len (* 2 n))
(res (make-string len))
(opening (/ len 2))
(closing (/ len 2)))
(dotimes (i len res)
(setf (aref res i)
(cond ((zerop opening) #\])
((zerop closing) #\[)
(t (if (= (random 2) 0)
(progn (decf opening) #\[)
(progn (decf closing) #\]))))))))
(defun balancedp (string)
(zerop (reduce (lambda (nesting bracket)
(ecase bracket
(#\] (if (= nesting 0)
(return-from balancedp nil)
(1- nesting)))
(#\[ (1+ nesting))))
string
:initial-value 0)))
(defun show-balanced-brackets ()
(dotimes (i 10)
(let ((s (string-of-brackets i)))
(format t "~3A: ~A~%" (balancedp s) s))))

60
Task/Balanced-brackets/Component-Pascal/balanced-brackets.pas Normal file
View file

@ -0,0 +1,60 @@
MODULE Brackets;
IMPORT StdLog, Args, Stacks (* See Task Stacks *);
TYPE
Character = POINTER TO RECORD (Stacks.Object)
c: CHAR
END;
PROCEDURE NewCharacter(c: CHAR): Character;
VAR
n: Character;
BEGIN
NEW(n);n.c:= c;RETURN n
END NewCharacter;
PROCEDURE (c: Character) Show*;
BEGIN
StdLog.String("Character(");StdLog.Char(c.c);StdLog.String(");");StdLog.Ln
END Show;
PROCEDURE CheckBalance(str: ARRAY OF CHAR): BOOLEAN;
VAR
s: Stacks.Stack;
n,x: ANYPTR;
i: INTEGER;
c : CHAR;
BEGIN
i := 0; s := Stacks.NewStack();
WHILE (i < LEN(str$)) & (~Args.IsBlank(str[i])) & (str[i] # 0X) DO
IF s.Empty() THEN
s.Push(NewCharacter(str[i]));
ELSE
n := s.top.data;
WITH
n : Character DO
IF (str[i] = ']')& (n.c = '[') THEN
x := s.Pop();
ELSE
s.Push(NewCharacter(str[i]))
END;
ELSE RETURN FALSE;
END;
END;
INC(i)
END;
RETURN s.Empty();
END CheckBalance;
PROCEDURE Do*;
VAR
p : Args.Params;
i: INTEGER;
BEGIN
Args.Get(p); (* Get Params *)
FOR i := 0 TO p.argc - 1 DO
StdLog.String(p.args[i] + ":>");StdLog.Bool(CheckBalance(p.args[i]));StdLog.Ln
END
END Do;
END Brackets.

26
Task/Balanced-brackets/Crystal/balanced-brackets.crystal Normal file
View file

@ -0,0 +1,26 @@
def generate(n : Int)
(['[',']'] * n).shuffle.join # Implicit return
end
def is_balanced(str : String)
count = 0
str.each_char do |ch|
case ch
when '['
count += 1
when ']'
count -= 1
if count < 0
return false
end
else
return false
end
end
count == 0
end
10.times do |i|
str = generate(i)
puts "#{str}: #{is_balanced(str)}"
end

8
Task/Balanced-brackets/D/balanced-brackets-1.d Normal file
View file

@ -0,0 +1,8 @@
import std.stdio, std.algorithm, std.random, std.range;
void main() {
foreach (immutable i; 1 .. 9) {
immutable s = iota(i * 2).map!(_ => "[]"[uniform(0, 2)]).array;
writeln(s.balancedParens('[', ']') ? " OK: " : "bad: ", s);
}
}

23
Task/Balanced-brackets/D/balanced-brackets-2.d Normal file
View file

@ -0,0 +1,23 @@
import std.stdio, std.random, std.range, std.algorithm;
bool isBalanced(in string txt) pure nothrow {
auto count = 0;
foreach (immutable c; txt) {
if (c == ']') {
count--;
if (count < 0)
return false;
} else if (c == '[')
count++;
}
return count == 0;
}
void main() {
foreach (immutable i; 1 .. 9) {
immutable s = iota(i * 2).map!(_ => "[]"[uniform(0, 2)]).array;
writeln(s.isBalanced ? " OK " : "Bad ", s);
}
}

19
Task/Balanced-brackets/D/balanced-brackets-3.d Normal file
View file

@ -0,0 +1,19 @@
import std.stdio, std.random, std.range, std.algorithm;
bool isBalanced(in string s, in char[2] pars="[]") pure nothrow @safe @nogc {
bool bal(in string t, in int nb = 0) pure nothrow @safe @nogc {
if (!nb && t.empty) return true;
if (t.empty || nb < 0) return false;
if (t[0] == pars[0]) return bal(t.dropOne, nb + 1);
if (t[0] == pars[1]) return bal(t.dropOne, nb - 1);
return bal(t.dropOne, nb); // Ignore char.
}
return bal(s);
}
void main() {
foreach (immutable i; 1 .. 9) {
immutable s = iota(i * 2).map!(_ => "[]"[uniform(0, $)]).array;
writeln(s.isBalanced ? " OK " : "Bad ", s);
}
}

31
Task/Balanced-brackets/Delphi/balanced-brackets.delphi Normal file
View file

@ -0,0 +1,31 @@
procedure Balanced_Brackets;
var BracketsStr : string;
TmpStr : string;
I,J : integer;
begin
Randomize;
for I := 1 to 9 do
begin
{ Create a random string of 2*N chars with N*"[" and N*"]" }
TmpStr := '';
for J := 1 to I do
TmpStr := '['+TmpStr+']';
BracketsStr := '';
while TmpStr > '' do
begin
J := Random(Length(TmpStr))+1;
BracketsStr := BracketsStr+TmpStr[J];
Delete(TmpStr,J,1);
end;
TmpStr := BracketsStr;
{ Test for balanced brackets }
while Pos('[]',TmpStr) > 0 do
Delete(TmpStr,Pos('[]',TmpStr),2);
if TmpStr = '' then
writeln(BracketsStr+': OK')
else
writeln(BracketsStr+': not OK');
end;
end;

28
Task/Balanced-brackets/EchoLisp/balanced-brackets.l Normal file
View file

@ -0,0 +1,28 @@
(define (balance str)
(for/fold (closed 0) ((par str))
#:break (< closed 0 ) => closed
(+ closed
(cond
((string=? par "[") 1)
((string=? par "]") -1)
(else 0)))))
(define (task N)
(define str (list->string (append (make-list N "[") (make-list N "]"))))
(for ((i 10))
(set! str (list->string (shuffle (string->list str))))
(writeln (if (zero? (balance str)) '👍 '❌ ) str)))
(task 4)
❌ "[]]][[]["
❌ "]][][[[]"
❌ "][[[]]]["
👍 "[][[[]]]"
❌ "]][[][]["
❌ "][][[[]]"
👍 "[][][[]]"
❌ "]][[][[]"
❌ "[[]]][[]"
❌ "[[][]]]["

37
Task/Balanced-brackets/Ecstasy/balanced-brackets.ecstasy Normal file
View file

@ -0,0 +1,37 @@
module BalancedBrackets {
Boolean balanced(String text) {
Int depth = 0;
for (Char ch : text) {
switch (ch, depth) {
case ('[', _):
++depth;
break;
case (']', 0):
return False;
case (']', _):
--depth;
break;
}
}
return depth==0;
}
@Inject Console console;
void run() {
String[] tests =
[
"[]",
"[][]",
"[]][[]",
"[[[]][]]",
"][[[[]][]]",
"[[[]][[]][]]",
"]][[]][[[[][]]",
"[[]]]][]][[][[[]",
];
Int longest = tests.map(s -> s.size).reduce(0, (max, len) -> max.maxOf(len));
for (String test : tests) {
console.print($"{test}{' ' * (longest-test.size)} {balanced(test) ? "OK" : "NOT OK"}");
}
}
}

46
Task/Balanced-brackets/Elena/balanced-brackets.elena Normal file
View file

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

27
Task/Balanced-brackets/Elixir/balanced-brackets.elixir Normal file
View file

@ -0,0 +1,27 @@
defmodule Balanced_brackets do
def task do
Enum.each(0..5, fn n ->
brackets = generate(n)
result = is_balanced(brackets) |> task_balanced
IO.puts "#{brackets} is #{result}"
end)
end
defp generate( 0 ), do: []
defp generate( n ) do
for _ <- 1..2*n, do: Enum.random ["[", "]"]
end
def is_balanced( brackets ), do: is_balanced_loop( brackets, 0 )
defp is_balanced_loop( _, n ) when n < 0, do: false
defp is_balanced_loop( [], 0 ), do: true
defp is_balanced_loop( [], _n ), do: false
defp is_balanced_loop( ["[" | t], n ), do: is_balanced_loop( t, n + 1 )
defp is_balanced_loop( ["]" | t], n ), do: is_balanced_loop( t, n - 1 )
defp task_balanced( true ), do: "OK"
defp task_balanced( false ), do: "NOT OK"
end
Balanced_brackets.task

29
Task/Balanced-brackets/Erlang/balanced-brackets.erl Normal file
View file

@ -0,0 +1,29 @@
-module( balanced_brackets ).
-export( [generate/1, is_balanced/1, task/0] ).
generate( N ) ->
[generate_bracket(random:uniform()) || _X <- lists:seq(1, 2*N)].
is_balanced( String ) -> is_balanced_loop( String, 0 ).
task() ->
lists:foreach( fun (N) ->
String = generate( N ),
Result = is_balanced( String ),
io:fwrite( "~s is ~s~n", [String, task_balanced(Result)] )
end,
lists:seq(0, 5) ).
is_balanced_loop( _String, N ) when N < 0 -> false;
is_balanced_loop( [], 0 ) -> true;
is_balanced_loop( [], _N ) -> false;
is_balanced_loop( [$[ | T], N ) -> is_balanced_loop( T, N + 1 );
is_balanced_loop( [$] | T], N ) -> is_balanced_loop( T, N - 1 ).
generate_bracket( N ) when N =< 0.5 -> $[;
generate_bracket( N ) when N > 0.5 -> $].
task_balanced( true ) -> "OK";
task_balanced( false ) -> "NOT OK".

45
Task/Balanced-brackets/Euphoria/balanced-brackets.euphoria Normal file
View file

@ -0,0 +1,45 @@
function check_brackets(sequence s)
integer level
level = 0
for i = 1 to length(s) do
if s[i] = '[' then
level += 1
elsif s[i] = ']' then
level -= 1
if level < 0 then
return 0
end if
end if
end for
return level = 0
end function
function generate_brackets(integer n)
integer opened,closed,r
sequence s
opened = n
closed = n
s = ""
for i = 1 to n*2 do
r = rand(opened+closed)
if r<=opened then
s &= '['
opened -= 1
else
s &= ']'
closed -= 1
end if
end for
return s
end function
sequence s
for i = 1 to 10 do
s = generate_brackets(3)
puts(1,s)
if check_brackets(s) then
puts(1," OK\n")
else
puts(1," NOT OK\n")
end if
end for

86
Task/Balanced-brackets/Excel/balanced-brackets-1.excel Normal file
View file

@ -0,0 +1,86 @@
bracketReport
=LAMBDA(bracketPair,
LAMBDA(s,
LET(
depths, SCANLCOLS(
LAMBDA(depth, charDelta,
depth + charDelta
)
)(0)(
codesFromBrackets(bracketPair)(
MID(s,
SEQUENCE(1, LEN(s), 1, 1),
1
)
)
),
overClosePosn, IFNA(MATCH(-1, depths, 0), 0),
IF(0 <> overClosePosn,
"Overclosed at char " & (overClosePosn - 1),
IF(0 <> LASTCOL(depths),
"Underclosed by end",
"OK"
)
)
)
)
)
testRandomBrackets
=LAMBDA(bracketPair,
LAMBDA(n,
LET(
sample, CONCAT(
bracketFromCode(bracketPair)(
RANDARRAY(1, n, -1, 1, TRUE)
)
),
APPENDCOLS(sample)(
bracketReport(bracketPair)(sample)
)
)
)
)
bracketFromCode
=LAMBDA(bracketPairString,
LAMBDA(c,
IF(0 <> c,
IF(0 < c,
MID(bracketPairString, 1, 1),
MID(bracketPairString, 2, 1)
),
"x"
)
)
)
codesFromBrackets
=LAMBDA(bracketPair,
LAMBDA(s,
LAMBDA(c,
LET(
posn, IFERROR(
FIND(c, bracketPair),
0
),
rem, "0 for non-bracket chars, (1, -1) for (open, close)",
IF(0 <> posn,
IF(1 < posn, -1, 1),
0
)
)
)(
MID(s,
SEQUENCE(1, LEN(s), 1, 1),
1
)
)
)
)

110
Task/Balanced-brackets/Excel/balanced-brackets-2.excel Normal file
View file

@ -0,0 +1,110 @@
APPENDCOLS
=LAMBDA(xs,
LAMBDA(ys,
LET(
nx, COLUMNS(xs),
colIndexes, SEQUENCE(1, nx + COLUMNS(ys)),
rowIndexes, SEQUENCE(MAX(ROWS(xs), ROWS(ys))),
IFERROR(
IF(nx < colIndexes,
INDEX(ys, rowIndexes, colIndexes - nx),
INDEX(xs, rowIndexes, colIndexes)
),
NA()
)
)
)
)
CHARSROW
=LAMBDA(s,
MID(s,
SEQUENCE(1, LEN(s), 1, 1),
1
)
)
HEADCOL
=LAMBDA(xs,
LET(REM, "The first item of each column in xs",
INDEX(xs, 1, SEQUENCE(1, COLUMNS(xs)))
)
)
HEADROW
=LAMBDA(xs,
LET(REM, "The first item of each row in xs",
INDEX(
xs,
SEQUENCE(ROWS(xs)),
SEQUENCE(1, 1)
)
)
)
LASTCOL
=LAMBDA(xs,
INDEX(
xs,
SEQUENCE(ROWS(xs), 1, 1, 1),
COLUMNS(xs)
)
)
SCANLCOLS
=LAMBDA(op,
LAMBDA(a,
LAMBDA(xs,
APPENDCOLS(a)(
LET(
b, op(a, HEADROW(xs)),
IF(2 > COLUMNS(xs),
b,
SCANLCOLS(op)(b)(
TAILROW(xs)
)
)
)
)
)
)
)
TAILCOL
=LAMBDA(cols,
LET(REM, "The tail of each column in the grid.",
INDEX(
cols,
SEQUENCE(ROWS(cols) - 1, 1, 2, 1),
SEQUENCE(1, COLUMNS(cols))
)
)
)
TAILROW
=LAMBDA(xs,
LET(REM,"The tail of each row in the grid",
n, COLUMNS(xs) - 1,
IF(0 < n,
INDEX(
xs,
SEQUENCE(ROWS(xs), 1, 1, 1),
SEQUENCE(1, n, 2, 1)
),
NA()
)
)
)

22
Task/Balanced-brackets/F-Sharp/balanced-brackets.fs Normal file
View file

@ -0,0 +1,22 @@
let isBalanced str =
let rec loop count = function
| ']'::_ when count = 0 -> false
| '['::xs -> loop (count+1) xs
| ']'::xs -> loop (count-1) xs
| [] -> count = 0
| _::_ -> false
str |> Seq.toList |> loop 0
let shuffle arr =
let rnd = new System.Random()
Array.sortBy (fun _ -> rnd.Next()) arr
let generate n =
new string( String.replicate n "[]" |> Array.ofSeq |> shuffle )
for n in 1..10 do
let s = generate n
printfn "\"%s\" is balanced: %b" s (isBalanced s)

22
Task/Balanced-brackets/Factor/balanced-brackets-1.factor Normal file
View file

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

20
Task/Balanced-brackets/Factor/balanced-brackets-2.factor Normal file
View file

@ -0,0 +1,20 @@
USING: io formatting locals kernel math sequences unicode.case ;
IN: balanced-brackets
: map-braces ( -- qout )
[
{
{ "[" [ drop 1 ] }
{ "]" [ drop -1 ] }
[ drop 0 ]
} case
]
;
: balanced? ( str -- ? )
map-braces map sum 0 =
;
"[1+2*[3+4*[5+6]-3]*4-[3*[3+3]]]" balanced?
-- Data stack:
t

39
Task/Balanced-brackets/Fantom/balanced-brackets.fantom Normal file
View file

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

23
Task/Balanced-brackets/Forth/balanced-brackets.fth Normal file
View file

@ -0,0 +1,23 @@
include lib/choose.4th ( n1 -- n2)
include lib/ctos.4th ( n -- a 1)
10 constant /[] \ maximum number of brackets
/[] string [] \ string with brackets
\ create string with brackets
: make[] ( --)
0 dup [] place /[] choose 0 ?do 2 choose 2* [char] [ + c>s [] +place loop
; \ empty string, fill with brackets
\ evaluate string
: eval[] ( --)
[] count 2dup over chars + >r swap type 0
begin \ setup string and count
over r@ < \ reached end of string?
while \ if not ..
dup 0< 0= \ unbalanced ]?
while \ if not ..
over c@ [char] \ - negate + swap char+ swap
repeat \ evaluate, goto next character
r> drop if ." NOT" then ." OK" cr drop
; \ evaluate string and print result
make[] eval[]

97
Task/Balanced-brackets/Fortran/balanced-brackets.f Normal file
View file

@ -0,0 +1,97 @@
! $ gfortran -g -O0 -std=f2008 -Wall f.f08 -o f.exe
! $ ./f
! compiles syntax error
! :
! : ][
! : ]][[
! :[[[]]]
! : ][[][]][
! : ][[]]][[[]
! : ]]]][]][[[[[
! : ]]]][][]][[[[[
! : ][[[]]]]][]][[[[
! : [[][]]][]]][[[][[]
! : ]]][[][[[[[[[[]]]]]]
! :[[][[[][]]][]]
! :[[[][]][][[[]][]][]]
program balanced_brackets
implicit none
integer :: N
character(len=20) :: brackets, fmt
write(6,*)'compiles syntax error'
call random_seed
do N=0, 10
call generate(N, brackets)
if (balanced(brackets)) then
fmt = '(a,a20)'
else
fmt = '(a,21x,a20)'
end if
write(6,fmt)':',brackets
end do
brackets = '[[][[[][]]][]]'
if (balanced(brackets)) then
fmt = '(a,a20)'
else
fmt = '(a,21x,a20)'
end if
write(6,fmt)':',brackets
N = 10
call generate(N, brackets)
do while (.not. balanced(brackets)) ! show a balanced set
call generate(N, brackets)
end do
fmt = '(a,a20)'
write(6,fmt)':',brackets
contains
logical function balanced(s)
implicit none
character(len=*), intent(in) :: s
integer :: i, a, n
n = len_trim(s)
a = 0
balanced = .true.
do i=1, n
if (s(i:i) == '[') then
a = a+1
else
a = a-1
end if
balanced = balanced .and. (0 <= a)
end do
end function balanced
subroutine generate(N, s)
implicit none
integer, intent(in) :: N
character(len=*), intent(out) :: s
integer :: L, R, i
real, dimension(2*N) :: harvest
character :: c
i = 1
L = 0
R = 0
s = ' '
call random_number(harvest)
do while ((L < N) .and. (R < N))
if (harvest(i) < 0.5) then
L = L+1
s(i:i) = '['
else
R = R+1
s(i:i) = ']'
end if
i = i+1
end do
c = merge('[', ']', L < N)
do while (i <= 2*N)
s(i:i) = c
i = i+1
end do
end subroutine generate
end program balanced_brackets

45
Task/Balanced-brackets/FreeBASIC/balanced-brackets.basic Normal file
View file

@ -0,0 +1,45 @@
' FB 1.05.0 Win64
Function isBalanced(s As String) As Boolean
If s = "" Then Return True
Dim countLeft As Integer = 0 '' counts number of left brackets so far unmatched
Dim c As String
For i As Integer = 1 To Len(s)
c = Mid(s, i, 1)
If c = "[" Then
countLeft += 1
ElseIf countLeft > 0 Then
countLeft -= 1
Else
Return False
End If
Next
Return countLeft = 0
End Function
' checking examples in task description
Dim brackets(1 To 7) As String = {"", "[]", "][", "[][]", "][][", "[[][]]", "[]][[]"}
For i As Integer = 1 To 7
Print IIf(brackets(i) <> "", brackets(i), "(empty)"); Tab(10); IIf(isBalanced(brackets(i)), "OK", "NOT OK")
Next
' checking 7 random strings of brackets of length 8 say
Randomize
Dim r As Integer '' 0 will signify "[" and 1 will signify "]"
Dim s As String
For i As Integer = 1 To 7
s = Space(8)
For j As Integer = 1 To 8
r = Int(Rnd * 2)
If r = 0 Then
Mid(s, j) = "["
Else
Mid(s, j) = "]"
End If
Next j
Print s; Tab(10); IIf(isBalanced(s), "OK", "NOT OK")
Next i
Print
Print "Press any key to quit"
Sleep

44
Task/Balanced-brackets/FutureBasic/balanced-brackets.basic Normal file
View file

@ -0,0 +1,44 @@
include "NSLog.incl"
local fn BracketBalance( strWithBracket as CFStringRef ) as CFStringRef
NSInteger i, bracketTracker = 0
CFStringRef result
CFCharacterSetRef bracketSet = fn CharacterSetWithCharactersInString( @"[]" )
CFCharacterSetRef bracketsOnlySet = fn CharacterSetInvertedSet( bracketSet )
CFArrayRef trimmedSArray = fn StringComponentsSeparatedByCharactersInSet( strWithBracket, bracketsOnlySet )
CFStringRef trimmedStr = fn ArrayComponentsJoinedByString( trimmedSArray, @"" )
NSUInteger strLen = len( trimmedStr )
// Empty string, no brackets
if ( strLen == 0 ) then result = @"No brackets" : exit fn
// String with odd number of brackets is unbalanced
if ( strLen mod 2 ) then result = @"Unbalanced" : exit fn
for i = 0 to strLen - 1
CFStringRef bracket = fn StringWithFormat( @"%C", fn StringCharacterAtIndex( trimmedStr, i ) )
if fn StringisEqual( bracket, @"[" ) then bracketTracker++
if fn StringisEqual( bracket, @"]" ) then bracketTracker--
if bracketTracker < 0 then result = @"Unbalanced" : break
next
if bracketTracker == 0 then result = @"Balanced"
end fn = result
NSLog( @"%12s: %@", fn StringUTF8String( fn BracketBalance( @"" ) ), @"" )
NSLog( @"%12s: %@", fn StringUTF8String( fn BracketBalance( @"[" ) ), @"[" )
NSLog( @"%12s: %@", fn StringUTF8String( fn BracketBalance( @"]" ) ), @"]" )
NSLog( @"%12s: %@", fn StringUTF8String( fn BracketBalance( @"[]" ) ), @"[]" )
NSLog( @"%12s: %@", fn StringUTF8String( fn BracketBalance( @"[[]" ) ), @"[[]" )
NSLog( @"%12s: %@", fn StringUTF8String( fn BracketBalance( @"[]]" ) ), @"[]]" )
NSLog( @"%12s: %@", fn StringUTF8String( fn BracketBalance( @"[][]" ) ), @"[][]" )
NSLog( @"%12s: %@", fn StringUTF8String( fn BracketBalance( @"][" ) ), @"][" )
NSLog( @"%12s: %@", fn StringUTF8String( fn BracketBalance( @"][][" ) ), @"][][" )
NSLog( @"%12s: %@", fn StringUTF8String( fn BracketBalance( @"[[]][][][[][]]" ) ), @"[[]][][][[][]]" )
NSLog( @"%12s: %@", fn StringUTF8String( fn BracketBalance( @"][[]][][][]]][[" ) ), @"][[]][][][]]][[" )
NSLog( @"%12s: %@", fn StringUTF8String( fn BracketBalance( @"[[[abc]][[d]]]]]" ) ), @"[[[abc]][[def]]]]]" )
NSLog( @"%12s: %@", fn StringUTF8String( fn BracketBalance( @"[[[abc]]][[[[[d]]]]]" ) ), @"[[[abc]]][[[[[def]]]]]" )
NSLog( @"%12s: %@", fn StringUTF8String( fn BracketBalance( @"[][abc]]][[[[[d]]]]]" ) ), @"[][abc]]][[[[[def]]]]]" )
NSLog( @"%12s: %@", fn StringUTF8String( fn BracketBalance( @"The quick brown fox" ) ), @"The quick brown fox" )
HandleEvents

36
Task/Balanced-brackets/GAP/balanced-brackets.gap Normal file
View file

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

40
Task/Balanced-brackets/GDScript/balanced-brackets.gd Normal file
View file

@ -0,0 +1,40 @@
extends MainLoop
func generate_brackets(n: int) -> String:
var brackets: Array[String] = []
# Add opening and closing brackets
brackets.resize(2*n)
for i in range(0, 2*n, 2):
brackets[i] = "["
brackets[i+1] = "]"
brackets.shuffle()
return "".join(brackets)
func is_balanced(str: String) -> bool:
var unclosed_brackets := 0
for c in str:
match c:
"[":
unclosed_brackets += 1
"]":
if unclosed_brackets == 0:
return false
unclosed_brackets -= 1
_:
return false
return unclosed_brackets == 0
func _process(_delta: float) -> bool:
randomize()
for i in range(6):
var bracket_string := generate_brackets(i)
if is_balanced(bracket_string):
print("%sOK" % bracket_string.rpad(13))
else:
print("%sNOT OK" % bracket_string.rpad(11))
return true # Exit

73
Task/Balanced-brackets/Gambas/balanced-brackets.gambas Normal file
View file

@ -0,0 +1,73 @@
'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
siNumberOfLines As Short = 20 'Amount of lines to test
'----
Public Sub Main()
Dim sBrks As String[] = GenerateBrackets() 'Get random array to check
Dim sTemp, sHold, sWork As String 'Working variables
Dim siCount As Short 'Counter
For Each sTemp In sBrks 'For each line in the sBrk array (e.g. '[][][][[[[]][]]]')
sWork = sTemp 'Make sWork = sTemp
Repeat 'Repeat
sHold = sWork 'Make sHold = sWork
sWork = Replace(sWork, "[]", "") 'Remove all brackets that match '[]'
Until sHold = sWork 'If sHold = sWork then there are no more '[]' matches
If sWork = "" Then 'So if all the brackets 'Nested' correctly sWork will be empty
Print " OK "; 'Print 'OK'
Else 'Else they did not all match
Print "NOT OK "; 'So print 'NOT OK'
Endif
For siCount = 1 To Len(sTemp) 'Loop through the line of brackets
Print Mid(sTemp, siCount, 1) & " "; 'Print each bracket + a space to make it easier to read
Next
Print 'Print a new line
Next
End
'----
Public Sub GenerateBrackets() As String[] 'Generates an array of random quantities of '[' and ']'
Dim siQty As New Short[] 'To store the random number (of brackets) to put in a line
Dim sBrk As New String[] 'To store the lines of brackets
Dim siNum, siEnd, siLoop As Short 'Various counters
Dim sTemp As String 'Temp string
Repeat 'Repeat
siNum = Rand(0, siNumberOfBrackets) 'Pick a number between 0 and the total number of brackets requested
If Even(siNum) Then siQty.Add(siNum) 'If the number is even then add the number to siQty
Until siQty.Count = siNumberOfLines 'Keep going until we have the number of lines requested
For Each siNum In siQty 'For each number in siQty..(e.g. 6)
Do
siEnd = Rand(0, 1) 'Generate a 0 or a 1
If siEnd = 0 Then sTemp &= "[" 'If '0' then add a '[' bracket
If siEnd = 1 Then sTemp &= "]" 'If '1' then add a ']' bracket
If siNum = 0 Then 'If siNum = 0 then..
sBrk.Add("") 'Add '0' to the array
sTemp = "" 'Clear sTemp
Break 'Exit the Do Loop
Endif
If Len(sTemp) = siNum Then 'If the length of sTemp = the required amount then..
If sTemp Not Begins "]" And sTemp Not Ends "[" Then 'Check to see that sTemp does not start with "]" and does not end with a "["
sBrk.Add(sTemp) 'Add it to the array
sTemp = "" 'Clear sTemp
Break 'Exit the Do Loop
Else 'Else
sTemp = "" 'Clear sTemp
End If 'Try again!
Endif
Loop
Next
Return sBrk 'Return the sBrk array
End

54
Task/Balanced-brackets/Go/balanced-brackets.go Normal file
View file

@ -0,0 +1,54 @@
package main
import (
"bytes"
"fmt"
"math/rand"
"time"
)
func init() {
rand.Seed(time.Now().UnixNano())
}
func generate(n uint) string {
a := bytes.Repeat([]byte("[]"), int(n))
for i := len(a) - 1; i >= 1; i-- {
j := rand.Intn(i + 1)
a[i], a[j] = a[j], a[i]
}
return string(a)
}
func testBalanced(s string) {
fmt.Print(s + ": ")
open := 0
for _,c := range s {
switch c {
case '[':
open++
case ']':
if open == 0 {
fmt.Println("not ok")
return
}
open--
default:
fmt.Println("not ok")
return
}
}
if open == 0 {
fmt.Println("ok")
} else {
fmt.Println("not ok")
}
}
func main() {
rand.Seed(time.Now().UnixNano())
for i := uint(0); i < 10; i++ {
testBalanced(generate(i))
}
testBalanced("()")
}

21
Task/Balanced-brackets/Groovy/balanced-brackets-1.groovy Normal file
View file

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

11
Task/Balanced-brackets/Groovy/balanced-brackets-2.groovy Normal file
View file

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

13
Task/Balanced-brackets/Groovy/balanced-brackets-3.groovy Normal file
View file

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

6
Task/Balanced-brackets/Haskell/balanced-brackets-1.hs Normal file
View file

@ -0,0 +1,6 @@
isMatching :: String -> Bool
isMatching = null . foldl aut []
where
aut ('[':s) ']' = s
-- aut ('{':s) '}' = s -- automaton could be extended
aut s x = x:s

2
Task/Balanced-brackets/Haskell/balanced-brackets-2.hs Normal file
View file

@ -0,0 +1,2 @@
brackets = filter isMatching
$ [1.. ] >>= (`replicateM` "[]{}")

31
Task/Balanced-brackets/Haskell/balanced-brackets-3.hs Normal file
View file

@ -0,0 +1,31 @@
import Control.Monad
import System.Random
import Text.Printf
import VShuffle
-- Return whether a string contains balanced brackets. Nothing indicates a
-- balanced string, while (Just i) means an imbalance was found at, or just
-- after, the i'th bracket. We assume the string contains only brackets.
isBalanced :: String -> Maybe Int
isBalanced = bal (-1) 0
where
bal :: Int -> Int -> String -> Maybe Int
bal _ 0 [] = Nothing
bal i _ [] = Just i
bal i (-1) _ = Just i
bal i n ('[':bs) = bal (i + 1) (n + 1) bs
bal i n (']':bs) = bal (i + 1) (n - 1) bs
-- Print a string, indicating whether it contains balanced brackets. If not,
-- indicate the bracket at which the imbalance was found.
check :: String -> IO ()
check s = maybe (good s) (bad s) (isBalanced s)
where
good = printf "Good \"%s\"\n"
bad s n = printf "Bad \"%s\"\n%*s^\n" s (n + 6) " "
main :: IO ()
main = do
let bs = cycle "[]"
rs <- replicateM 10 newStdGen
zipWithM_ (\n r -> check $ shuffle (take n bs) r) [0,2 ..] rs

30
Task/Balanced-brackets/Haskell/balanced-brackets-4.hs Normal file
View file

@ -0,0 +1,30 @@
module VShuffle
( shuffle
) where
import Data.List (mapAccumL)
import System.Random
import Control.Monad.ST
import qualified Data.Vector as V
import qualified Data.Vector.Generic.Mutable as M
-- Generate a list of array index pairs, each corresponding to a swap.
pairs
:: (Enum a, Random a, RandomGen g)
=> a -> a -> g -> [(a, a)]
pairs l u r = snd $ mapAccumL step r [l .. pred u]
where
step r i =
let (j, r') = randomR (i, u) r
in (r', (i, j))
-- Return a random permutation of the list. We use the algorithm described in
-- http://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#The_modern_algorithm.
shuffle
:: (RandomGen g)
=> [a] -> g -> [a]
shuffle xs r =
V.toList . runST $
do v <- V.unsafeThaw $ V.fromList xs
mapM_ (uncurry $ M.swap v) $ pairs 0 (M.length v - 1) r
V.unsafeFreeze v

42
Task/Balanced-brackets/Haskell/balanced-brackets-5.hs Normal file
View file

@ -0,0 +1,42 @@
import Control.Applicative ((<|>))
import Data.List (findIndex, replicate, scanl)
import Data.List.Split (chunksOf)
import System.Random
-------------------- BALANCED BRACKETS -------------------
nesting :: String -> [Int]
nesting = tail . scanl (flip level) 0
where
level '[' = succ
level ']' = pred
level _ = id
bracketProblemIndex :: String -> Maybe Int
bracketProblemIndex s =
findIndex (< 0) depths <|> unClosed
where
depths = nesting s
unClosed
| 0 /= last depths = Just $ pred (length s)
| otherwise = Nothing
--------------------------- TEST -------------------------
main :: IO ()
main = do
let g = mkStdGen 137
mapM_ (putStrLn . showProblem) $
chunksOf
6
(bracket <$> take 60 (randomRs (0, 1) g))
showProblem s =
case bracketProblemIndex s of
Just i -> s <> ": Unmatched\n" <> replicate i ' ' <> "^"
_ -> s <> ": OK\n"
bracket :: Int -> Char
bracket 0 = '['
bracket _ = ']'

15
Task/Balanced-brackets/Icon/balanced-brackets.icon Normal file
View file

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

3
Task/Balanced-brackets/J/balanced-brackets-1.j Normal file
View file

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

11
Task/Balanced-brackets/J/balanced-brackets-2.j Normal file
View file

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

49
Task/Balanced-brackets/Java/balanced-brackets-1.java Normal file
View file

@ -0,0 +1,49 @@
public class BalancedBrackets {
public static boolean hasBalancedBrackets(String str) {
int brackets = 0;
for (char ch : str.toCharArray()) {
if (ch == '[') {
brackets++;
} else if (ch == ']') {
brackets--;
} else {
return false; // non-bracket chars
}
if (brackets < 0) { // closing bracket before opening bracket
return false;
}
}
return brackets == 0;
}
public static String generateBalancedBrackets(int n) {
assert n % 2 == 0; // if n is odd we can't match brackets
char[] ans = new char[n];
int openBracketsLeft = n / 2;
int unclosed = 0;
for (int i = 0; i < n; i++) {
if (Math.random() >= 0.5 && openBracketsLeft > 0 || unclosed == 0) {
ans[i] = '[';
openBracketsLeft--;
unclosed++;
} else {
ans[i] = ']';
unclosed--;
}
}
return String.valueOf(ans);
}
public static void main(String[] args) {
for (int i = 0; i <= 16; i += 2) {
String brackets = generateBalancedBrackets(i);
System.out.println(brackets + ": " + hasBalancedBrackets(brackets));
}
String[] tests = {"", "[]", "][", "[][]", "][][", "[[][]]", "[]][[]"};
for (String test : tests) {
System.out.println(test + ": " + hasBalancedBrackets(test));
}
}
}

64
Task/Balanced-brackets/Java/balanced-brackets-2.java Normal file
View file

@ -0,0 +1,64 @@
import java.util.ArrayDeque;
import java.util.Deque;
public class BalancedBrackets {
public static boolean areSquareBracketsBalanced(String expr) {
return isBalanced(expr, "", "", "[", "]", false);
}
public static boolean areBracketsBalanced(String expr) {
return isBalanced(expr, "", "", "{([", "})]", false);
}
public static boolean areStringAndBracketsBalanced(String expr) {
return isBalanced(expr, "'\"", "\\\\", "{([", "})]", true);
}
public static boolean isBalanced(String expr, String lit, String esc, String obr, String cbr, boolean other) {
boolean[] inLit = new boolean[lit.length()];
Deque<Character> stack = new ArrayDeque<Character>();
for (int i=0; i<expr.length(); i+=1) {
char c = get(expr, i);
int x;
if ((x = indexOf(inLit, true)) != -1) {
if (c == get(lit, x) && get(expr, i-1) != get(esc, x)) inLit[x] = false;
}
else if ((x = indexOf(lit, c)) != -1)
inLit[x] = true;
else if ((x = indexOf(obr, c)) != -1)
stack.push(get(cbr, x));
else if (indexOf(cbr, c) != -1) {
if (stack.isEmpty() || stack.pop() != c) return false;
}
else if (!other)
return false;
}
return stack.isEmpty();
}
static int indexOf(boolean[] a, boolean b) {
for (int i=0; i<a.length; i+=1) if (a[i] == b) return i;
return -1;
}
static int indexOf(String s, char c) {
return s.indexOf(c);
}
static char get(String s, int i) {
return s.charAt(i);
}
public static void main(String[] args) {
System.out.println("With areSquareBracketsBalanced:");
for (String s: new String[] {
"", "[]", "[][]", "[[][]]", "][", "][][", "[]][[]", "[", "]"
}
) {
System.out.printf("%s: %s\n", s, areSquareBracketsBalanced(s));
}
System.out.println("\nBut also with areStringAndBracketsBalanced:");
for (String s: new String[] {
"x[]", "[x]", "[]x", "([{}])", "([{}]()", "([{ '([{\\'([{' \"([{\\\"([{\" }])",
}
) {
System.out.printf("%s: %s\n", s, areStringAndBracketsBalanced(s));
}
}
}

19
Task/Balanced-brackets/Java/balanced-brackets.java Normal file
View file

@ -0,0 +1,19 @@
grammar balancedBrackets ;
options {
language = Java;
}
bb : {System.out.print("input is: ");} (balancedBrackets {System.out.print($balancedBrackets.text);})* NEWLINE {System.out.println();}
;
balancedBrackets
: OpenBracket balancedBrackets* CloseBracket
;
OpenBracket
: '['
;
CloseBracket
: ']'
;
NEWLINE : '\r'? '\n'
;

17
Task/Balanced-brackets/JavaScript/balanced-brackets-1.js Normal file
View file

@ -0,0 +1,17 @@
function shuffle(str) {
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
return a.join('')
}
function isBalanced(str) {
var a = str, b
do { b = a, a = a.replace(/\[\]/g, '') } while (a != b)
return !a
}
var M = 20
while (M-- > 0) {
var N = Math.random() * 10 | 0, bs = shuffle('['.repeat(N) + ']'.repeat(N))
console.log('"' + bs + '" is ' + (isBalanced(bs) ? '' : 'un') + 'balanced')
}

56
Task/Balanced-brackets/JavaScript/balanced-brackets-2.js Normal file
View file

@ -0,0 +1,56 @@
console.log("Supplied examples");
var tests = ["", "[]", "][", "[][]", "][][", "[[][]]", "[]][[]"];
for (var test of tests)
{
console.log("The string '" + test + "' is " +
(isStringBalanced(test) ? "" : "not ") + "OK.");
}
console.log();
console.log("Random generated examples");
for (var example = 1; example <= 10; example++)
{
var test = generate(Math.floor(Math.random() * 10) + 1);
console.log("The string '" + test + "' is " +
(isStringBalanced(test) ? "" : "not ") + "OK.");
}
function isStringBalanced(str)
{
var paired = 0;
for (var i = 0; i < str.length && paired >= 0; i++)
{
var c = str[i];
if (c == '[')
paired++;
else if (c == ']')
paired--;
}
return (paired == 0);
}
function generate(n)
{
var opensCount = 0, closesCount = 0;
// Choose at random until n of one type generated
var generated = "";
while (opensCount < n && closesCount < n)
{
switch (Math.floor(Math.random() * 2) + 1)
{
case 1:
opensCount++;
generated += "[";
break;
case 2:
closesCount++;
generated += "]";
break;
default:
break;
}
}
// Now pad with the remaining other brackets
generated +=
opensCount == n ? "]".repeat(n - closesCount) : "[".repeat(n - opensCount);
return generated;
}

105
Task/Balanced-brackets/JavaScript/balanced-brackets-3.js Normal file
View file

@ -0,0 +1,105 @@
(() => {
'use strict';
// ---------------- BALANCED BRACKETS ----------------
// firstUnbalancedBracket :: String -> String -> Maybe Int
const firstUnbalancedBracket = brackets =>
haystack => {
const [openBracket, closeBracket] = [...brackets];
const go = (xs, iDepth, iCharPosn) =>
// iDepth: initial nesting depth (0 = closed)
// iCharPosn: starting character position
0 < xs.length ? (() => {
const
h = xs[0],
tail = xs.slice(1),
iNext = iDepth + (
brackets.includes(h) ? (
openBracket === h ? (
1
) : -1
) : 0
);
return 0 > iNext ? (
Just(iCharPosn) // Unmatched closing bracket.
) : 0 < tail.length ? go(
tail, iNext, 1 + iCharPosn
) : 0 !== iNext ? (
Just(iCharPosn)
) : Nothing();
})() : 0 !== iDepth ? (
Just(iCharPosn)
) : Nothing();
return go([...haystack], 0, 0);
};
// ---------------------- TEST -----------------------
// main :: IO ()
const main = () => {
const
intPairs = 6,
strPad = ' '.repeat(4 + (2 * intPairs));
console.log(
enumFromTo(0)(intPairs)
.map(pairCount => {
const
stringLength = 2 * pairCount,
strSample = randomBrackets(stringLength);
return "'" + strSample + "'" +
strPad.slice(2 + stringLength) + maybe('OK')(
iUnMatched => 'problem\n' +
' '.repeat(1 + iUnMatched) + '^'
)(
firstUnbalancedBracket('[]')(strSample)
);
}).join('\n')
);
};
// Int -> String
const randomBrackets = n =>
enumFromTo(1)(n)
.map(() => Math.random() < 0.5 ? (
'['
) : ']').join('');
// --------------------- GENERIC ---------------------
// Just :: a -> Maybe a
const Just = x => ({
type: 'Maybe',
Nothing: false,
Just: x
});
// Nothing :: Maybe a
const Nothing = () => ({
type: 'Maybe',
Nothing: true,
});
// enumFromTo :: Int -> Int -> [Int]
const enumFromTo = m =>
n => !isNaN(m) ? (
Array.from({
length: 1 + n - m
}, (_, i) => m + i)
) : enumFromTo_(m)(n);
// maybe :: b -> (a -> b) -> Maybe a -> b
const maybe = v =>
// Default value (v) if m is Nothing, or f(m.Just)
f => m => m.Nothing ? (
v
) : f(m.Just);
// ---
return main();
})();

33
Task/Balanced-brackets/Jq/balanced-brackets-1.jq Normal file
View file

@ -0,0 +1,33 @@
< /dev/random tr -cd '0-9' | fold -w 1 | jq -Mcnr '
# Output: a PRN in range(0;$n) where $n is .
def prn:
if . == 1 then 0
else . as $n
| (($n-1)|tostring|length) as $w
| [limit($w; inputs)] | join("") | tonumber
| if . < $n then . else ($n | prn) end
end;
def prb: 2 | prn == 0;
def balanced:
{array: explode, parity: 0}
| until( .result | type == "boolean";
if .array == [] then .result = (.parity == 0)
else .parity += (.array[0] | if . == 91 then 1 else -1 end)
| if .parity < 0 then .result = false
else .array |= .[1:]
end
end ).result ;
def task($n):
if $n%2 == 1 then null
else [ (range(0; $n) | if prb then "[" else "]" end) // ""]
| add
| "\(.): \(balanced)"
end;
task(0),
task(2),
(range(0;10) | task(4))

19
Task/Balanced-brackets/Jq/balanced-brackets-2.jq Normal file
View file

@ -0,0 +1,19 @@
def prb: (now|tostring[-1:] | tonumber) % 2 == 0;
def balanced:
if length==0 then true
elif .[:1] == "]" then false
else test("[[][]]") and (gsub("[[][]]"; "") | balanced)
end;
def task($n):
if $n%2 == 1 then null
else
(reduce range(0; $n) as $i ("";
. + (if prb then "[" else "]" end) ))
| "\(.): \(balanced)"
end;
task(0),
task(2),
(range(0;10) | task(4))

16
Task/Balanced-brackets/Julia/balanced-brackets-1.julia Normal file
View file

@ -0,0 +1,16 @@
using Printf
function balancedbrackets(str::AbstractString)
i = 0
for c in str
if c == '[' i += 1 elseif c == ']' i -=1 end
if i < 0 return false end
end
return i == 0
end
brackets(n::Integer) = join(shuffle(collect(Char, "[]" ^ n)))
for (test, pass) in map(x -> (x, balancedbrackets(x)), collect(brackets(i) for i = 0:8))
@printf("%22s%10s\n", test, pass ? "pass" : "fail")
end

1
Task/Balanced-brackets/Julia/balanced-brackets-2.julia Normal file
View file

@ -0,0 +1 @@
balancedbrackets(str::AbstractString) = foldl((x, y) -> x < 0 ? -1 : x + y, collect((x == '[') - (x == ']') for x in str), init = 0) == 0

14
Task/Balanced-brackets/K/balanced-brackets.k Normal file
View file

@ -0,0 +1,14 @@
gen_brackets:{"[]"@x _draw 2}
check:{r:(-1;1)@"["=x; *(0=+/cs<'0)&(0=-1#cs:+\r)}
{(x;check x)}' gen_brackets' 2*1+!10
(("[[";0)
("[][]";1)
("][][]]";0)
("[[][[][]";0)
("][]][[[[[[";0)
("]]][[]][]]][";0)
("[[[]][[[][[[][";0)
("[[]][[[]][]][][]";1)
("][[][[]]][[]]]][][";0)
("]][[[[]]]][][][[]]]]";0))

18
Task/Balanced-brackets/Klingphix/balanced-brackets.klingphix Normal file
View file

@ -0,0 +1,18 @@
"[[]][]]"
%acc 0 !acc
%flag false !flag
len [
get tochar dup
"[" == [$acc 1 + !acc] if
"]" == [$acc 1 - !acc] if
$acc 0 < [true !flag] if
] for
print
$acc 0 # $flag or ( [" is NOT ok"] [" is OK"] ) if
print
" " input

32
Task/Balanced-brackets/Kotlin/balanced-brackets.kotlin Normal file
View file

@ -0,0 +1,32 @@
import java.util.Random
fun isBalanced(s: String): Boolean {
if (s.isEmpty()) return true
var countLeft = 0 // number of left brackets so far unmatched
for (c in s) {
if (c == '[') countLeft++
else if (countLeft > 0) countLeft--
else return false
}
return countLeft == 0
}
fun main(args: Array<String>) {
println("Checking examples in task description:")
val brackets = arrayOf("", "[]", "][", "[][]", "][][", "[[][]]", "[]][[]")
for (b in brackets) {
print(if (b != "") b else "(empty)")
println("\t " + if (isBalanced(b)) "OK" else "NOT OK")
}
println()
println("Checking 7 random strings of brackets of length 8:")
val r = Random()
(1..7).forEach {
var s = ""
for (j in 1..8) {
s += if (r.nextInt(2) == 0) '[' else ']'
}
println("$s " + if (isBalanced(s)) "OK" else "NOT OK")
}
}

15
Task/Balanced-brackets/L++/balanced-brackets.l++ Normal file
View file

@ -0,0 +1,15 @@
(include "string")
(defn bool balanced (std::string s)
(def bal 0)
(foreach c s
(if (== c #\[) (++ bal)
(if (== c #\]) (-- bal)))
(if (< bal 0) (return false)))
(return (== bal 0)))
(main
(decl std::string (at tests) |{"", "[]", "[][]", "[[][]]", "][", "][][", "[]][[]"}|)
(pr std::boolalpha)
(foreach x tests
(prn x "\t" (balanced x))))

22
Task/Balanced-brackets/Lasso/balanced-brackets.lasso Normal file
View file

@ -0,0 +1,22 @@
define randomparens(num::integer,open::string='[',close::string=']') => {
local(out) = array
with i in 1 to #num do {
#out->insert(']', integer_random(1,#out->size || 1))
#out->insert('[', integer_random(1,#out->size || 1))
}
return #out->join
}
define validateparens(input::string,open::string='[',close::string=']') => {
local(i) = 0
#input->foreachcharacter => {
#1 == #open ? #i++
#1 == #close && --#i < 0 ? return false
}
return #i == 0 ? true | false
}
with i in 1 to 10
let input = randomparens(#i)
select #input + ' = ' + validateparens(#input)

62
Task/Balanced-brackets/Liberty-BASIC/balanced-brackets.basic Normal file
View file

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

20
Task/Balanced-brackets/Lua/balanced-brackets.lua Normal file
View file

@ -0,0 +1,20 @@
function isBalanced(s)
--Lua pattern matching has a 'balanced' pattern that matches sets of balanced characters.
--Any two characters can be used.
return s:gsub('%b[]','')=='' and true or false
end
function randomString()
math.randomseed(os.time())
math.random()math.random()math.random()math.random()
local tokens={'[',']'}
local result={}
for i=1,8 do
table.insert(result,tokens[math.random(1,2)])
end
return table.concat(result)
end
local RS=randomString()
print(RS)
print(isBalanced(RS))

26
Task/Balanced-brackets/M2000-Interpreter/balanced-brackets.m2000 Normal file
View file

@ -0,0 +1,26 @@
module Balanced_brackets{
// Generate a string with N opening brackets [ and with N closing brackets ], in some arbitrary order.
function randomBrackets(max as long) {
if max<1 then max=1
def putbracket()=mid$("[[[[]]",random(1,6),1)
dim a(random(1, max)) as string<<putbracket()
=a()#str$("")
}
// Determine whether the generated string is balanced; that is, whether it consists entirely of pairs of opening/closing brackets (in that order), none of which mis-nest.
function check(s as string) {
long i, level
for i=1 to len(s)
if mid$(s,i,1)="[" then level++ else level--
if level<0 then exit for
next
=level=0
}
string k
boolean m
do
k=randomBrackets(10)
m=check(k)
print k;@(12);": ";if$(m->"OK", "NOT OK")
until m
}
Balanced_brackets

4
Task/Balanced-brackets/MATLAB/balanced-brackets.m Normal file
View file

@ -0,0 +1,4 @@
function x = isbb(s)
t = cumsum((s=='[') - (s==']'));
x = all(t>=0) && (t(end)==0);
end;

Some files were not shown because too many files have changed in this diff Show more