96 lines
2.8 KiB
JavaScript
96 lines
2.8 KiB
JavaScript
(() => {
|
|
'use strict';
|
|
|
|
// findUnbalancedBracket :: String -> String -> Maybe Int
|
|
const findUnbalancedBracket = strBrackets => strHaystack => {
|
|
const
|
|
openBracket = strBrackets[0],
|
|
closeBracket = strBrackets[1];
|
|
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 + (
|
|
strBrackets.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(strHaystack.split(''), 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) + '^'
|
|
)(
|
|
findUnbalancedBracket('[]')(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 =>
|
|
Array.from({
|
|
length: 1 + n - m
|
|
}, (_, i) => m + i);
|
|
|
|
// maybe :: b -> (a -> b) -> Maybe a -> b
|
|
const maybe = v => f => m =>
|
|
m.Nothing ? v : f(m.Just);
|
|
|
|
// ---
|
|
return main();
|
|
})();
|