Скачать или смотреть Python One-Liner: Check for Balanced Parentheses in a String! 🔄✨

Checking for balanced parentheses ensures every opening bracket ((, {, [) is properly closed in the correct order. The Long Way uses an explicit stack and looping logic to push and pop brackets, while the One‑Liner leverages functools.reduce and a lambda to emulate the same stack behavior in a single expression. Both approaches verify that the resultant “stack” is empty only if the string is balanced.

Long Way: Stack‑Based Implementation

def is_balanced(s):
Define matching pairs of brackets
pairs = {'(': ')', '{': '}', '[': ']'}
stack = []

for char in s:
if char in pairs:
Push any opening bracket onto the stack
stack.append(char)
elif char in pairs.values():
If no opening bracket to match, or mismatch, return False
if not stack or pairs[stack.pop()] != char:
return False
If stack is empty, all brackets were matched
return not stack

Example usage:
print(is_balanced("{[()()]}")) # True
print(is_balanced("{[(])}")) # False
print(is_balanced("(((()))")) # False

Explanation

Matching Pairs: We map each opening bracket to its corresponding closing bracket (pairs = {'(': ')', …}).

Stack Operations:

Push when encountering an opening bracket (in "({[").

Pop & Compare when encountering a closing bracket (in ")}]"). If the popped opening bracket doesn’t match, return False.

Python Examples

Final Check: After processing the string, if stack is empty, it means every opening bracket had a correct closing match; otherwise, it’s unbalanced.

One‑Liner: functools.reduce Trick

import functools

print(
functools.reduce(
lambda st, c: st + c
if c in "({["
else (
st[:-1]
if st and dict(zip("({[", ")}]"))[st[-1]] == c
else ["!"]
),
"{[()()]}",
[]
) == []
)
Output: True

Explanation
reduce as a Stack: We treat st (the accumulator) as our stack (a list or string of opening brackets).

Lambda Logic:

Opening Bracket (c in "({["): Append it to st.

Closing Bracket:

Match: If st isn’t empty and the last pushed bracket matches (via dict(zip("({[", ")}]"))), remove it (st[:-1]).

Mismatch: Return a non‑empty sentinel (["!"]) so that final comparison fails.

Initial & Final State:

We start with an empty st.

After reduce, comparing == [] yields True only if all brackets matched and st returned to empty.

Balanced parentheses checks are fundamental in compilers, code linters, and interview questions. By understanding both stack‑based and functional techniques, you’ll be ready for any scenario!

#PythonTips #CodingShorts #BalancedParentheses #DataStructures #Algorithms #PythonOneLiner #Stack #Reduce #Lambda #CodingInterview