PHP Bracket
function bracket(string $s): int
{
    $stack = [];
    foreach (str_split($s) as $v) {
        switch ($v) {
            case ')':
                if (empty($stack) || array_pop($stack) !== '(') {
                    return 0;
                }
                break;
            case ']':
                if (empty($stack) || array_pop($stack) !== '[') {
                    return 0;
                }
                break;
            case '}':
                if (empty($stack) || array_pop($stack) !== '{') {
                    return 0;
                }
                break;
            default:
                if ( ! empty($v)) {
                    $stack[] = $v;
                }
                break;
        }

    }

    return empty($stack) ? 1 : 0;
}

This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.

Python Bracket
def bracket(s: str) -> int:
    closers = {")": "(", "]": "[", "}": "{"}
    stack: list[str] = []

    for ch in s:
        if ch in closers:
            if not stack or stack.pop() != closers[ch]:
                return 0
        elif ch:
            stack.append(ch)

    return 1 if not stack else 0

This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.

Rust Bracket
fn bracket(s: &str) -> i64 {
    let mut stack = Vec::new();
    for c in s.chars() {
        match c {
            ')' => {
                if stack.pop() != Some('(') {
                    return 0;
                }
            }
            ']' => {
                if stack.pop() != Some('[') {
                    return 0;
                }
            }
            '}' => {
                if stack.pop() != Some('{') {
                    return 0;
                }
            }
            _ => stack.push(c),
        }
    }

    if stack.is_empty() { 1 } else { 0 }
}

This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.

TypeScript Bracket
function bracket(s: string): number {
  const stack: string[] = [];

  for (const v of s) {
    switch (v) {
      case ")":
        if (stack.length === 0 || stack.pop() !== "(") {
          return 0;
        }
        break;
      case "]":
        if (stack.length === 0 || stack.pop() !== "[") {
          return 0;
        }
        break;
      case "}":
        if (stack.length === 0 || stack.pop() !== "{") {
          return 0;
        }
        break;
      default:
        if (v) {
          stack.push(v);
        }
        break;
    }
  }

  return stack.length === 0 ? 1 : 0;
}

This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.

Bash Century From Year
century_from_year() {
    local _year=$1
    echo $(( (_year + 99) / 100 ))
}

This converts a year into its century. Years 1-100 are century 1, 101-200 are century 2, and so on.

C++ Century From Year
#include <cmath>

int centuryFromYear(int year)
{
    return static_cast<int>(std::ceil(year / 100.0));
}

This converts a year into its century. Years 1-100 are century 1, 101-200 are century 2, and so on.

C# Century From Year
static int CenturyFromYear(int year)
{
    return (int)Math.Ceiling(year / 100.0);
}

This converts a year into its century. Years 1-100 are century 1, 101-200 are century 2, and so on.

Elixir Century From Year
defmodule CenturyFromYear do
  def century_from_year(year), do: ceil(year / 100)
end

This converts a year into its century. Years 1-100 are century 1, 101-200 are century 2, and so on.

Erlang Century From Year
-module(century_from_year).
-export([century_from_year/1]).

century_from_year(Year) ->
    (Year + 99) div 100.

This converts a year into its century. Years 1-100 are century 1, 101-200 are century 2, and so on.

Go Century From Year
func centuryFromYear(year int) int {
	return int(math.Ceil(float64(year) / 100))
}

This converts a year into its century. Years 1-100 are century 1, 101-200 are century 2, and so on.