Bash Notes on Dan Stefan Oprean

Add

Mon, 01 Jan 0001 00:00:00 +0000

Bash Add

add() {
    echo $(( $1 + $2 ))
}

This just adds the two input numbers with Bash arithmetic and prints the sum.

Add Border

Mon, 01 Jan 0001 00:00:00 +0000

Bash Add Border

add_border() {
    local -n _pic="$1"
    local -n _outPic="$2"
    local _width=${#_pic[0]}
    local _border
    _border=$(printf '%*s' "$_width" '' | tr ' ' '*')
    _outPic=("$_border")
    local _line
    for _line in "${_pic[@]}"; do
        _outPic+=("*${_line}*")
    done
    _outPic+=("$_border")
}

This builds a new grid with a * border around every side. It adds a full top and bottom row, then wraps each existing row from left and right.

Adjacent Elements Product

Mon, 01 Jan 0001 00:00:00 +0000

Bash Adjacent Elements Product

adjacent_elements_product() {
    local -n _arr="$1"
    local _max=-9223372036854775808
    local _i _c=${#_arr[@]}
    for ((_i = 0; _i < _c - 1; _i++)); do
        local _p=$(( _arr[_i] * _arr[_i+1] ))
        if (( _p > _max )); then _max=$_p; fi
    done
    echo "$_max"
}

This walks through neighboring values, multiplies each pair, and keeps the biggest product it finds.

Almost Magic Square

Mon, 01 Jan 0001 00:00:00 +0000

Bash Almost Magic Square

almost_magic_square() {
    local -n _a="$1"
    local -n _out="$2"
    local -a _rowSum=(0 0 0) _colSum=(0 0 0)
    local -a _m
    local _i _j
    for ((_i = 0; _i < 3; _i++)); do
        for ((_j = 0; _j < 3; _j++)); do
            _m[_i*3+_j]=${_a[_i*3+_j]}
        done
    done
    for ((_i = 0; _i < 3; _i++)); do
        for ((_j = 0; _j < 3; _j++)); do
            _rowSum[_i]=$(( _rowSum[_i] + _m[_i*3+_j] ))
            _colSum[_i]=$(( _colSum[_i] + _m[_j*3+_i] ))
        done
    done
    local _maxSum=0
    for ((_i = 0; _i < 3; _i++)); do
        if (( _rowSum[_i] > _maxSum )); then _maxSum=${_rowSum[_i]}; fi
        if (( _colSum[_i] > _maxSum )); then _maxSum=${_colSum[_i]}; fi
    done
    _i=0; _j=0
    while (( _i < 3 && _j < 3 )); do
        local _diffR=$(( _maxSum - _rowSum[_i] ))
        local _diffC=$(( _maxSum - _colSum[_j] ))
        local _diff=$(( _diffR < _diffC ? _diffR : _diffC ))
        _m[_i*3+_j]=$(( _m[_i*3+_j] + _diff ))
        _rowSum[_i]=$(( _rowSum[_i] + _diff ))
        _colSum[_j]=$(( _colSum[_j] + _diff ))
        if (( _rowSum[_i] == _maxSum )); then ((_i++)); fi
        if (( _colSum[_j] == _maxSum )); then ((_j++)); fi
    done
    _out=("${_m[@]}")
}

This adjusts the matrix toward a matching target sum so the rows and columns line up more like a magic square.

Are Equally Strong

Mon, 01 Jan 0001 00:00:00 +0000

Bash Are Equally Strong

are_equally_strong() {
    local _yourLeft=$1 _yourRight=$2 _friendsLeft=$3 _friendsRight=$4
    local _maxYou=$(( _yourRight > _yourLeft ? _yourRight : _yourLeft ))
    local _maxFriend=$(( _friendsLeft > _friendsRight ? _friendsLeft : _friendsRight ))
    local _minYou=$(( _yourLeft < _yourRight ? _yourLeft : _yourRight ))
    local _minFriend=$(( _friendsRight < _friendsLeft ? _friendsRight : _friendsLeft ))
    if (( _maxYou == _maxFriend && _minYou == _minFriend )); then
        echo true
    else
        echo false
    fi
}

This compares each person’s strongest and weakest arm. If both pairs match, the result is true.

Array Change

Mon, 01 Jan 0001 00:00:00 +0000

Bash Array Change

array_change() {
    local -n _a="$1"
    local _min=0 _k _c=${#_a[@]}
    for ((_k = 0; _k < _c - 1; _k++)); do
        if (( _a[_k] >= _a[_k+1] )); then
            local _dif=$(( _a[_k] - _a[_k+1] + 1 ))
            _a[_k+1]=$(( _a[_k+1] + _dif ))
            _min=$(( _min + _dif ))
        fi
    done
    echo "$_min"
}

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Array Maximal Adjacement Difference

Mon, 01 Jan 0001 00:00:00 +0000

Bash Array Maximal Adjacement Difference

array_maximal_adjacent_difference() {
    local -n _a="$1"
    local _dif=0 _i _c=${#_a[@]}
    for ((_i = 1; _i < _c - 1; _i++)); do
        local _d1=$(( _a[_i] - _a[_i-1] )); (( _d1 < 0 )) && _d1=$(( -_d1 ))
        local _d2=$(( _a[_i] - _a[_i+1] )); (( _d2 < 0 )) && _d2=$(( -_d2 ))
        (( _d1 > _dif )) && _dif=$_d1
        (( _d2 > _dif )) && _dif=$_d2
    done
    echo "$_dif"
}

This checks the gap between each pair of neighbors and returns the largest difference.

Bash Variables

Mon, 01 Jan 0001 00:00:00 +0000

Variable

NAME="John"
echo $NAME
echo "$NAME"
echo "${NAME}

This shows the common ways to read a Bash variable. Quoting is usually the safe default because it keeps spaces and special characters from breaking your output.

Condition

if [[ -z "$string" ]]; then
  echo "String is empty"
elif [[ -n "$string" ]]; then
  echo "String is not empty"
fi

This is the standard Bash string check. -z means the value is empty, and -n means it has content.

Binary Gap

Mon, 01 Jan 0001 00:00:00 +0000

Bash Binary Gap

binary_gap() {
    local _n=$1
    local _bin=""
    if (( _n == 0 )); then
        _bin="0"
    else
        local _x=$_n
        while (( _x > 0 )); do
            _bin="$(( _x % 2 ))$_bin"
            _x=$(( _x / 2 ))
        done
    fi
    _bin="${_bin#"${_bin%%[!0]*}"}"
    _bin="${_bin%"${_bin##*[!0]}"}"
    local _gap=0 _len=0
    local -a _zeros
    IFS='1' read -ra _zeros <<< "$_bin"
    local _z
    for _z in "${_zeros[@]}"; do
        _len=${#_z}
        (( _len > _gap )) && _gap=$_len
    done
    echo "$_gap"
}

This turns the number into binary, ignores zeroes outside the edges, and finds the longest run of zeroes between 1s.

Bracket

Mon, 01 Jan 0001 00:00:00 +0000

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.

Century From Year

Mon, 01 Jan 0001 00:00:00 +0000

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.

Check Palindrome

Mon, 01 Jan 0001 00:00:00 +0000

Bash Check Palindrome

check_palindrome() {
    local _s=$1
    local _rev=""
    local _i
    for ((_i = ${#_s} - 1; _i >= 0; _i--)); do
        _rev="${_rev}${_s:_i:1}"
    done
    if [[ "$_rev" == "$_s" ]]; then echo true; else echo false; fi
}

This compares the string with its reverse. If they match, it is a palindrome.

Chocolates By Numbers

Mon, 01 Jan 0001 00:00:00 +0000

Bash Chocolates By Numbers

gcd() {
    local _n=$1 _m=$2
    if (( _n % _m == 0 )); then
        echo "$_m"
        return
    fi
    gcd "$_m" $(( _n % _m ))
}

chocolates_by_numbers() {
    local _n=$1 _m=$2
    local _g
    _g=$(gcd "$_n" "$_m")
    echo $(( (_n * _m / _g) / _m ))
}

This uses the greatest common divisor to figure out how many chocolates get eaten before the pattern repeats.

Common Prime Divisors

Mon, 01 Jan 0001 00:00:00 +0000

Bash Common Prime Divisors

gcd() {
    local _n=$1 _m=$2
    if (( _n % _m == 0 )); then
        echo "$_m"
        return
    fi
    gcd "$_m" $(( _n % _m ))
}

remove_common_prime_divisors() {
    local _n=$1 _m=$2 _d
    while (( _n != 1 )); do
        _d=$(gcd "$_n" "$_m")
        if (( _d == 1 )); then
            break
        fi
        _n=$(( _n / _d ))
    done
    echo "$_n"
}

common_prime_divisors() {
    local -n _arrA="$1"
    local -n _arrB="$2"
    local _counter=0 _i _x _y _d _rx _ry
    for _i in "${!_arrA[@]}"; do
        _x=${_arrA[$_i]}
        _y=${_arrB[$_i]}
        _d=$(gcd "$_x" "$_y")
        _rx=$(remove_common_prime_divisors "$_x" "$_d")
        if (( _rx != 1 )); then
            continue
        fi
        _ry=$(remove_common_prime_divisors "$_y" "$_d")
        if (( _ry == 1 )); then
            ((_counter++))
        fi
    done
    echo "$_counter"
}

This checks whether two numbers are built from the same prime factors by repeatedly dividing out their shared parts.

Count Div

Mon, 01 Jan 0001 00:00:00 +0000

Bash Count Div

count_div() {
    local _a=$1 _b=$2 _k=$3
    local _firstDiv
    if (( _a % _k == 0 )); then _firstDiv=$_a; else _firstDiv=$(( _a + (_k - _a % _k) )); fi
    local _lastDiv=$(( _b - _b % _k ))
    echo $(( (_lastDiv - _firstDiv) / _k + 1 ))
}

This counts how many numbers in a range are divisible by K without looping through every value.

Count Factors

Mon, 01 Jan 0001 00:00:00 +0000

Bash Count Factors

count_factors() {
    local _n=$1
    local _count=0 _i=1
    while (( _i * _i < _n )); do
        if (( _n % _i == 0 )); then
            _count=$(( _count + 2 ))
        fi
        ((_i++))
    done
    if (( _i * _i == _n )); then
        ((_count++))
    fi
    echo "$_count"
}

This checks divisors in pairs up to the square root, which keeps the work much smaller than testing every number.

Count Non Divisible

Mon, 01 Jan 0001 00:00:00 +0000

Bash Count Non Divisible

count_non_divisible() {
    local -n _a="$1"
    local -n _out="$2"
    local _size=${#_a[@]}
    local _maxv=${_a[0]} _v
    for _v in "${_a[@]}"; do (( _v > _maxv )) && _maxv=$_v; done
    local -a _occ
    for ((_v = 0; _v <= _maxv; _v++)); do _occ[_v]=0; done
    for _v in "${_a[@]}"; do _occ[_v]=$(( _occ[_v] + 1 )); done
    _out=()
    local _k
    for _k in "${!_a[@]}"; do
        _v=${_a[$_k]}
        local _count=0 _i=1
        while (( _i * _i <= _v )); do
            if (( _v % _i == 0 )); then
                _count=$(( _count + _occ[_i] ))
                if (( _v / _i != _i )); then
                    _count=$(( _count + _occ[_v/_i] ))
                fi
            fi
            ((_i++))
        done
        _out[_k]=$(( _size - _count ))
    done
}

This counts how often each value appears, then subtracts the divisor matches so you get the non-divisible count for each item.

Count Semi Primes

Mon, 01 Jan 0001 00:00:00 +0000

Bash Count Semi Primes

count_semi_primes() {
    local _n=$1
    local -n _pArr="$2"
    local -n _qArr="$3"
    local -n _outArr="$4"
    local -a _is_prime _semi _cum
    local _i _k _idx
    for ((_i = 0; _i <= _n; _i++)); do _is_prime[_i]=1; _semi[_i]=0; done
    for ((_i = 2; _i * _i <= _n; _i++)); do
        if (( _is_prime[_i] )); then
            for ((_k = _i * _i; _k <= _n; _k += _i)); do
                _is_prime[_k]=0
            done
        fi
    done
    for ((_k = 2; _k * _k <= _n; _k++)); do
        if (( _is_prime[_k] )); then
            for ((_i = 2; _i * _k <= _n; _i++)); do
                if (( _is_prime[_i] )); then
                    _semi[_k * _i]=1
                fi
            done
        fi
    done
    _cum[0]=${_semi[0]}
    for ((_i = 1; _i <= _n; _i++)); do
        _cum[_i]=$(( _cum[_i-1] + _semi[_i] ))
    done
    _outArr=()
    for _idx in "${!_pArr[@]}"; do
        local _lo=${_pArr[$_idx]}
        local _hi=${_qArr[$_idx]}
        _outArr[_idx]=$(( _cum[_hi] - _cum[_lo-1] ))
    done
}

This precomputes semiprimes and prefix sums so each range query becomes a quick subtraction.

Cyclic Rotation

Mon, 01 Jan 0001 00:00:00 +0000

Bash Cyclic Rotation

cyclic_rotation() {
    local -n _a="$1"
    local -n _out="$2"
    local _k=$3
    local _size=${#_a[@]}
    if (( _size == 0 )); then
        _out=()
        return
    fi
    _k=$(( _k % _size ))
    _out=()
    local _i
    for ((_i = 0; _i < _size; _i++)); do
        _out[(_i + _k) % _size]=${_a[_i]}
    done
}

This rotates the array to the right by K steps and keeps the wrap-around values in the correct order.

Distinct

Mon, 01 Jan 0001 00:00:00 +0000

Bash Distinct

distinct() {
    local -n _a="$1"
    local -A _seen
    local _v
    for _v in "${_a[@]}"; do _seen[$_v]=1; done
    echo "${#_seen[@]}"
}

This counts unique values by tracking what has already been seen.

Dominator

Mon, 01 Jan 0001 00:00:00 +0000

Bash Dominator

dominator() {
    local -n _a="$1"
    local _size=0 _value=0 _count=0 _index=0
    local _k _v
    for _k in "${!_a[@]}"; do
        _v=${_a[$_k]}
        if (( _size == 0 )); then
            ((_size++))
            _value=$_v
            _index=$_k
        elif (( _value != _v )); then
            ((_size--))
        else
            ((_size++))
        fi
    done
    local _candidate
    if (( _size > 0 )); then _candidate=$_value; else _candidate=-1; fi
    _count=0
    for _v in "${_a[@]}"; do
        if (( _v == _candidate )); then ((_count++)); fi
    done
    if (( _count <= ${#_a[@]} / 2 )); then
        _index=-1
    fi
    echo "$_index"
}

This finds a value that appears in more than half of the array, then returns one valid index for it.

Equi Leader

Mon, 01 Jan 0001 00:00:00 +0000

Bash Equi Leader

equi_leader() {
    local -n _a="$1"
    local _leaderSize=0 _value=0 _leaderCount=0
    local _k _v
    for _k in "${!_a[@]}"; do
        _v=${_a[$_k]}
        if (( _leaderSize == 0 )); then
            ((_leaderSize++))
            _value=$_v
        elif (( _value != _v )); then
            ((_leaderSize--))
        else
            ((_leaderSize++))
        fi
    done
    local _candidate
    if (( _leaderSize > 0 )); then _candidate=$_value; else _candidate=-1; fi
    _leaderCount=0
    for _v in "${_a[@]}"; do
        if (( _v == _candidate )); then ((_leaderCount++)); fi
    done
    local _leader=-1
    local _count=${#_a[@]}
    if (( 2 * _leaderCount > _count )); then
        _leader=$_candidate
    fi
    local _lLeaderCount=0 _equiLeaders=0
    for _k in "${!_a[@]}"; do
        _v=${_a[$_k]}
        local _leftHalf=$(( (_k + 1) / 2 ))
        local _rightHalf=$(( (_count - _k - 1) / 2 ))
        if (( _v == _leader )); then
            ((_lLeaderCount++))
        fi
        local _rLeaderCount=$(( _leaderCount - _lLeaderCount ))
        if (( _lLeaderCount > _leftHalf && _rLeaderCount > _rightHalf )); then
            ((_equiLeaders++))
        fi
    done
    echo "$_equiLeaders"
}

This keeps leader counts on both sides of the split and counts positions where the same leader survives in each half.

Fib Frog

Mon, 01 Jan 0001 00:00:00 +0000

Bash Fib Frog

fib_frog() {
    local -n _arr="$1"
    local _size=${#_arr[@]}
    local -a _fib=(0 1)
    local _i=1
    while (( _fib[_i] <= _size )); do
        ((_i++))
        _fib[_i]=$(( _fib[_i-1] + _fib[_i-2] ))
    done
    local -a _q_idx=(-1) _q_jmp=(0)
    local _head=0
    local -a _steps
    for ((_i = 0; _i < _size; _i++)); do _steps[_i]=0; done
    while (( _head < ${#_q_idx[@]} )); do
        local _cidx=${_q_idx[_head]} _cjmp=${_q_jmp[_head]}
        ((_head++))
        local _fidx
        for ((_fidx = ${#_fib[@]} - 1; _fidx >= 2; _fidx--)); do
            local _idx=$(( _cidx + _fib[_fidx] ))
            if (( _idx == _size )); then
                echo $(( _cjmp + 1 ))
                return
            fi
            if (( _idx > _size )) || (( ${_steps[_idx]:-0} )) || (( _arr[_idx] == 0 )); then
                continue
            fi
            if (( _arr[_idx] == 1 )); then
                _steps[_idx]=1
                _q_idx+=("$_idx")
                _q_jmp+=($(( _cjmp + 1 )))
            fi
        done
    done
    echo -1
}

This precomputes Fibonacci jumps, then uses a breadth-first search to find the shortest valid path across the river.

Fish

Mon, 01 Jan 0001 00:00:00 +0000

Bash Fish

fish() {
    local -n _a="$1"
    local -n _b="$2"
    local _size=${#_a[@]}
    local _dead=0
    local -a _stack=()
    local _i
    for ((_i = 0; _i < _size; _i++)); do
        if (( _b[_i] == 1 )); then
            _stack+=("${_a[_i]}")
        elif (( ${#_stack[@]} > 0 )); then
            while (( ${#_stack[@]} > 0 )); do
                ((_dead++))
                local _top=${_stack[-1]}
                if (( _a[_i] > _top )); then
                    unset '_stack[-1]'
                    _stack=("${_stack[@]}")
                else
                    break
                fi
            done
        fi
    done
    echo $(( _size - _dead ))
}

This uses a stack for downstream fish and resolves fights only when opposite directions meet.

Flags

Mon, 01 Jan 0001 00:00:00 +0000

Bash Flags

flags() {
    local -n _a="$1"
    local _size=${#_a[@]}
    local -a _peak _nxt
    _peak[0]=0
    local _i
    for ((_i = 1; _i < _size; _i++)); do
        local _right=0
        (( _i + 1 < _size )) && _right=${_a[_i+1]}
        if (( _a[_i-1] < _a[_i] && _a[_i] > _right )); then _peak[_i]=1; else _peak[_i]=0; fi
    done
    _nxt[_size-1]=-1
    for ((_i = _size - 2; _i >= 0; _i--)); do
        if (( _peak[_i] )); then _nxt[_i]=$_i; else _nxt[_i]=${_nxt[_i+1]}; fi
    done
    _i=1
    local _result=0
    while (( _i * (_i - 1) <= _size )); do
        local _pos=0 _num=0
        while (( _pos < _size && _num < _i )); do
            _pos=${_nxt[_pos]}
            if (( _pos == -1 )); then break; fi
            ((_num++))
            _pos=$(( _pos + _i ))
        done
        ((_i++))
        (( _num > _result )) && _result=$_num
    done
    echo "$_result"
}

This finds all peaks first, then checks how many flags can be placed while keeping the required distance.

Frog Jmp

Mon, 01 Jan 0001 00:00:00 +0000

Bash Frog Jmp

frog_jmp() {
    local _x=$1 _y=$2 _d=$3
    echo $(( (_y - _x + _d - 1) / _d ))
}

This computes the jump count with math instead of simulation, which is the cleanest way to solve it.

Frog River One

Mon, 01 Jan 0001 00:00:00 +0000

Bash Frog River One

frog_river_one() {
    local _x=$1
    local -n _a="$2"
    local -A _existing
    local _k _v
    for _k in "${!_a[@]}"; do
        _v=${_a[$_k]}
        if [[ -z "${_existing[$_v]:-}" ]] && (( _v <= _x )); then
            _existing[$_v]=1
            if (( ${#_existing[@]} == _x )); then
                echo "$_k"
                return
            fi
        fi
    done
    echo -1
}

This tracks the earliest time each needed position appears and stops as soon as the frog can cross.

Genomic Range Query

Mon, 01 Jan 0001 00:00:00 +0000

Bash Genomic Range Query

genomic_range_query() {
    local _s=$1
    local -n _p="$2"
    local -n _q="$3"
    local -n _out="$4"
    _out=()
    local _k _idx
    for _idx in "${!_p[@]}"; do
        local _pi=${_p[$_idx]} _qi=${_q[$_idx]}
        local _len=$(( _qi - _pi + 1 ))
        local _sub=${_s:_pi:_len}
        if [[ "$_sub" == *A* ]]; then
            _out[_idx]=1
        elif [[ "$_sub" == *C* ]]; then
            _out[_idx]=2
        elif [[ "$_sub" == *G* ]]; then
            _out[_idx]=3
        else
            _out[_idx]=4
        fi
    done
}

This builds prefix counts for each DNA letter so every query can return the minimum impact factor quickly.

Is Ipv 4 Adress

Mon, 01 Jan 0001 00:00:00 +0000

Bash Is Ipv 4 Adress

is_ipv4_address() {
    local _s=$1
    local -a _parts
    IFS='.' read -ra _parts <<< "$_s"
    if (( ${#_parts[@]} != 4 )); then echo false; return; fi
    local _v
    for _v in "${_parts[@]}"; do
        if [[ -z "$_v" ]] || ! [[ "$_v" =~ ^[0-9]+$ ]]; then
            echo false; return
        fi
        if (( ${#_v} > 1 && ${_v:0:1} == 0 )); then
            echo false; return
        fi
        if (( _v > 255 )); then
            echo false; return
        fi
    done
    echo true
}

This splits the string by dots and validates each part as a normal IPv4 octet.

Ladder

Mon, 01 Jan 0001 00:00:00 +0000

Bash Ladder

ladder() {
    local -n _aArr="$1"
    local -n _bArr="$2"
    local -n _outArr="$3"
    local _size=${#_aArr[@]}
    local _maxB
    _maxB=$(printf '%s\n' "${_bArr[@]}" | sort -n | tail -1)
    local _mod=$(( (1 << _maxB) - 1 ))
    local _limitA
    _limitA=$(printf '%s\n' "${_aArr[@]}" | sort -n | tail -1)
    local -a _fib=(0 1)
    local _i
    for ((_i = 2; _i < _limitA + 2; _i++)); do
        _fib[_i]=$(( (_fib[_i-1] + _fib[_i-2]) & _mod ))
    done
    _outArr=()
    for ((_i = 0; _i < _size; _i++)); do
        _outArr[_i]=$(( _fib[_aArr[_i]+1] & ((1 << _bArr[_i]) - 1) ))
    done
}

This precomputes climb counts once and applies the modulo per query, which avoids recalculating the same paths over and over.

Largest String

Mon, 01 Jan 0001 00:00:00 +0000

Bash Largest String

largest_string() {
    local _s=$1
    local -a _c
    local _i _len=${#_s}
    for ((_i = 0; _i < _len; _i++)); do _c[_i]=${_s:_i:1}; done
    local _cur=""
    for ((_i = _len - 1; _i >= 0; _i--)); do
        _cur="${_c[_i]}${_cur}"
        if (( ${#_cur} == 3 )); then
            if [[ "$_cur" == "abb" ]]; then
                _c[_i]="b"; _c[_i+1]="a"; _c[_i+2]="a"
                if [[ -n "${_c[_i+4]:-}" && "${_c[_i+4]}" == "b" ]]; then
                    _i=$(( _i + 4 + 1 ))
                elif [[ -n "${_c[_i+3]:-}" && "${_c[_i+3]}" == "b" ]]; then
                    _i=$(( _i + 3 + 1 ))
                elif [[ "${_c[_i+2]}" == "b" ]]; then
                    _i=$(( _i + 2 + 1 ))
                fi
            fi
            if [[ "${_c[_i+1]}" == "b" ]]; then
                _i=$(( _i + 1 + 1 ))
            else
                ((_i++))
            fi
            _cur=""
        fi
    done
    local _out=""
    for ((_i = 0; _i < _len; _i++)); do _out="${_out}${_c[_i]}"; done
    echo "$_out"
}

This builds the biggest valid string it can under the challenge rules by always choosing the best next character it is allowed to use.

Max Counters

Mon, 01 Jan 0001 00:00:00 +0000

Bash Max Counters

max_counters() {
    local _n=$1
    local -n _a="$2"
    local -n _out="$3"
    local -a _counters
    local _i
    for ((_i = 0; _i < _n; _i++)); do _counters[_i]=0; done
    local _maxCounter=0 _lastUpdate=0
    local _condition=$(( _n + 1 ))
    local _v
    for _v in "${_a[@]}"; do
        if (( _v <= _n )); then
            local _index=$(( _v - 1 ))
            if (( _counters[_index] < _lastUpdate )); then
                _counters[_index]=$_lastUpdate
            fi
            (( _counters[_index]++ ))
            (( _counters[_index] > _maxCounter )) && _maxCounter=${_counters[_index]}
        fi
        if (( _v == _condition )); then
            _lastUpdate=$_maxCounter
        fi
    done
    for _i in "${!_counters[@]}"; do
        if (( _counters[_i] < _lastUpdate )); then
            _counters[_i]=$_lastUpdate
        fi
    done
    _out=("${_counters[@]}")
}

This delays the expensive “set all counters to max” work until it is really needed, which keeps the solution fast.

Max Double Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Bash Max Double Slice Sum

max_double_slice_sum() {
    local -n _arr="$1"
    local _size=${#_arr[@]}
    if (( _size < 3 )); then
        echo 0
        return
    fi
    local -a _p1 _p2
    _p1[1]=0
    _p2[_size-2]=0
    local _i
    for ((_i = 2; _i < _size - 1; _i++)); do
        local _left=$(( _p1[_i-1] + _arr[_i-1] ))
        (( _left < 0 )) && _left=0
        _p1[_i]=$_left
        local _right=$(( _p2[_size-_i] + _arr[_size-_i] ))
        (( _right < 0 )) && _right=0
        _p2[_size-_i-1]=$_right
    done
    local _sum=$(( _p1[1] + _p2[1] ))
    for ((_i = 1; _i < _size - 1; _i++)); do
        local _cand=$(( _p1[_i] + _p2[_i] ))
        if (( _cand > _sum )); then _sum=$_cand; fi
    done
    echo "$_sum"
}

This keeps the best sum ending on the left and starting on the right, then combines them around each middle position.

Max Product Of Three

Mon, 01 Jan 0001 00:00:00 +0000

Bash Max Product Of Three

max_product_of_three() {
    local -n _a="$1"
    local -a _sorted=($(printf '%s\n' "${_a[@]}" | sort -n))
    local _c=${#_sorted[@]}
    local _p1=$(( _sorted[_c-1] * _sorted[_c-2] * _sorted[_c-3] ))
    local _p2=$(( _sorted[0] * _sorted[1] * _sorted[_c-1] ))
    if (( _p1 > _p2 )); then echo "$_p1"; else echo "$_p2"; fi
}

This checks the useful extremes, because the best product can come from either the three largest numbers or two negatives plus one large positive.

Max Profit

Mon, 01 Jan 0001 00:00:00 +0000

Bash Max Profit

max_profit() {
    local -n _a="$1"
    local _price=${_a[0]} _profit=0 _v
    for _v in "${_a[@]}"; do
        (( _v < _price )) && _price=$_v
        local _cur=$(( _v - _price ))
        (( _cur > _profit )) && _profit=$_cur
    done
    echo "$_profit"
}

This tracks the lowest buy price seen so far and updates the best profit as it scans the prices once.

Max Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Bash Max Slice Sum

max_slice_sum() {
    local -n _arr="$1"
    local _tmp=-9223372036854775808 _max=-9223372036854775808
    local _v
    for _v in "${_arr[@]}"; do
        if (( _tmp + _v > _v )); then _tmp=$(( _tmp + _v )); else _tmp=$_v; fi
        if (( _tmp > _max )); then _max=$_tmp; fi
    done
    echo "$_max"
}

This is a Kadane-style scan: keep the best running sum and the best overall sum while moving once through the array.

Min Avg Two Slice

Mon, 01 Jan 0001 00:00:00 +0000

Bash Min Avg Two Slice

min_avg_two_slice() {
    local -n _a="$1"
    local _idx=0
    local _min
    _min=$(echo "scale=10; (${_a[0]} + ${_a[1]}) / 2" | bc)
    local _count=${#_a[@]} _i
    for ((_i = 0; _i < _count - 1; _i++)); do
        local _cur
        _cur=$(echo "scale=10; (${_a[_i]} + ${_a[_i+1]}) / 2" | bc)
        if (( _i + 2 < _count )); then
            local _three
            _three=$(echo "scale=10; (${_a[_i]} + ${_a[_i+1]} + ${_a[_i+2]}) / 3" | bc)
            if (( $(echo "$_three < $_cur" | bc -l) )); then
                _cur=$_three
            fi
        fi
        if (( $(echo "$_cur < $_min" | bc -l) )); then
            _min=$_cur
            _idx=$_i
        fi
    done
    echo "$_idx"
}

This leans on the key trick for this problem: the minimum average slice is always length 2 or 3.

Min Perimeter Rectangle

Mon, 01 Jan 0001 00:00:00 +0000

Bash Min Perimeter Rectangle

min_perimeter_rectangle() {
    local _n=$1
    local _i=1
    local _min=9223372036854775807
    while (( _i * _i < _n )); do
        if (( _n % _i == 0 )); then
            local _perim=$(( 2 * (_i + _n / _i) ))
            (( _perim < _min )) && _min=$_perim
        fi
        ((_i++))
    done
    echo "$_min"
}

This searches factor pairs up to the square root and picks the pair with the smallest perimeter.

Missing Integer

Mon, 01 Jan 0001 00:00:00 +0000

Bash Missing Integer

missing_integer() {
    local -n _a="$1"
    local -a _sorted=($(printf '%s\n' "${_a[@]}" | sort -nu))
    local _min=1 _v
    for _v in "${_sorted[@]}"; do
        if (( _v > 0 )); then
            if (( _min != _v )); then
                break
            fi
            ((_min++))
        fi
    done
    echo "$_min"
}

This records the positive numbers that exist, then returns the smallest positive value that is still missing.

Nesting

Mon, 01 Jan 0001 00:00:00 +0000

Bash Nesting

nesting() {
    local _s=$1
    if [[ -z "$_s" ]]; then echo 1; return; fi
    local -a _stack=()
    local _i _c
    for ((_i = 0; _i < ${#_s}; _i++)); do
        _c=${_s:_i:1}
        if [[ "$_c" == ")" ]]; then
            if (( ${#_stack[@]} == 0 )) || [[ "${_stack[-1]}" != "(" ]]; then
                echo 0; return
            fi
            unset '_stack[-1]'
        else
            _stack+=("$_c")
        fi
    done
    if (( ${#_stack[@]} == 0 )); then echo 1; else echo 0; fi
}

This treats the string like a balance counter: open parentheses add one, closing ones remove one.

Number Of Disc Intersections

Mon, 01 Jan 0001 00:00:00 +0000

Bash Number Of Disc Intersections

number_of_disc_intersections() {
    local -n _a="$1"
    local _c=${#_a[@]}
    local -a _start _end
    local _k
    for ((_k = 0; _k < _c; _k++)); do _start[_k]=0; _end[_k]=0; done
    for _k in "${!_a[@]}"; do
        local _v=${_a[$_k]}
        local _key
        if (( _k < _v )); then _key=0; else _key=$(( _k - _v )); fi
        (( _start[_key]++ ))
        if (( _k + _v >= _c )); then _key=$(( _c - 1 )); else _key=$(( _k + _v )); fi
        (( _end[_key]++ ))
    done
    local _sum=0 _active=0
    for ((_k = 0; _k < _c; _k++)); do
        _sum=$(( _sum + _active * _start[_k] + (_start[_k] * (_start[_k] - 1)) / 2 ))
        _active=$(( _active + _start[_k] - _end[_k] ))
        if (( _sum > 10000000 )); then
            echo -1
            return
        fi
    done
    echo "$_sum"
}

This sorts disc start and end points and counts active overlaps without comparing every pair directly.

Odd Occurrences In Array

Mon, 01 Jan 0001 00:00:00 +0000

Bash Odd Occurrences In Array

odd_occurrences_in_array() {
    local -n _a="$1"
    local -A _count
    local _v
    for _v in "${_a[@]}"; do
        if [[ -z "${_count[$_v]:-}" ]]; then
            _count[$_v]=1
        else
            unset '_count[$_v]'
        fi
    done
    for _v in "${!_count[@]}"; do
        echo "$_v"
        return
    done
}

This uses XOR to cancel out pairs, leaving only the value that appears an odd number of times.

Palindrome Rearranging

Mon, 01 Jan 0001 00:00:00 +0000

Bash Palindrome Rearranging

palindrome_rearranging() {
    local _s=$1
    local -A _val
    local _i _c
    for ((_i = 0; _i < ${#_s}; _i++)); do
        _c=${_s:_i:1}
        _val[$_c]=$(( ${_val[$_c]:-0} + 1 ))
    done
    local _odd=0
    for _c in "${!_val[@]}"; do
        (( _val[$_c] % 2 != 0 )) && ((_odd++))
    done
    if (( _odd <= 1 )); then echo true; else echo false; fi
}

This counts character frequency and checks whether the string has the right number of odd counts to form a palindrome.

Passing Cars

Mon, 01 Jan 0001 00:00:00 +0000

Bash Passing Cars

passing_cars() {
    local -n _a="$1"
    local _passing=0 _multiply=0 _v
    for _v in "${_a[@]}"; do
        if (( _v == 0 )); then
            ((_multiply++))
        elif (( _multiply > 0 )); then
            _passing=$(( _passing + _multiply ))
            if (( _passing > 1000000000 )); then
                echo -1
                return
            fi
        fi
    done
    echo "$_passing"
}

This counts eastbound cars as it scans, then adds them whenever a westbound car appears.

Peaks

Mon, 01 Jan 0001 00:00:00 +0000

Bash Peaks

peaks() {
    local -n _arr="$1"
    local _n=${#_arr[@]}
    if (( _n <= 2 )); then
        echo 0
        return
    fi
    local -a _sum
    for ((_i = 0; _i < _n; _i++)); do _sum[_i]=0; done
    local _last=-1 _dist=0 _i
    for ((_i = 1; _i + 1 < _n; _i++)); do
        _sum[_i]=${_sum[_i-1]}
        if (( _arr[_i] > _arr[_i-1] && _arr[_i] > _arr[_i+1] )); then
            if (( _i - _last > _dist )); then _dist=$(( _i - _last )); fi
            _last=$_i
            (( _sum[_i]++ ))
        fi
    done
    _sum[_n-1]=${_sum[_n-2]}
    if (( _sum[_n-1] == 0 )); then
        echo 0
        return
    fi
    if (( _n - _last > _dist )); then _dist=$(( _n - _last )); fi
    local _j
    for ((_i = (_dist >> 1) + 1; _i < _dist; _i++)); do
        if (( _n % _i == 0 )); then
            _last=0
            for ((_j = _i; _j <= _n; _j += _i)); do
                if (( _sum[_j-1] <= _last )); then
                    break
                fi
                _last=${_sum[_j-1]}
            done
            if (( _j > _n )); then
                echo $(( _n / _i ))
                return
            fi
        fi
    done
    for ((_last = _dist; _n % _last != 0; )); do
        ((_last++))
    done
    echo $(( _n / _last ))
}

This finds the peak positions, then tests how many equal blocks can each contain at least one peak.

Perm Check

Mon, 01 Jan 0001 00:00:00 +0000

Bash Perm Check

perm_check() {
    local -n _a="$1"
    local -a _sorted=($(printf '%s\n' "${_a[@]}" | sort -n))
    local _c=${#_sorted[@]}
    local _k
    for ((_k = 0; _k < _c - 1; _k++)); do
        if (( _sorted[_k] != _k + 1 )); then
            echo 0
            return
        fi
    done
    echo 1
}

This validates that every value from 1 to N appears exactly once.

Perm Missing Element

Mon, 01 Jan 0001 00:00:00 +0000

Bash Perm Missing Element

perm_missing_element() {
    local -n _a="$1"
    local -a _sorted=($(printf '%s\n' "${_a[@]}" | sort -n))
    local _k
    for _k in "${!_sorted[@]}"; do
        if (( _sorted[_k] != _k + 1 )); then
            echo $(( _k + 1 ))
            return
        fi
    done
    echo $(( ${#_sorted[@]} + 1 ))
}

This uses the expected sum of 1..N+1 and subtracts the actual sum to find the missing value.

Plagiarism Check

Mon, 01 Jan 0001 00:00:00 +0000

Bash Plagiarism Check

plagiarism_check() {
    local -n _code1="$1"
    local -n _code2="$2"
    local _c1 _c2
    _c1=$(IFS=' '; echo "${_code1[*]}")
    _c2=$(IFS=' '; echo "${_code2[*]}")
    if [[ "$_c1" == "$_c2" ]]; then
        echo false
        return
    fi

    local -a _d1 _d2
    IFS=' ' read -ra _d1 <<< "$_c1"
    IFS=' ' read -ra _d2 <<< "$_c2"

    local -A _rcand
    local -a _rcand_keys=()
    local _k
    for _k in "${!_d1[@]}"; do
        local _v=${_d1[$_k]}
        local _w=${_d2[$_k]}
        if [[ "$_v" != "$_w" ]] && ! [[ "$_v" =~ ^-?[0-9]+$ ]]; then
            if [[ -z "${_rcand[$_v]:-}" ]]; then
                _rcand_keys+=("$_v")
            fi
            _rcand[$_v]=$_w
        fi
    done

    local _orig _repl
    for _orig in "${_rcand_keys[@]}"; do
        _repl=${_rcand[$_orig]}
        _c1=$(echo "$_c1" | sed -E "s/(^|[^A-Za-z0-9_])${_orig}([^A-Za-z0-9_]|$)/\1PLACEHOLDER${_orig}\2/g")
        _c1=$(echo "$_c1" | sed -E "s/(^|[^A-Za-z0-9_])${_orig}([A-Za-z0-9_]|$)/\1PLACEHOLDER${_orig}\2/g")
    done
    for _orig in "${_rcand_keys[@]}"; do
        _repl=${_rcand[$_orig]}
        _c1=$(echo "$_c1" | sed -E "s/(^|[^A-Za-z0-9_])PLACEHOLDER${_orig}([^A-Za-z0-9_]|$)/\1${_repl}\2/g")
        _c1=$(echo "$_c1" | sed -E "s/(^|[^A-Za-z0-9_])PLACEHOLDER${_orig}([A-Za-z0-9_]|$)/\1${_repl}\2/g")
    done

    if [[ "$_c1" == "$_c2" ]]; then echo true; else echo false; fi
}

This flattens both snippets, tries consistent identifier replacements, and checks whether the rewritten code matches.

Shape Area

Mon, 01 Jan 0001 00:00:00 +0000

Bash Shape Area

shape_area() {
    local _n=$1
    if (( _n > 1 )); then
        echo $(( $(shape_area $(( _n - 1 ))) + 4 * (_n - 1) ))
    else
        echo 1
    fi
}

This returns the area of the growing n-interesting polygon using the direct formula instead of building the shape.

Stone Blocks

Mon, 01 Jan 0001 00:00:00 +0000

Bash Stone Blocks

stone_blocks() {
    local -n _h="$1"
    local -a _height
    local _index=0 _blocks=0
    local _i
    for _i in "${_h[@]}"; do
        while (( _index > 0 && _height[_index-1] > _i )); do
            ((_index--))
        done
        if (( _index > 0 && _height[_index-1] == _i )); then
            continue
        fi
        _height[_index]=$_i
        ((_blocks++))
        ((_index++))
    done
    echo "$_blocks"
}

This uses a stack of active heights and only counts a new block when the wall needs a new height segment.

Tape Equilibrium

Mon, 01 Jan 0001 00:00:00 +0000

Bash Tape Equilibrium

tape_equilibrium() {
    local -n _a="$1"
    local _firstPart=0
    local _secondPart=0
    local _v
    for _v in "${_a[@]}"; do _secondPart=$(( _secondPart + _v )); done
    local _min=9223372036854775807
    local _i
    for ((_i = 0; _i < ${#_a[@]} - 1; _i++)); do
        _firstPart=$(( _firstPart + _i ))
        _secondPart=$(( _secondPart - _i ))
        local _diff=$(( _firstPart - _secondPart ))
        (( _diff < 0 )) && _diff=$(( -_diff ))
        (( _diff < _min )) && _min=$_diff
    done
    echo "$_min"
}

This keeps left and right running sums and updates the smallest difference at each split point.

Triangle

Mon, 01 Jan 0001 00:00:00 +0000

Bash Triangle

triangle() {
    local -n _a="$1"
    local -a _sorted=($(printf '%s\n' "${_a[@]}" | sort -n))
    local _c=${#_sorted[@]}
    if (( _c < 3 )); then
        echo 0
        return
    fi
    local _i
    for ((_i = 0; _i < _c - 2; _i++)); do
        if (( _sorted[_i] > 0 && _sorted[_i] > _sorted[_i+2] - _sorted[_i+1] )); then
            echo 1
            return
        fi
    done
    echo 0
}

This sorts the values and checks nearby triples, because a valid triangle only needs one local match after sorting.