Linux Complete Interview Pack 2: 150 Shell Scripting Interview Questions and Answers with Coding Exercises

A text file with shell commands run in order. It automates repeated work like backups, log cleanup, deployments and reports.

The first line, like #!/usr/bin/env bash, which tells the system which interpreter to use when the script is executed directly.

chmod +x script.sh then ./script.sh, or run it with bash script.sh without execute permission. source script.sh runs it in the current shell.

bash starts a new child shell, so variables and cd do not affect your shell. source (or .) runs inside the current shell, so changes stay.

name=value with no spaces around =. Read it with $name or "${name}". Quote values with spaces: city="New Delhi".

Without quotes the shell splits values on spaces and expands globs, so a file named my file.txt becomes two words. "$var" keeps it as one.

Single quotes keep everything literal. Double quotes allow $var, $(cmd) and backslash escapes but stop word splitting.

today=$(date +%F). The older backtick form `date` works but is harder to nest.

read -rp 'Enter name: ' name. Add -s to hide input for passwords and -t 10 for a timeout.

$1, $2 and so on are arguments, $0 the script name, $# the count, "$@" all arguments separately and $* all as one string. shift moves them left.

if [[ -f /etc/app.conf ]]; then echo found; else echo missing; fi. Use elif for more branches.

-f regular file, -d directory, -e exists, -r readable, -w writable, -x executable, -s not empty, -L symlink.

Numbers: -eq, -ne, -lt, -le, -gt, -ge, or (( a > b )). Strings: == and != inside [[ ]], -z for empty and -n for not empty.

[ ] is the POSIX test command and needs careful quoting. [[ ]] is a bash keyword that handles empty variables, supports && and ||, pattern matching with == and regex with =~.

for f in *.log; do gzip "$f"; done. For numbers: for i in {1..5} or for ((i=1;i<=5;i++)).

while condition; do ...; done. For example while ! curl -sf localhost:8080; do sleep 2; done waits until the app is up. until runs while the condition is false.

break exits the loop. continue skips to the next iteration. Both take a number for nested loops, like break 2.

case "$1" in start) start_app;; stop) stop_app;; *) echo "usage: $0 start|stop";; esac. It is cleaner than many elif branches.

greet() { echo "Hi $1"; } then greet Asha. Use local for variables inside, and return a status with return N or output with echo.

A number 0 to 255 every command returns. 0 means success. $? holds the last one and exit N ends a script with N.

do between commands? || a && b runs b only if a succeeds. a || b runs b only if a fails. mkdir -p dir && cd dir || exit 1 is a common pattern.

$(( a + b )) for integers, (( count++ )) to increment, let and expr are older forms. For decimals use bc or awk, such as echo '3.5*2' | bc.

A # starts a comment to the end of the line. For a block, many people use several # lines; a here-doc to : also works but is less clear.

bash -x script.sh or set -x inside prints each command before it runs. bash -n checks syntax without running and shellcheck finds common bugs.

