String length (${#var}) in Bash Scripting - Time & Space Complexity

Time Complexity: String length (${#var})

O(1)

Understanding Time Complexity

We want to understand how the time it takes to get the length of a string changes as the string gets longer.

Specifically, how does using ${#var} behave when the string size grows?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

mystring="Hello, world!"
length=${#mystring}
echo "Length is $length"
    

This code gets the length of the string stored in mystring and prints it.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Counting each character in the string to find its length.
• How many times: Once per character in the string.

How Execution Grows With Input

As the string gets longer, the time to count its length grows in direct proportion.

Input Size (n)	Approx. Operations
10	10 character checks
100	100 character checks
1000	1000 character checks

Pattern observation: The work grows linearly as the string length increases.

Final Time Complexity

Time Complexity: O(n)

This means the time to get the string length grows directly with the number of characters in the string.

Common Mistake

[X] Wrong: "Getting the string length is instant no matter how long the string is."

[OK] Correct: The system must check each character to count length, so longer strings take more time.

Interview Connect

Knowing how simple operations like string length scale helps you reason about script performance and write efficient code.

Self-Check

"What if the string length was stored in a variable and updated as the string changes? How would that affect the time complexity of getting the length?"

Practice

1. What does the expression ${#var} do in a bash script?

easy

A. It converts the variable var to uppercase.

B. It returns the value of the variable var.

C. It counts the number of words in the variable var.

D. It returns the length of the string stored in the variable var.

Solution

1. Step 1: Understand the syntax ${#var}

   This syntax in bash returns the length of the string stored in the variable var.

2. Step 2: Differentiate from other operations

   It does not return the value itself, count words, or change case. It specifically counts characters.

3. Final Answer:

   It returns the length of the string stored in the variable var. -> Option D

4. Quick Check:

   Length of string = ${#var} [OK]

Hint: Remember: ${#var} counts characters in var [OK]

Common Mistakes:

• Confusing ${#var} with $var (value of variable)
• Thinking it counts words instead of characters
• Assuming it changes the string content

2. Which of the following is the correct way to get the length of a string variable name in bash?

easy

A. length=${name#}

B. length=$#name

C. length=${#name}

D. length=$name#

Solution

1. Step 1: Recall correct syntax for string length

   The correct syntax to get string length is ${#variable}, so for name it is ${#name}.

2. Step 2: Check each option

   length=${name#} uses wrong placement of #, length=$#name uses $ and # incorrectly, length=$name# appends # after variable incorrectly.

3. Final Answer:

   length=${#name} -> Option C

4. Quick Check:

   Use ${#var} to get length [OK]

Hint: Use ${#var} exactly to get string length [OK]

Common Mistakes:

• Placing # after variable name instead of before
• Using $# which counts positional parameters, not string length
• Confusing variable expansion syntax

3. What will be the output of the following bash script?

text="Hello World"
echo ${#text}

medium

A. 11

B. Error

C. 12

D. 10

Solution

1. Step 1: Count characters in the string "Hello World"

   The string has 11 characters: 5 letters in "Hello", 1 space, and 5 letters in "World".

2. Step 2: Understand ${#text} returns string length

   The command echo ${#text} prints the length, which is 11.

3. Final Answer:

   11 -> Option A

4. Quick Check:

   Length of "Hello World" = 11 [OK]

Hint: Count spaces too when using ${#var} [OK]

Common Mistakes:

• Ignoring spaces in length count
• Counting words instead of characters
• Expecting output to be string value instead of length

4. Consider this bash script snippet:

myvar=Hello
length=$#myvar
echo $length

What is the problem with this script?

medium

A. It will print the number of positional parameters, not string length.

B. It will print the length of the string correctly.

C. It will cause a syntax error due to wrong variable name.

D. It will print the string value instead of length.

Solution

1. Step 1: Understand what $# means in bash

   The symbol $# returns the number of positional parameters passed to the script, not the length of a string variable.

2. Step 2: Analyze the script behavior

   Assigning length=$#myvar tries to get positional parameters count, ignoring myvar. So it does not get string length.

3. Final Answer:

   It will print the number of positional parameters, not string length. -> Option A

4. Quick Check:

   $# counts parameters, not string length [OK]

Hint: Use ${#var} for length, not $# [OK]

Common Mistakes:

• Confusing $# (positional params) with ${#var} (string length)
• Expecting $# to work on variables
• Missing braces around variable name

5. You want to check if a user input stored in variable input is empty or not in a bash script. Which condition correctly uses string length to do this?

hard

A. if [ $#input -eq 0 ]; then echo "Empty input"; fi

B. if [ ${#input} -eq 0 ]; then echo "Empty input"; fi

C. if [ $input -eq 0 ]; then echo "Empty input"; fi

D. if [ ${input#} -eq 0 ]; then echo "Empty input"; fi

Solution

1. Step 1: Use ${#input} to get string length

   To check if input is empty, we check if its length is zero using ${#input}.

2. Step 2: Write correct if condition syntax

   The condition [ ${#input} -eq 0 ] correctly tests if the string length is zero.

3. Final Answer:

   if [ ${#input} -eq 0 ]; then echo "Empty input"; fi -> Option B

4. Quick Check:

   Check empty string with ${#var} == 0 [OK]

Hint: Test empty string with if [ ${#var} -eq 0 ] [OK]

Common Mistakes:

• Using $#input which is invalid
• Comparing string value directly to number
• Misplacing # symbol in variable expansion