TypeScript Binary Gap
function binaryGap(n: number): number {
const trimmed = n.toString(2).replace(/^0+|0+$/g, "");
const zeroes = trimmed.split("1");
let gap = 0;
for (const zero of zeroes) {
gap = Math.max(gap, zero.length);
}
return gap;
}
This turns the number into binary, ignores zeroes outside the edges, and finds the longest run of zeroes between 1s.
Bash Bracket
bracket() {
local _s=$1
local -a _stack=()
local _i _c
for ((_i = 0; _i < ${#_s}; _i++)); do
_c=${_s:_i:1}
case "$_c" in
')')
if (( ${#_stack[@]} == 0 )) || [[ "${_stack[-1]}" != "(" ]]; then
echo 0; return
fi
unset '_stack[-1]'
;;
']')
if (( ${#_stack[@]} == 0 )) || [[ "${_stack[-1]}" != "[" ]]; then
echo 0; return
fi
unset '_stack[-1]'
;;
'}')
if (( ${#_stack[@]} == 0 )) || [[ "${_stack[-1]}" != "{" ]]; then
echo 0; return
fi
unset '_stack[-1]'
;;
*)
_stack+=("$_c")
;;
esac
done
if (( ${#_stack[@]} == 0 )); then echo 1; else echo 0; fi
}
This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.
C++ Bracket
#include <string>
#include <vector>
int bracket(const std::string& s)
{
std::vector<char> stack;
for (char c : s) {
switch (c) {
case ')':
if (stack.empty() || stack.back() != '(') {
return 0;
}
stack.pop_back();
break;
case ']':
if (stack.empty() || stack.back() != '[') {
return 0;
}
stack.pop_back();
break;
case '}':
if (stack.empty() || stack.back() != '{') {
return 0;
}
stack.pop_back();
break;
default:
stack.push_back(c);
break;
}
}
return stack.empty() ? 1 : 0;
}
This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.
C# Bracket
static int Bracket(string s)
{
var stack = new Stack<char>();
foreach (var v in s)
{
switch (v)
{
case ')':
if (stack.Count == 0 || stack.Pop() != '(')
{
return 0;
}
break;
case ']':
if (stack.Count == 0 || stack.Pop() != '[')
{
return 0;
}
break;
case '}':
if (stack.Count == 0 || stack.Pop() != '{')
{
return 0;
}
break;
default:
stack.Push(v);
break;
}
}
return stack.Count == 0 ? 1 : 0;
}
This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.
Elixir Bracket
defmodule Bracket do
def bracket(s) do
result =
s
|> String.graphemes()
|> Enum.reduce_while([], fn ch, stack ->
case ch do
")" -> pop_match(stack, "(")
"]" -> pop_match(stack, "[")
"}" -> pop_match(stack, "{")
_ -> {:cont, [ch | stack]}
end
end)
if result == [], do: 1, else: 0
end
defp pop_match([], _expected), do: {:halt, :mismatch}
defp pop_match([top | rest], expected) do
if top == expected, do: {:cont, rest}, else: {:halt, :mismatch}
end
end
This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.
Erlang Bracket
-module(bracket).
-export([bracket/1]).
bracket(S) ->
case close_stack(S, []) of
[] -> 1;
_ -> 0
end.
close_stack([], Stack) -> Stack;
close_stack([$( | T], Stack) -> close_stack(T, [$( | Stack]);
close_stack([$[ | T], Stack) -> close_stack(T, [$[ | Stack]);
close_stack([${ | T], Stack) -> close_stack(T, [${ | Stack]);
close_stack([$) | T], [$( | Stack1]) -> close_stack(T, Stack1);
close_stack([$] | T], [$[ | Stack1]) -> close_stack(T, Stack1);
close_stack([$} | T], [${ | Stack1]) -> close_stack(T, Stack1);
close_stack([$) | _], _) -> error;
close_stack([$] | _], _) -> error;
close_stack([$} | _], _) -> error;
close_stack([_ | T], Stack) -> close_stack(T, Stack).
This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.
Go Bracket
func bracket(s string) int {
pairs := map[byte]byte{')': '(', ']': '[', '}': '{'}
stack := make([]byte, 0, len(s))
for i := 0; i < len(s); i++ {
c := s[i]
if open, isClose := pairs[c]; isClose {
if len(stack) == 0 || stack[len(stack)-1] != open {
return 0
}
stack = stack[:len(stack)-1]
} else {
stack = append(stack, c)
}
}
if len(stack) == 0 {
return 1
}
return 0
}
This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.
Haskell Bracket
bracket :: String -> Int
bracket s = go s []
where
go [] stack = if null stack then 1 else 0
go (c : cs) stack = case c of
')' -> pop '(' cs stack
']' -> pop '[' cs stack
'}' -> pop '{' cs stack
_ -> go cs (c : stack)
pop expected cs (top : rest)
| top == expected = go cs rest
pop _ _ _ = 0
This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.
Java Bracket
import java.util.ArrayDeque;
import java.util.Deque;
public class Solution {
public static int bracket(String s) {
Deque<Character> stack = new ArrayDeque<>();
for (char v : s.toCharArray()) {
switch (v) {
case ')':
if (stack.isEmpty() || stack.pop() != '(') {
return 0;
}
break;
case ']':
if (stack.isEmpty() || stack.pop() != '[') {
return 0;
}
break;
case '}':
if (stack.isEmpty() || stack.pop() != '{') {
return 0;
}
break;
default:
stack.push(v);
break;
}
}
return stack.isEmpty() ? 1 : 0;
}
}
This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.
Lisp Bracket
(defun bracket (s)
(let ((stack '()))
(loop for v across s
do (cond
((char= v #\))
(if (or (null stack) (char/= (pop stack) #\())
(return-from bracket 0)))
((char= v #\])
(if (or (null stack) (char/= (pop stack) #\[))
(return-from bracket 0)))
((char= v #\})
(if (or (null stack) (char/= (pop stack) #\{))
(return-from bracket 0)))
(t (push v stack))))
(if (null stack) 1 0)))
This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.