Integer comparisons (-eq, -ne, -gt, -lt, -ge, -le) in Bash Scripting - Time & Space Complexity

Time Complexity: Integer comparisons (-eq, -ne, -gt, -lt, -ge, -le)

O(n)

Understanding Time Complexity

When we use integer comparisons in bash scripts, it is helpful to know how the time to run these checks changes as we do more of them.

We want to understand how the number of comparisons affects the total time the script takes.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

count=0
for i in $(seq 1 $n)
do
  if [ "$i" -gt 10 ]; then
    count=$((count + 1))
  fi
done
    

This script counts how many numbers from 1 to n are greater than 10 using integer comparisons.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Integer comparison inside the if statement.
• How many times: The comparison runs once for each number from 1 to n, so n times.

How Execution Grows With Input

Each time we increase n, the script does one more comparison.

Input Size (n)	Approx. Operations
10	10 comparisons
100	100 comparisons
1000	1000 comparisons

Pattern observation: The number of comparisons grows directly with n, so doubling n doubles the work.

Final Time Complexity

Time Complexity: O(n)

This means the time to run the script grows in a straight line as the input size increases.

Common Mistake

[X] Wrong: "Integer comparisons inside a loop are instant and don't add up."

[OK] Correct: Each comparison takes a small amount of time, and when done many times, these add up linearly with the number of items.

Interview Connect

Understanding how simple operations like integer comparisons scale helps you write efficient scripts and explain your reasoning clearly in real situations.

Self-Check

"What if we replaced the loop with nested loops each doing integer comparisons? How would the time complexity change?"

Practice

1. Which operator checks if two integers are equal in a bash script?

easy

A. -gt

B. -ne

C. -lt

D. -eq

Solution

1. Step 1: Understand the meaning of each operator

   -eq means equal, -ne means not equal, -gt means greater than, -lt means less than.

2. Step 2: Identify the operator for equality

   The operator that checks if two integers are equal is -eq.

3. Final Answer:

   -eq -> Option D

4. Quick Check:

   Equality check = -eq [OK]

Hint: Remember: eq means equal, ne means not equal [OK]

Common Mistakes:

• Confusing -eq with -ne
• Using == instead of -eq in [ ]
• Forgetting spaces around operators

2. Which of the following is the correct syntax to check if variable x is greater than 10 in bash?

easy

A. [ $x > 10 ]

B. [ $x -gt 10 ]

C. [ $x -ge 10 ]

D. [ $x => 10 ]

Solution

1. Step 1: Recall integer comparison operators in bash

   For greater than, bash uses -gt inside [ ]. The symbol > is for string comparison or redirection.

2. Step 2: Check each option

   [ $x -gt 10 ] uses [ $x -gt 10 ] which is correct syntax for integer greater than check.

3. Final Answer:

   [ $x -gt 10 ] -> Option B

4. Quick Check:

   Greater than check uses -gt [OK]

Hint: Use -gt for greater than, not > inside [ ] [OK]

Common Mistakes:

• Using > instead of -gt inside [ ]
• Using => instead of -ge
• Missing spaces around brackets and operators

3. What will be the output of this bash script snippet?

num=5
if [ $num -lt 10 ]; then
echo "Less"
else
echo "More"
fi

medium

A. Less

B. More

C. Syntax Error

D. No output

Solution

1. Step 1: Evaluate the condition [ $num -lt 10 ]

   num is 5, 5 is less than 10, so condition is true.

2. Step 2: Determine which branch runs

   Since condition is true, the then branch runs and prints "Less".

3. Final Answer:

   Less -> Option A

4. Quick Check:

   5 < 10 is true, prints Less [OK]

Hint: If condition true, then branch runs; else runs otherwise [OK]

Common Mistakes:

• Confusing -lt with -le
• Forgetting spaces inside [ ]
• Using > instead of -lt

4. Identify the error in this bash snippet:

count=3
if [ $count -gt 5 ]
then
  echo "High"
fi

medium

A. No error, script runs fine

B. Missing semicolon or newline after condition

C. Missing spaces around brackets

D. Wrong operator -gt used

Solution

1. Step 1: Check if the if condition syntax is correct

   The if condition line ends with ] but the next line is then. Bash requires a newline or semicolon after ] before then.

2. Step 2: Identify the fix

   Add a newline (already present) or a semicolon after ] to separate condition and then. Here newline is present, so syntax is correct.

3. Step 3: Re-examine the snippet

   Actually, the snippet as shown is correct syntax if newline is present after ] before then. If newline missing, error occurs.

4. Final Answer:

   No error, script runs fine -> Option A

5. Quick Check:

   if condition must end with newline or semicolon before then [OK]

Hint: Put newline or semicolon after ] before then [OK]

Common Mistakes:

• Writing if [ condition ] then on same line without semicolon
• Forgetting spaces inside [ ]
• Using > instead of -gt

5. You want to write a bash script that prints "Valid" only if a variable age is between 18 and 30 inclusive. Which condition correctly checks this?

hard

A. [ $age -ge 18 -a $age -le 30 ]

B. [ $age -gt 18 -o $age -lt 30 ]

C. [ $age -ge 18 ] && [ $age -le 30 ]

D. [ $age -gt 18 -a $age -lt 30 ]

Solution

1. Step 1: Understand the range condition

   We want age >= 18 and age <= 30 inclusive, so both conditions must be true.

2. Step 2: Analyze each option

   [ $age -ge 18 -a $age -le 30 ] uses -a inside single [ ], which is valid but less recommended. [ $age -gt 18 -o $age -lt 30 ] uses -o (or), which is wrong. [ $age -ge 18 ] && [ $age -le 30 ] uses two separate [ ] with &&, which is correct and clear. [ $age -gt 18 -a $age -lt 30 ] uses > and < (not inclusive) and -a inside [ ].

3. Final Answer:

   [ $age -ge 18 ] && [ $age -le 30 ] -> Option C

4. Quick Check:

   Use && with separate [ ] for clear inclusive range [OK]

Hint: Use && with separate [ ] for AND conditions [OK]

Common Mistakes:

• Using -o (OR) instead of AND
• Using > and < instead of -ge and -le
• Combining multiple conditions inside one [ ] with -a (less clear)