Balanced bracket checker

No reference implementation in this language.

// Balanced bracket checker, TypeScript reference.
// Reads one line of printable ASCII (up to 1000 chars), prints `yes` or `no`.

import { readFileSync } from "node:fs";

function main(): void {
  let line = readFileSync(0, "utf8");
  if (line.endsWith("\n")) line = line.slice(0, -1);
  const stack: string[] = [];
  const pairs: Record<string, string> = { ")": "(", "]": "[", "}": "{" };
  let balanced = true;
  for (const ch of line) {
    if (ch === "(" || ch === "[" || ch === "{") {
      stack.push(ch);
    } else if (ch === ")" || ch === "]" || ch === "}") {
      if (stack.length === 0 || stack[stack.length - 1] !== pairs[ch]) {
        balanced = false;
        break;
      }
      stack.pop();
    }
  }
  if (balanced && stack.length === 0) {
    process.stdout.write("yes\n");
  } else {
    process.stdout.write("no\n");
  }
}

main();

// Balanced bracket checker, Rust reference.
// Reads one line of printable ASCII (up to 1000 chars), prints `yes` or `no`.

use std::io::{self, Read, Write};

fn main() {
    let mut input = String::new();
    io::stdin().read_to_string(&mut input).unwrap();
    if input.ends_with('\n') {
        input.pop();
    }
    let mut stack: Vec<char> = Vec::new();
    let mut balanced = true;
    for ch in input.chars() {
        match ch {
            '(' | '[' | '{' => stack.push(ch),
            ')' => {
                if stack.pop() != Some('(') {
                    balanced = false;
                    break;
                }
            }
            ']' => {
                if stack.pop() != Some('[') {
                    balanced = false;
                    break;
                }
            }
            '}' => {
                if stack.pop() != Some('{') {
                    balanced = false;
                    break;
                }
            }
            _ => {}
        }
    }
    let out = io::stdout();
    let mut h = out.lock();
    if balanced && stack.is_empty() {
        h.write_all(b"yes\n").unwrap();
    } else {
        h.write_all(b"no\n").unwrap();
    }
}

// Balanced bracket checker, Go reference.
// Reads one line of printable ASCII (up to 1000 chars), prints `yes` or `no`.

package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	line, _ := reader.ReadString('\n')
	line = strings.TrimRight(line, "\n")
	stack := make([]byte, 0, 1024)
	balanced := true
	for i := 0; i < len(line); i++ {
		ch := line[i]
		switch ch {
		case '(', '[', '{':
			stack = append(stack, ch)
		case ')':
			if len(stack) == 0 || stack[len(stack)-1] != '(' {
				balanced = false
			} else {
				stack = stack[:len(stack)-1]
			}
		case ']':
			if len(stack) == 0 || stack[len(stack)-1] != '[' {
				balanced = false
			} else {
				stack = stack[:len(stack)-1]
			}
		case '}':
			if len(stack) == 0 || stack[len(stack)-1] != '{' {
				balanced = false
			} else {
				stack = stack[:len(stack)-1]
			}
		}
		if !balanced {
			break
		}
	}
	if balanced && len(stack) == 0 {
		fmt.Print("yes\n")
	} else {
		fmt.Print("no\n")
	}
}

"""Balanced bracket checker, Python reference.

Reads one line of printable ASCII (up to 1000 chars), prints `yes` or `no`.
"""
import sys


def main() -> None:
    line = sys.stdin.readline()
    if line.endswith("\n"):
        line = line[:-1]
    stack: list[str] = []
    pairs = {")": "(", "]": "[", "}": "{"}
    balanced = True
    for ch in line:
        if ch in "([{":
            stack.append(ch)
        elif ch in ")]}":
            if not stack or stack[-1] != pairs[ch]:
                balanced = False
                break
            stack.pop()
    if balanced and not stack:
        sys.stdout.write("yes\n")
    else:
        sys.stdout.write("no\n")


if __name__ == "__main__":
    main()