A list variable: servers=(web1 web2 db1). ${servers[0]} is the first, "${servers[@]}" all items, ${#servers[@]} the count. declare -A makes key-value maps.

A way to feed many lines to a command: cat <<EOF > file then lines then EOF. Quote 'EOF' to stop variable expansion inside.

if command -v jq >/dev/null; then ... fi. Avoid which in scripts because its output differs between systems.

A special file that discards anything written to it. cmd >/dev/null 2>&1 silences all output.

printf 'Name: %s Age: %d\n' Asha 30 gives exact formatting. echo -n prints without newline but echo varies between shells, so printf is safer.

backup-$(date +%F).tgz gives backup-2026-10-26.tgz. Use date +%Y%m%d-%H%M%S for a full stamp.

Unquoted they behave the same. "$@" keeps each argument separate (correct for passing on), while "$*" joins all into one string with the first IFS character.

$$ is the PID of the current shell, often used for temp file names. $! is the PID of the last background job, used with wait or kill.

A short name for a command, like alias ll='ls -lah'. Aliases are for interactive shells; use functions in scripts.

.bash_profile (or .profile) runs for login shells like SSH sessions; .bashrc runs for interactive non-login shells like new terminal tabs. Most setups source .bashrc from .bash_profile.

export NAME=value. Without export, the variable exists only in the current shell. env NAME=value cmd sets it for one command.

True when the string is empty or the variable is unset. -n is the opposite.

echo 'config missing' >&2; exit 1. Write errors to stderr (>&2) so they do not mix with normal output.

Three standard streams: 0 input, 1 normal output, 2 errors. Redirect them with <, > or 1>, and 2>.

while IFS= read -r line; do ...; done < <(cmd). This keeps spaces and runs the loop in the current shell so variables survive.

sh is the POSIX shell (dash on Ubuntu, bash in sh mode on RHEL). bash adds arrays, [[ ]], brace expansion, process substitution and more. A #!/bin/sh script must avoid bash-only features.

{a,b,c} and {1..5} create lists before the command runs: mkdir -p app/{logs,conf,data} makes three folders and cp file{,.bak} makes a backup copy.

The shell expands patterns like *.log, file?.txt and [0-9]* to matching file names before the command runs. If nothing matches, the pattern stays as is unless nullglob is set.

env=${1:-dev} uses dev when $1 is empty. ${VAR:?message} stops with an error when it is missing.

${#var}. For example name=Pune; echo ${#name} prints 4.

Write a usage function that prints the syntax to stderr and exits 1, and call it when [[ $# -lt 1 ]] or on -h.

The Internal Field Separator decides how the shell splits words and how read splits fields. IFS=, read -r a b c <<< "$line" splits a CSV line.

sleep 5 waits five seconds; sleep 1m and sleep 0.5 also work with GNU sleep.

A child copy of the shell made by ( ), pipes or $( ). Changes inside, like cd or variables, do not affect the parent.

Put set -euo pipefail near the top, and handle expected failures with || true or if blocks.

Add a cron line such as 0 * * * * /opt/scripts/report.sh >> /var/log/report.log 2>&1, or create a systemd timer with OnCalendar=hourly.

-e exits on errors but is ignored inside if conditions, && chains and functions called in conditions. -u fails on unset variables, so use ${VAR:-} for optional ones. pipefail returns the last non-zero status in a pipeline. grep with no match returns 1 and can stop the script unexpectedly.

It runs code on signals or exit: trap 'rm -f "$tmp"' EXIT cleans temp files, trap 'echo failed at line $LINENO' ERR reports errors, and trap '' INT ignores Ctrl+C.

tmp=$(mktemp) or dir=$(mktemp -d) gives a unique, private path. Combine with trap 'rm -rf "$dir"' EXIT. Never use fixed names like /tmp/out.txt.

Use flock: exec 9>/var/lock/backup.lock; flock -n 9 || { echo running; exit 1; }. Or wrap the cron line with flock -n /var/lock/job.lock script.sh.

getopts handles short flags: while getopts 'e:vh' o; do case $o in e) env=$OPTARG;; v) verbose=1;; h) usage;; esac; done; shift $((OPTIND-1)). For long options use a while loop with case on $1 and shift.

log(){ printf '%s %s\n' "$(date '+%F %T')" "$*" | tee -a "$LOG"; } then log 'backup started'. logger -t backup 'started' sends to syslog or the journal.

exec > >(tee -a "$LOG") 2>&1 near the top redirects everything after it.

<(cmd) gives a command's output as a file path. diff <(sort a) <(sort b) compares sorted files without temp files. >(cmd) does the reverse.

Each part of a pipeline runs in a subshell, so cat f | while read l; do n=$((n+1)); done leaves n unchanged. Use done < f, done < <(cmd), or shopt -s lastpipe.

for i in 1 2 3 4 5; do cmd && break; sleep $((i*2)); done. Check the final status after the loop and exit if it never succeeded.

timeout 30 curl -s URL kills it after 30 seconds and returns 124. timeout -k 5 30 cmd sends KILL 5 seconds after TERM.

Start each with & and call wait. Save PIDs to check each status with wait $pid. xargs -P 4 or GNU parallel limit how many run at once.

for f in ./*.csv; do ... "$f"; done with quotes works. For find results use find . -name '*.csv' -print0 | while IFS= read -r -d '' f; do ...; done. Never use for f in $(ls).

declare -A port=([web]=80 [db]=5432); echo "${port[db]}"; for k in "${!port[@]}"; do echo "$k=${port[$k]}"; done. Needs bash 4.

${f%.*} drops the last extension, ${f##*/} keeps the file name and ${f%/*} keeps the folder, all without external commands.

${v/old/new} replaces the first match and ${v//old/new} all. ${v^^} and ${v,,} change case.

[[ $ip =~ ^([0-9]{1,3}\.){3}[0-9]{1,3}$ ]] && echo ok. Captured groups are in BASH_REMATCH. Keep the regex unquoted or in a variable.

grep finds lines matching a pattern. sed edits streams (substitute, delete, insert lines). awk is a small language for columns and calculations, like summing a field or grouping.

awk -F, '{s+=$3} END {print s}' sales.csv sums the third CSV column. Add NR>1 to skip the header.

sed -n '/START/,/END/p' file. sed -n '10,20p' file prints lines 10 to 20.

Loop with while IFS='=' read -r k v; do [[ $k =~ ^[A-Z_]+$ ]] && declare "$k=$v"; done < app.conf. Sourcing an untrusted file runs any code inside it, so avoid that.

Use jq: jq -r '.items[].name' data.json, curl -s api | jq '.status', jq -r '.[] | [.id,.name] | @csv' for CSV. Do not parse JSON with grep or sed.

code=$(curl -s -o /dev/null -w '%{http_code}' "$url"); [[ $code == 200 ]] || alert. Add --max-time 10 so it never hangs.

if ! diff -q a b >/dev/null; then echo changed; fi, or compare checksums with cmp -s a b. comm -13 <(sort a) <(sort b) prints lines only in b.

Print the value and capture it: get_ip(){ hostname -I | awk '{print $1}'; }; ip=$(get_ip). return only gives a 0 to 255 status code. A nameref (declare -n) can also write into a caller's variable.

Without local, variables in a function overwrite globals with the same name, causing hard bugs. local keeps them inside the function.

Put shared functions in lib.sh and load them with source "$(dirname "$0")/lib.sh". Guard against loading twice and keep the library free of top-level actions.

dir=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd). This works even when called from another folder or through source.

[[ $EUID -eq 0 ]] || { echo 'run as root' >&2; exit 1; }.

Wrap actions: run(){ if [[ $DRY == 1 ]]; then echo "+ $*"; else "$@"; fi; } then run rm -f "$f". Users can see what would happen before it does.

find . -name '*.tmp' -print0 | xargs -0 rm -f handles spaces. -n 1 passes one item per command, -P 4 runs four at a time and -I{} places the item where you want.

exec replaces the shell with cmd, so the script ends there and cmd keeps the same PID. It is common in container entrypoints so signals reach the app. exec with only redirects changes the script's file descriptors.

use=$(df --output=pcent / | tail -1 | tr -dc 0-9); (( use > 85 )) && echo "disk ${use}%" | mail -s alert ops@example.com.

Plain awk -F, breaks on "Pune, MH". Use a proper tool such as csvkit, mlr (Miller) or Python's csv module; or awk with FPAT='([^,]+)|("[^"]+")' in GNU awk.

A linter that finds quoting bugs, unused variables, bad tests and portability issues, each with a code like SC2086. Run it in your editor and CI.

export PS4='+ ${BASH_SOURCE}:${LINENO}: ' then set -x. Each traced line then shows the file and line.

Detect with . /etc/os-release and $ID, then pick dnf or apt, service names (httpd or apache2) and paths in a case statement. Use command -v to check tools.

trap 'echo stopping; kill $(jobs -p) 2>/dev/null; exit 130' INT TERM. Clean up children and temp files in the handler.

select opt in start stop status quit; do case $opt in quit) break;; *) systemctl "$opt" app;; esac; done. PS3 sets the prompt.

sudo echo x > /etc/file fails because the redirect runs as you. Use echo x | sudo tee /etc/file >/dev/null, or sudo tee -a to append.

Use grep pattern file instead of cat file | grep pattern, and while read ... done < file instead of cat file | while read. It saves a process and keeps variables.

openssl rand -base64 18, or tr -dc 'A-Za-z0-9' </dev/urandom | head -c 16. $RANDOM is fine for jitter but not for secrets.

timeout 3 bash -c "</dev/tcp/$host/$port" && echo open || echo closed. This uses bash's built-in /dev/tcp.

ssh host "bash -s" -- "$env" < deploy.sh passes the local script and arguments. Or ssh host "cd /app && ENV=$env ./run.sh" with careful quoting.

Use <<-EOF and indent the lines with tabs (not spaces); the leading tabs are removed.

find /var/log/app -type f -name '*.log' -mtime +7 -print then the same with -delete once the list looks right.

Check before acting: mkdir -p, id user || useradd user, grep -q line file || echo line >> file, and systemctl is-enabled before enable. Running it twice should change nothing the second time.

126 found but not executable, 127 command not found, 130 stopped by Ctrl+C (128 plus signal 2). 137 is killed by signal 9 and 143 by signal 15.

time ./script.sh for the whole run, or start=$SECONDS; ...; echo "took $((SECONDS-start))s" inside.

Use bats-core for unit tests, shellcheck for lint, bash -n for syntax, run in a container for clean environments, and add a CI job. Keep functions small so they are easy to test.

When the script needs complex data structures, JSON or API work beyond a few jq calls, heavy error handling, unit tests, concurrency control or grows past a few hundred lines. Bash is best for gluing commands, bootstrapping and simple automation.

Strict mode, a lock, clear arguments with validation, a dry-run flag, logging with timestamps, pre-checks (disk, health, versions), atomic switch (symlink swap or new release folder), health check after deploy, automatic rollback on failure, idempotent steps and meaningful exit codes.

Write to a temp file in the same filesystem, sync if needed, then mv tmp target. rename is atomic, so readers see either the old or new file, never half of one.

Unquoted variables (injection and globbing), eval on user input, predictable temp files, secrets in arguments visible in ps, world-writable script paths, trusting PATH, and sourcing untrusted files. Fix with quoting, mktemp, absolute paths, reading secrets from files or env, and strict permissions.

Read them from a root-only file (chmod 600), an environment variable injected by systemd or CI, or a secret manager CLI such as aws secretsmanager or vault. Avoid command-line arguments and set +x around secret use so traces do not print them.

eval runs any text as code, so user data like ; rm -rf / becomes a command. Use arrays for building commands (cmd=(rsync -a "$src" "$dst"); "${cmd[@]}"), declare or printf -v for dynamic variables, and case for dispatch.

flock only works on one host. Across hosts use a distributed lock (a DynamoDB or Redis key with expiry, Consul or etcd), or schedule on one leader, or make the job idempotent so duplicates are harmless.

Structured log lines (key=value or JSON) to the journal with logger, exit codes that mean something, a heartbeat or push metric (Prometheus pushgateway or CloudWatch put-metric-data), alerts on failure via trap ERR, and run them as systemd units for status and history.

Timers give logs in journalctl, dependency ordering, Persistent=true to catch missed runs, randomized delays, resource limits and easy status. Cron is simpler and everywhere. For production services, timers are usually better.

Use #!/bin/sh, [ ] not [[ ]], no arrays, $(...) is fine, printf over echo, no local in strict POSIX (though dash supports it), no brace expansion or process substitution, and test with dash and checkbashisms.

Avoid spawning processes inside big loops (use parameter expansion, builtins and one awk pass instead of many greps), batch with xargs or parallel, avoid repeated ssh by using ControlMaster, and measure with time and set -x timestamps.

Check strict mode and quoting, input validation, error handling and cleanup, idempotency, hardcoded paths or secrets, destructive commands guarded by checks, shellcheck output, logging, and whether it should be a config management task instead.

Use set -u and ${DIR:?} so an empty variable stops the script, check the path is under an expected root, avoid running as root when not needed, and prefer moving to a trash folder first.

When managing many servers' state: Ansible gives idempotent modules, inventory, templating, check mode, roles and reporting. Shell is fine for single host tasks or glue inside Ansible's shell module.

Collect results per host in an associative array, continue on failure, print a summary table, and exit non-zero if any host failed. Add a --hosts flag to retry only the failed ones.

macOS ships bash 3.2 (no associative arrays, no ${var^^}, no mapfile). Older RHEL has bash 4.2. Features like wait -n need 4.3 and ${var@Q} needs 4.4. Check BASH_VERSINFO when needed.

Back up with a timestamp, edit with a tool that validates (visudo -cf, nginx -t, sshd -t), write atomically, keep a diff in the log, and roll back automatically if validation or the service restart fails.

A style guide (Google shell style), a main function, small named functions, a header with purpose and usage, version control with review, shellcheck and bats in CI, and a README with examples.

Traps run only after the foreground command finishes. To react quickly, run the command in the background and wait for it; wait returns early when a trapped signal arrives.

Use set -e, prepare config from env vars, then exec "$@" so the app becomes PID 1 and receives SIGTERM. Use tini or --init if the app does not reap child processes.

Strict mode and logging to a file, package updates, install agents (SSM, CloudWatch), create users and SSH keys, harden SSH, mount disks by UUID, pull config from S3 or Parameter Store, start services, and signal success or failure to the orchestrator.

Stream rather than load: use grep -F for fixed strings, LC_ALL=C for faster matching, zgrep or zcat for compressed logs, awk single pass aggregates, sort -S for memory and --parallel, and split by time window first.

0 success, 1 general error, 2 usage error, and documented specific codes like 3 config missing or 4 dependency down. Keep them stable, since monitoring and CI rely on them.

Use STAR: the situation (for example 40 servers patched by hand each month), the task, what you built (a parallel, logged, idempotent patch script with health checks and rollback), and the result in numbers (hours saved, errors cut).

Store and log in UTC (date -u), convert only for display with TZ=Asia/Kolkata date, use ISO 8601 formats, and use date -d for arithmetic like date -d '7 days ago' +%F in GNU date.

Check the argument is a whole number, then use the remainder operator.

#!/usr/bin/env bash
set -euo pipefail
n=${1:?usage: $0 NUMBER}
[[ $n =~ ^-?[0-9]+$ ]] || { echo 'not a number' >&2; exit 2; }
if (( n % 2 == 0 )); then echo "$n is even"; else echo "$n is odd"; fi

Walk the string from the last character to the first using substring expansion.

#!/usr/bin/env bash
s=${1:?usage: $0 TEXT}
out=''
for (( i=${#s}-1; i>=0; i-- )); do out+=${s:i:1}; done
echo "$out"

Lower-case it, reverse it, and compare.

#!/usr/bin/env bash
w=${1,,}
r=$(printf '%s' "$w" | rev)
[[ $w == "$r" ]] && echo palindrome || echo 'not palindrome'

Keep two variables and shift them each step.

#!/usr/bin/env bash
n=${1:-10}; a=0; b=1
for (( i=0; i<n; i++ )); do printf '%s ' "$a"; (( t=a+b, a=b, b=t )); done; echo

Multiply in a loop; bash integers are 64-bit, so up to 20! is safe.

#!/usr/bin/env bash
n=${1:?}; f=1
for (( i=2; i<=n; i++ )); do (( f*=i )); done
echo "$n! = $f"

Read line by line and add up; this shows how loops and expansion work.

#!/usr/bin/env bash
l=0 w=0 c=0
while IFS= read -r line || [[ -n $line ]]; do
  (( l++ )); set -- $line; (( w+=$# )); (( c+=${#line}+1 ))
done < "${1:?file}"
echo "$l $w $c"

The client IP is the first field; count with sort and uniq.

awk '{print $1}' /var/log/nginx/access.log | sort | uniq -c | sort -rn | head -5

In the combined log format the status is field 9.

awk '{c[$9]++} END {for (s in c) print s, c[s]}' /var/log/nginx/access.log | sort

Use df with fixed columns, skip tmpfs, and alert above a threshold.

#!/usr/bin/env bash
set -euo pipefail
limit=${1:-80}
df -P -x tmpfs -x devtmpfs | awk 'NR>1 {gsub("%","",$5); print $5, $6}' |
while read -r use mnt; do
  (( use >= limit )) && echo "ALERT $mnt at ${use}%"
done
exit 0

Create the archive, then list old ones by time and delete beyond 7.

#!/usr/bin/env bash
set -euo pipefail
src=${1:?src}; dst=${2:?dst}
mkdir -p "$dst"
tar -czf "$dst/backup-$(date +%F-%H%M).tgz" -C "$(dirname "$src")" "$(basename "$src")"
ls -1t "$dst"/backup-*.tgz | tail -n +8 | xargs -r rm -f

Loop over names, use systemctl is-active, and log actions.

#!/usr/bin/env bash
for s in nginx sshd crond; do
  if ! systemctl is-active --quiet "$s"; then
    echo "$(date '+%F %T') $s down, restarting"
    systemctl restart "$s" || echo "restart of $s failed" >&2
  fi
done

Read each line, skip the header, create the group and user only if missing.

#!/usr/bin/env bash
set -euo pipefail
while IFS=, read -r u g; do
  [[ $u == username ]] && continue
  getent group "$g" >/dev/null || groupadd "$g"
  id "$u" &>/dev/null || useradd -m -g "$g" "$u"
done < "${1:?csv}"

Use find with size output and sort.

find "${1:-.}" -type f -printf '%s %p
' 2>/dev/null | sort -rn | head -10 | awk '{printf "%.1f MB %s
", $1/1048576, $2}'

Use parameter expansion to swap the extension and mv -n to avoid overwriting.

for f in *.jpeg; do [[ -e $f ]] || continue; mv -n -- "$f" "${f%.jpeg}.jpg"; done

Loop with curl and a deadline using SECONDS.

#!/usr/bin/env bash
url=${1:-http://localhost:8080/health}
end=$((SECONDS+60))
until [[ $(curl -s -o /dev/null -w '%{http_code}' --max-time 3 "$url") == 200 ]]; do
  (( SECONDS >= end )) && { echo 'timed out' >&2; exit 1; }
  sleep 2
done
echo up

comm works on sorted input.

comm -23 <(sort -u a.txt) <(sort -u b.txt)

Hash every file, then show hashes seen more than once.

find "${1:-.}" -type f -exec md5sum {} + | sort | awk '{h=$1; $1=""; if (h==p) {print pf; print $0} p=h; pf=$0}' | sort -u

tail -F follows rotation; grep --line-buffered passes lines at once.

tail -Fn0 /var/log/app/app.log | grep --line-buffered ERROR | while read -r line; do
  logger -t appwatch "ERROR seen: $line"
done

Background each ssh, store PIDs in an array, and wait for each.

#!/usr/bin/env bash
declare -A pid
for h in web1 web2 db1; do ssh -o ConnectTimeout=5 "$h" uptime > "/tmp/$h.out" 2>&1 & pid[$h]=$!; done
fail=0
for h in "${!pid[@]}"; do wait "${pid[$h]}" || { echo "FAIL $h"; fail=1; }; done
exit $fail

Check the shape with a regex, then each octet is 0 to 255.

valid_ip(){
  local ip=$1 o
  [[ $ip =~ ^([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})$ ]] || return 1
  for o in "${BASH_REMATCH[@]:1}"; do (( 10#$o <= 255 )) || return 1; done
}
valid_ip 10.0.0.256 && echo ok || echo bad

Split into words, lower-case, count and sort.

tr -cs '[:alpha:]' '
' < book.txt | tr '[:upper:]' '[:lower:]' | sort | uniq -c | sort -rn | head -10

awk with a comma separator swaps fields and rebuilds the line.

awk -F, -v OFS=, '{t=$1; $1=$2; $2=t; print}' in.csv

Check size with stat and move it aside with a timestamp before writing.

log=/var/log/myjob.log
if [[ -f $log ]] && (( $(stat -c %s "$log") > 10485760 )); then
  mv "$log" "$log.$(date +%F-%H%M%S)"; gzip "$log".*[0-9] 2>/dev/null || true
fi
echo "$(date '+%F %T') run" >> "$log"

ps prints RSS in KB; awk adds it up.

ps -C "${1:-nginx}" -o rss= | awk '{s+=$1} END {printf "%.1f MB
", s/1024}'

Unpack into a new release folder, swap the current link, health check, and swap back on failure.

#!/usr/bin/env bash
set -euo pipefail
rel=/opt/app/releases/$(date +%Y%m%d%H%M%S)
prev=$(readlink -f /opt/app/current || true)
mkdir -p "$rel" && tar -xzf "${1:?artifact}" -C "$rel"
ln -sfn "$rel" /opt/app/current && systemctl restart app
if ! curl -sf --max-time 5 localhost:8080/health; then
  echo 'health failed, rolling back' >&2
  [[ -n $prev ]] && ln -sfn "$prev" /opt/app/current && systemctl restart app
  exit 1
fi
echo "deployed $rel"

Some allow man pages in live rounds; many do not allow Google. Ask at the start.

Bash unless they ask for POSIX. Say which you chose and why.

awk handles columns and sums well; for JSON, APIs or complex logic say you would use Python.

Type each solution here by hand, run it, break it, and fix it. Then write it again from memory.

Usually common one-liners: substitution, ranges, column sums and grouping.

It helps but has traps. Say you use it with pipefail and handle expected failures explicitly.

Unquoted variables, by far.

No, they are typical and commonly reported across many companies.

The exit status of the last command.

chmod +x script.sh.

for i in {1..10}; do echo $i; done.

while IFS= read -r line; do ...; done < file.

trap 'cleanup' EXIT INT TERM.

getopts 'vf:'.

flock -n on a lock file.

cd "$(dirname "${BASH_SOURCE[0]}")" && pwd.

Idempotent steps, release folders, a symlink switch, health check and automatic rollback.

Read from files or env, set +x around them, never pass as arguments.

Complex data, JSON APIs, heavy logic, long-lived services or when tests and types matter.

shellcheck, bash -n, bats-core tests and running in a clean container.