DEV Community: Fahad Vahora

Linux Practical Set H Solution – Employee Gross Salary

Fahad Vahora — Fri, 14 Aug 2026 04:30:00 +0000

In this article, we will solve VNSGU TYBCA Semester 5 Linux (UNIX) Practical – Set H using shell scripting.

This practical focuses on:

User input
if-else
Arithmetic operations
Percentage calculation
Employee salary calculation
awk
bc

📌 Practical Question

Write a shell script that computes the gross salary of an employee according to the following:

If Basic Salary is less than ₹50,000

HRA = 20% of Basic Salary
DA = 164% of Basic Salary

If Basic Salary is greater than ₹50,000

HRA = 15% of Basic Salary
DA = 136% of Basic Salary

Input Requirement

The basic salary should be entered interactively through the keyboard.

Gross Salary Formula

Gross Salary = Basic Salary + DA + HRA

🧠 Understanding the Problem

Let:

Basic Salary = B

If:

B < 50000

then:

HRA = 20% of B
DA  = 164% of B

If:

B > 50000

then:

HRA = 15% of B
DA  = 136% of B

Finally:

Gross Salary = B + HRA + DA

⚠️ Important Note About ₹50,000

The original question specifies:

Basic Salary < 50000
Basic Salary > 50000

It does not explicitly define what should happen when Basic Salary is exactly ₹50,000.

Therefore, in the solutions below, the 50000 case is handled separately.

🧮 Example Calculation

Suppose:

Basic Salary = ₹40,000

Since:

40000 < 50000

we use:

HRA = 20% of 40000
    = 8000

DA = 164% of 40000
   = 65600

Therefore:

Gross Salary = 40000 + 8000 + 65600
             = ₹113600

✅ Solution 1: Using Basic Bash `if-else`

This is the simplest and most suitable solution for a university practical examination.

Shell Script

#!/bin/bash

echo "Enter Basic Salary:"
read basic

if [ "$basic" -lt 50000 ]
then
    hra=$((basic * 20 / 100))
    da=$((basic * 164 / 100))

elif [ "$basic" -gt 50000 ]
then
    hra=$((basic * 15 / 100))
    da=$((basic * 136 / 100))

else
    echo "Basic salary of exactly 50000 is not defined in the question."
    exit 1
fi

gross=$((basic + hra + da))

echo "-----------------------------"
echo "Basic Salary : $basic"
echo "HRA          : $hra"
echo "DA           : $da"
echo "Gross Salary : $gross"
echo "-----------------------------"

🔍 Step-by-Step Explanation

Step 1: Take Basic Salary

read basic

The salary entered by the user is stored in the variable basic.

Step 2: Check Salary Below ₹50,000

if [ "$basic" -lt 50000 ]

The -lt operator means:

Less than

So this condition checks:

basic < 50000

If the condition is true, HRA and DA are calculated using:

hra=$((basic * 20 / 100))
da=$((basic * 164 / 100))

Step 3: Check Salary Above ₹50,000

elif [ "$basic" -gt 50000 ]

The -gt operator means:

Greater than

So this condition checks:

basic > 50000

HRA and DA are then calculated using:

hra=$((basic * 15 / 100))
da=$((basic * 136 / 100))

Step 4: Calculate Gross Salary

gross=$((basic + hra + da))

The formula is:

Gross Salary = Basic Salary + HRA + DA

🖥️ Example Output – Basic Salary Less Than ₹50,000

Enter Basic Salary:
40000
-----------------------------
Basic Salary : 40000
HRA          : 8000
DA           : 65600
Gross Salary : 113600
-----------------------------

🖥️ Example Output – Basic Salary Greater Than ₹50,000

Suppose:

Basic Salary = 60000

Calculation:

HRA = 15% of 60000 = 9000
DA  = 136% of 60000 = 81600

Output:

Enter Basic Salary:
60000
-----------------------------
Basic Salary : 60000
HRA          : 9000
DA           : 81600
Gross Salary : 150600
-----------------------------

❌ Example Output – Basic Salary Exactly ₹50,000

Enter Basic Salary:
50000

Basic salary of exactly 50000 is not defined in the question.

The script handles this case separately because the original question does not specify an HRA/DA rule for exactly ₹50,000.

⚠️ Limitation of Basic Bash Arithmetic

Bash arithmetic using:

$(( ... ))

works with integers.

For example:

echo $((5 / 2))

produces:

not:

2.5

If decimal salary values need to be supported, awk or bc can be used.

✅ Solution 2: Using `awk`

awk supports floating-point arithmetic, so it is useful when the basic salary can contain decimal values.

Shell Script

#!/bin/bash

echo "Enter Basic Salary:"
read basic

awk -v basic="$basic" '
BEGIN {
    if (basic < 50000) {
        hra = basic * 20 / 100
        da = basic * 164 / 100
    }
    else if (basic > 50000) {
        hra = basic * 15 / 100
        da = basic * 136 / 100
    }
    else {
        print "Basic salary of exactly 50000 is not defined in the question."
        exit 1
    }

    gross = basic + hra + da

    printf "-----------------------------\n"
    printf "Basic Salary : %.2f\n", basic
    printf "HRA          : %.2f\n", hra
    printf "DA           : %.2f\n", da
    printf "Gross Salary : %.2f\n", gross
    printf "-----------------------------\n"
}'

🖥️ Example Output

Enter Basic Salary:
42500.50

-----------------------------
Basic Salary : 42500.50
HRA          : 8500.10
DA           : 69700.82
Gross Salary : 120701.42
-----------------------------

The %.2f format displays the values with two decimal places.

🔍 Why Use `awk`?

The main advantage is floating-point arithmetic.

For example:

awk 'BEGIN { printf "%.2f\n", 5 / 2 }'

Output:

2.50

So awk is useful when decimal values are required.

✅ Solution 3: Using `bc`

bc is another command-line calculator that can perform decimal calculations.

Shell Script

#!/bin/bash

echo "Enter Basic Salary:"
read basic

if (( $(echo "$basic < 50000" | bc -l) ))
then
    hra=$(echo "scale=2; $basic * 20 / 100" | bc)
    da=$(echo "scale=2; $basic * 164 / 100" | bc)

elif (( $(echo "$basic > 50000" | bc -l) ))
then
    hra=$(echo "scale=2; $basic * 15 / 100" | bc)
    da=$(echo "scale=2; $basic * 136 / 100" | bc)

else
    echo "Basic salary of exactly 50000 is not defined in the question."
    exit 1
fi

gross=$(echo "scale=2; $basic + $hra + $da" | bc)

echo "-----------------------------"
echo "Basic Salary : $basic"
echo "HRA          : $hra"
echo "DA           : $da"
echo "Gross Salary : $gross"
echo "-----------------------------"

🖥️ Example Output

Enter Basic Salary:
42500.50

-----------------------------
Basic Salary : 42500.50
HRA          : 8500.10
DA           : 69700.82
Gross Salary : 120701.42
-----------------------------

🔍 Understanding the `bc` Solution

This:

echo "$basic < 50000" | bc -l

checks the comparison using bc.

For example:

echo "42500.50 * 20 / 100" | bc

produces:

8500.10

The scale=2 option controls the number of decimal places in calculations.

📊 Comparing the Solutions

Method	Decimal Support	Difficulty	External Command	Recommended
Bash `if-else`	❌ Integer arithmetic	⭐ Easy	No	✅ Practical
`awk`	✅ Yes	⭐⭐	`awk`	✅ Excellent
`bc`	✅ Yes	⭐⭐⭐	`bc`	✅ Good

Which Solution Should You Use?

For a normal university practical with integer salary input, Solution 1 is the easiest and most suitable.

If decimal salary values are required, use Solution 2 (awk) or Solution 3 (bc).

🧠 Important Operators Used

Less Than

-lt

Example:

[ "$basic" -lt 50000 ]

Greater Than

-gt

Example:

[ "$basic" -gt 50000 ]

Equal

-eq

Example:

[ "$basic" -eq 50000 ]

⚠️ Common Mistakes

Mistake 1: Using Assignment Instead of Comparison

Wrong:

if [ basic -lt 50000 ]

Correct:

if [ "$basic" -lt 50000 ]

Mistake 2: Incorrect Percentage Calculation

Wrong:

hra=$((basic * 20%))

Correct:

hra=$((basic * 20 / 100))

Mistake 3: Forgetting DA Is More Than 100%

The question specifies:

DA = 164%

for salary below ₹50,000 and:

DA = 136%

for salary above ₹50,000.

Do not accidentally write 16.4% or 13.6%.

Mistake 4: Forgetting the Gross Salary Formula

Remember:

Gross Salary = Basic Salary + HRA + DA

Mistake 5: Ignoring the ₹50,000 Case

The question gives:

< 50000
> 50000

but does not define:

= 50000

So the script handles that case separately.

🎯 Practical Exam Tips

Remember the basic structure:

if [ "$basic" -lt 50000 ]
then
    # HRA 20%
    # DA 164%

elif [ "$basic" -gt 50000 ]
then
    # HRA 15%
    # DA 136%
fi

Percentage calculation:

value=$((basic * percentage / 100))

Gross salary:

gross=$((basic + hra + da))

📝 Quick Revision

Salary below ₹50,000

hra=$((basic * 20 / 100))
da=$((basic * 164 / 100))

Salary above ₹50,000

hra=$((basic * 15 / 100))
da=$((basic * 136 / 100))

Gross Salary

gross=$((basic + hra + da))

Compare Less Than

[ "$basic" -lt 50000 ]

Compare Greater Than

[ "$basic" -gt 50000 ]

📚 Related Linux Practical Sets

This solution is part of the VNSGU TYBCA Sem 5 Linux (UNIX) Practical – OCT/Nov 2025 solution series.

Set A – Simple Interest & Compound Interest
Set B – Vowels Count & Case Conversion
Set C – Palindrome String
Set D – File Operations & Text Processing
Set E – Display Lines with Validation
Set F – Count Files & Directories
Set G – Recently Modified Files
Set H – Employee Gross Salary

🐧 Conclusion

The Set H practical is a good exercise for understanding conditional statements, percentage calculations, user input, and arithmetic operations in shell scripting.

The basic logic is:

Read Basic Salary
       ↓
Check Salary
       ↓
Calculate HRA and DA
       ↓
Calculate Gross Salary
       ↓
Display Result

For a basic university practical, the Bash if-else solution is usually enough.

If decimal calculations are required, awk or bc can be used.

💬 What Do You Prefer?

For salary calculations in shell scripting, which approach do you prefer?

Basic Bash arithmetic, awk, or bc?

Share your approach in the comments! 🐧💻

📌 Tags

linux shell unix beginners

Linux Practical Set F Solution – Count Files and Directories

Fahad Vahora — Thu, 13 Aug 2026 04:30:00 +0000

In this article, we will solve VNSGU TYBCA Semester 5 Linux (UNIX) Practical – Set F using shell scripting.

This practical focuses on:

File and directory identification
Current working directory
File test operators
Shell loops
find
wc

📌 Practical Question

Write a shell script to find total number of files and total number of directories in current working directory.

The script should count the files and directories present in the current working directory.

Important

For this question, we are counting the direct contents of the current directory only.

For example:

project/
├── file1.txt
├── file2.txt
├── script.sh
├── notes/
└── programs/

The result is:

Files       : 3
Directories : 2

Files inside notes/ or programs/ are not counted.

🧠 Concepts Used

Concept	Purpose
`pwd`	Display current directory
`find`	Search files/directories
`-type f`	Identify regular files
`-type d`	Identify directories
`wc -l`	Count results
`for` loop	Process directory entries
`-f`	File test
`-d`	Directory test

✅ Solution 1: Using `find`

This is one of the cleanest solutions for the practical.

Shell Script

#!/bin/bash

files=$(find . -maxdepth 1 -type f | wc -l)

directories=$(find . -mindepth 1 -maxdepth 1 -type d | wc -l)

echo "Current Working Directory: $(pwd)"
echo "Total Files       : $files"
echo "Total Directories : $directories"

🔍 Step-by-Step Explanation

Step 1: Find Files

find . -maxdepth 1 -type f

Here:

. means the current directory.
-maxdepth 1 means don't go inside subdirectories.
-type f means search for regular files.

For example:

./file1.txt
./file2.txt
./script.sh

Step 2: Count the Files

find . -maxdepth 1 -type f | wc -l

The | is called a pipe.

The output of find becomes the input of wc.

find
  ↓
pipe
  ↓
wc -l

wc -l counts the number of lines returned by find.

Step 3: Find Directories

find . -mindepth 1 -maxdepth 1 -type d

This finds directories in the current directory.

The important part is:

-mindepth 1

It prevents find from counting the current directory . itself.

🖥️ Example

Suppose the current directory contains:

file1.txt
file2.txt
program.sh
notes/
backup/

Run:

./script.sh

Output:

Current Working Directory: /home/student/linux
Total Files       : 3
Total Directories : 2

✅ Solution 2: Using Shell Loop and File Tests

This approach is useful for understanding shell scripting logic instead of depending mainly on find.

Shell Script

#!/bin/bash

files=0
directories=0

for item in *
do
    if [ -f "$item" ]
    then
        files=$((files + 1))

    elif [ -d "$item" ]
    then
        directories=$((directories + 1))
    fi
done

echo "Current Working Directory: $(pwd)"
echo "Total Files       : $files"
echo "Total Directories : $directories"

🔍 How This Solution Works

Step 1: Initialize Counters

files=0
directories=0

Both counters start from zero.

Step 2: Loop Through Items

for item in *

The * represents entries in the current directory.

The loop processes each item one by one.

Step 3: Check for File

if [ -f "$item" ]

The -f test returns true if the item is a regular file.

Then:

files=$((files + 1))

increases the file counter.

Step 4: Check for Directory

elif [ -d "$item" ]

The -d test returns true if the item is a directory.

Then:

directories=$((directories + 1))

increases the directory counter.

🖥️ Example

Suppose:

project/
├── a.txt
├── b.txt
├── c.sh
├── notes/
└── backup/

The loop processes:

a.txt     → File
b.txt     → File
c.sh      → File
notes     → Directory
backup    → Directory

Output:

Current Working Directory: /home/student/project
Total Files       : 3
Total Directories : 2

✅ Solution 3: Using `find` with `-mindepth`

We can also count both types directly without first storing the results in variables.

Shell Script

#!/bin/bash

echo "Current Working Directory: $(pwd)"

echo "Total Files       : $(find . -mindepth 1 -maxdepth 1 -type f | wc -l)"

echo "Total Directories : $(find . -mindepth 1 -maxdepth 1 -type d | wc -l)"

The -mindepth 1 option ensures that the current directory itself is not counted.

🔍 Understanding `-mindepth`

Consider:

find . -maxdepth 1 -type d

It can return:

.
./notes
./backup

The . represents the current directory.

Now:

find . -mindepth 1 -maxdepth 1 -type d

returns:

./notes
./backup

So there is no need to subtract 1 from the result.

📊 Comparing the Solutions

Method	Main Concept	Difficulty	Recommended
`find` + `wc`	Linux commands	⭐ Easy	✅ Excellent
`for` + `-f/-d`	Shell scripting	⭐⭐	✅ Excellent
`find` + `-mindepth`	`find` options	⭐⭐	✅ Excellent

Which Solution Should You Use?

For the practical exam, Solution 1 or Solution 3 is very convenient.

If the examiner wants to see your shell scripting logic, Solution 2 is a better choice because it uses:

for
if
-f
-d

🧠 Important Difference: `-maxdepth 1`

This is very important for this question.

Consider:

project/
├── a.txt
├── notes/
│   ├── b.txt
│   └── c.txt
└── script.sh

If we use:

find . -type f

the result includes:

./a.txt
./notes/b.txt
./notes/c.txt
./script.sh

So it searches recursively.

But:

find . -maxdepth 1 -type f

only finds:

./a.txt
./script.sh

Therefore, -maxdepth 1 is important when the question specifically asks for files in the current working directory.

⚠️ Common Mistakes

Mistake 1: Counting Recursively

Don't use:

find . -type f | wc -l

if the question means only the current directory.

This will also count files inside subdirectories.

Use:

find . -maxdepth 1 -type f | wc -l

Mistake 2: Counting `.` as a Directory

This:

find . -maxdepth 1 -type d

includes:

which represents the current directory.

Use:

-mindepth 1

to exclude it.

Mistake 3: Forgetting Quotes

Prefer:

[ -f "$item" ]

instead of:

[ -f $item ]

Quotes make the script safer when file or directory names contain spaces.

🎯 Practical Exam Tips

Remember these important commands.

Find Files

find . -maxdepth 1 -type f

Find Directories

find . -mindepth 1 -maxdepth 1 -type d

Count Results

wc -l

Check File

[ -f "$item" ]

Check Directory

[ -d "$item" ]

Current Directory

pwd

📝 Quick Revision

The simplest command-based solution is:

files=$(find . -maxdepth 1 -type f | wc -l)

directories=$(find . -mindepth 1 -maxdepth 1 -type d | wc -l)

echo "Files       : $files"
echo "Directories : $directories"

The shell-loop approach is:

for item in *
do
    if [ -f "$item" ]
    then
        files=$((files + 1))
    elif [ -d "$item" ]
    then
        directories=$((directories + 1))
    fi
done

📚 Related Linux Practical Sets

This solution is part of the VNSGU TYBCA Sem 5 Linux (UNIX) Practical – OCT/Nov 2025 solution series.

Set A – Simple Interest & Compound Interest
Set B – Vowels Count & Case Conversion
Set C – Palindrome String
Set D – File Operations & Text Processing
Set E – Display Lines with Validation
Set F – Count Files & Directories
Set G – Recently Modified Files
Set H – Employee Gross Salary

🐧 Conclusion

The Set F practical is a good exercise for understanding how Linux identifies files and directories.

The most important concepts are:

-type f → File
-type d → Directory
-maxdepth 1 → Do not search inside subdirectories
-mindepth 1 → Exclude the starting directory itself

If you understand these options, you can easily solve variations of this practical question.

💬 What Do You Prefer?

Which approach do you prefer for counting files and directories?

find command or shell for loop with -f and -d?

Share your approach in the comments! 🐧💻

📌 Tags

linux shell unix beginners

Linux Practical Set G Solution – Find Files Modified in Last 7 Days

Fahad Vahora — Thu, 13 Aug 2026 04:30:00 +0000

In this article, we will solve VNSGU TYBCA Semester 5 Linux (UNIX) Practical – Set G using shell scripting.

This practical focuses on:

Finding recently modified files
File modification time
find
sort
awk
ls
du
stat
File size
Current working directory

📌 Practical Question

Write a shell script to find all files in the current directory that were modified in the last 7 days and display their names and sizes.

The script should:

Search for files in the current directory.
Find files modified within the last 7 days.
Display the file names.
Display the file sizes.

🧠 Concepts Used

Command / Option	Purpose
`find`	Search for files
`-type f`	Select regular files
`-mtime`	Check modification time
`-maxdepth`	Limit search depth
`sort`	Sort command output
`awk`	Process and format output
`ls -lh`	Display file information
`du -h`	Display file size
`stat`	Display file information

⏱️ Understanding `-mtime`

The -mtime option is used with find to search files according to their modification time.

For example:

find . -mtime -7

means:

Find files modified less than 7 complete 24-hour periods ago.

The - before 7 means less than 7.

Common Examples

-mtime -1

→ Modified within the last 1 day.

-mtime -7

→ Modified within the last 7 complete 24-hour periods.

-mtime +7

→ Modified more than 7 complete 24-hour periods ago.

For this practical, we use:

-mtime -7

⚠️ Important: `-mtime` Uses 24-Hour Periods

find -mtime works with complete 24-hour periods, not simply calendar dates.

Therefore:

-mtime -7

means files whose age is less than 7 complete 24-hour periods.

If an exact time-based 7-day window is required, -mmin can be used.

✅ Solution 1: Using `find` and `ls`

This is one of the simplest solutions for the practical examination.

Shell Script

#!/bin/bash

echo "Files modified in the last 7 days:"
echo "-----------------------------------"

find . -maxdepth 1 -type f -mtime -7 -exec ls -lh {} \;

How It Works

find .

Searches from the current directory.

-maxdepth 1

prevents the search from going inside subdirectories.

-type f

selects regular files only.

-mtime -7

selects files modified within the last 7 complete 24-hour periods.

Finally:

-exec ls -lh {} \;

runs ls -lh for every matching file.

🖥️ Example Output

Suppose the current directory contains:

notes.txt
program.sh
old.txt
data.csv

and three files were modified within the last 7 days.

The output may look like:

Files modified in the last 7 days:
-----------------------------------
-rw-r--r-- 1 user user 2.1K Aug  8 09:30 ./notes.txt
-rwxr-xr-x 1 user user 1.5K Aug  7 16:20 ./program.sh
-rw-r--r-- 1 user user 8.4K Aug  6 11:45 ./data.csv

The exact permissions, dates, owner, and sizes depend on the system.

✅ Solution 2: Display Only File Name and Size

The previous solution displays complete ls -lh information.

If the question specifically asks for file name and size, we can make the output cleaner.

Shell Script

#!/bin/bash

echo "Files modified in the last 7 days:"
echo "-----------------------------------"

find . -maxdepth 1 -type f -mtime -7 -print0 |
while IFS= read -r -d '' file
do
    size=$(du -h "$file" | cut -f1)

    echo "File: $file"
    echo "Size: $size"
    echo
done

How It Works

-print0

separates file names using a null character.

This is useful for file names containing spaces.

For example:

my notes.txt

can be processed safely.

Then:

du -h "$file"

gets the file size in human-readable format.

For example:

4.0K    ./notes.txt

The cut -f1 extracts the size.

🖥️ Example Output

Files modified in the last 7 days:
-----------------------------------

File: ./notes.txt
Size: 4.0K

File: ./program.sh
Size: 8.0K

File: ./data.csv
Size: 12K

✅ Solution 3: Using `find` and `stat`

stat can be used to get the exact file size in bytes.

Shell Script

#!/bin/bash

echo "Files modified in the last 7 days:"
echo "-----------------------------------"

find . -maxdepth 1 -type f -mtime -7 -print0 |
while IFS= read -r -d '' file
do
    size=$(stat -c "%s" "$file")

    echo "File: $file"
    echo "Size: $size bytes"
    echo
done

Understanding `stat`

The command:

stat -c "%s" "$file"

returns the file size in bytes.

For example:

means the file size is 4096 bytes.

Here:

%s → File size in bytes

🖥️ Example Output

Files modified in the last 7 days:
-----------------------------------

File: ./notes.txt
Size: 4096 bytes

File: ./program.sh
Size: 1536 bytes

File: ./data.csv
Size: 8192 bytes

✅ Solution 4: Using `find`, `sort` and `awk`

This is an interesting approach when we want to sort the files according to their modification time and then display their names and sizes.

Here, find finds the files, sort sorts the results, and awk formats the output.

Shell Script

#!/bin/bash

echo "Files modified in the last 7 days:"
echo "-----------------------------------"

find . -maxdepth 1 -type f -mtime -7 \
    -printf '%T@ %s %p\n' |
sort -n |
awk '{
    printf "File: %-25s Size: %s bytes\n", $3, $2
}'

Understanding the `find` Output

The important part is:

-printf '%T@ %s %p\n'

These format specifiers mean:

%T@ → Modification timestamp
%s  → File size in bytes
%p  → File path/name

For example, the generated output may look like:

1754650200.123 2048 ./notes.txt
1754700300.456 4096 ./program.sh
1754750100.789 1024 ./data.txt

Sorting the Files

The output is passed to:

sort -n

The -n option performs numeric sorting.

Since the modification timestamp is the first value, the files are sorted according to their modification time.

The oldest matching file appears first.

Displaying the Result with `awk`

Finally:

awk '{
    printf "File: %-25s Size: %s bytes\n", $3, $2
}'

formats the output.

Here:

$2 → File size
$3 → File name/path

🔄 Display Latest Modified File First

If we want the most recently modified file first, use:

find . -maxdepth 1 -type f -mtime -7 \
    -printf '%T@ %s %p\n' |
sort -nr |
awk '{
    printf "File: %-25s Size: %s bytes\n", $3, $2
}'

Here:

-n → Numeric sorting
-r → Reverse order

Therefore:

sort -nr

sorts the modification timestamps from newest to oldest.

🖥️ Example Output

Files modified in the last 7 days:
-----------------------------------
File: ./data.txt              Size: 1024 bytes
File: ./notes.txt             Size: 2048 bytes
File: ./program.sh            Size: 4096 bytes

The exact order depends on the modification timestamps.

⚠️ Note About File Names with Spaces

The simple awk example above assumes that file names do not contain spaces.

For example:

my notes.txt

can cause fields to be split by awk.

For robust scripts, the -print0 + read -d '' approach from Solution 2 is safer.

For a basic university practical, however, the find + sort + awk approach is useful for demonstrating how Linux commands can be combined.

🔍 Understanding the Command Flow

The sort solution follows this pipeline:

find
  ↓
Find files modified in last 7 days
  ↓
-printf
  ↓
Generate timestamp + size + filename
  ↓
sort
  ↓
Sort by modification timestamp
  ↓
awk
  ↓
Format the output

This is a good example of combining multiple Linux commands using a pipeline.

📊 Comparing the Solutions

Method	Main Commands	Output	Difficulty	Recommended
Solution 1	`find + ls`	Full file information	⭐	✅ Excellent
Solution 2	`find + du`	Name + readable size	⭐⭐	✅ Excellent
Solution 3	`find + stat`	Name + size in bytes	⭐⭐	✅ Good
Solution 4	`find + sort + awk`	Sorted name + size	⭐⭐⭐	🔥 Advanced

Which Solution Should You Use?

For a practical examination:

Beginner-friendly: Solution 1

Only name and readable size: Solution 2

Size in bytes: Solution 3

Want to demonstrate sort + awk: Solution 4

🧠 Important Difference: `-mtime` vs `-mmin`

find provides both -mtime and -mmin.

Using `-mtime`

find . -maxdepth 1 -type f -mtime -7

This works with complete 24-hour periods.

Using `-mmin`

find . -maxdepth 1 -type f -mmin -10080

Because:

7 days × 24 hours × 60 minutes = 10080 minutes

-mmin can be useful when a minute-based time range is required.

For this practical, -mtime -7 is the straightforward solution.

🧠 Current Directory vs Recursive Search

This distinction is important.

Current Directory Only

find . -maxdepth 1 -type f -mtime -7

This searches only the current directory.

Current Directory and Subdirectories

find . -type f -mtime -7

This searches recursively.

Since the question specifically says:

in the current directory

we use:

-maxdepth 1

⚠️ Common Mistakes

Mistake 1: Forgetting `-type f`

Don't use:

find . -mtime -7

because the result can include directories.

Use:

find . -type f -mtime -7

Mistake 2: Searching Inside Subdirectories

Don't use:

find . -type f -mtime -7

if only the current directory should be searched.

Use:

find . -maxdepth 1 -type f -mtime -7

Mistake 3: Using `-mtime 7`

These are different:

-mtime 7

and:

-mtime -7

-mtime 7 refers to a particular 24-hour age bucket.

-mtime -7 means less than 7 complete 24-hour periods old.

For "modified in the last 7 days", -mtime -7 is generally the intended approach.

Mistake 4: Confusing `sort -n` and `sort -nr`

sort -n

sorts numeric values in ascending order.

sort -nr

sorts numeric values in descending order.

Therefore:

sort -n  → Older → Newer
sort -nr → Newer → Older

Mistake 5: Parsing `ls` Carelessly

Commands such as:

ls -lh | awk ...

can become unreliable when file names contain spaces or special characters.

For safer file-name handling, use:

find ... -print0

with:

read -d ''

🎯 Practical Exam Tips

Remember this basic command:

find . -maxdepth 1 -type f -mtime -7

It means:

.             → Current directory
-maxdepth 1   → Do not enter subdirectories
-type f       → Files only
-mtime -7     → Modified within the last 7 complete days

For human-readable file size:

ls -lh filename

or:

du -h filename

For file size in bytes:

stat -c "%s" filename

For sorting numeric values:

sort -n

For reverse numeric sorting:

sort -nr

📝 Quick Revision

Find recently modified files

find . -maxdepth 1 -type f -mtime -7

Find files and display information

find . -maxdepth 1 -type f -mtime -7 -exec ls -lh {} \;

Get human-readable size

du -h "$file"

Get size in bytes

stat -c "%s" "$file"

Sort by modification timestamp

sort -n

Sort newest first

sort -nr

📚 Related Linux Practical Sets

This solution is part of the VNSGU TYBCA Sem 5 Linux (UNIX) Practical – OCT/Nov 2025 solution series.

Set A – Simple Interest & Compound Interest
Set B – Vowels Count & Case Conversion
Set C – Palindrome String
Set D – File Operations & Text Processing
Set E – Display Lines with Validation
Set F – Count Files & Directories
Set G – Recently Modified Files
Set H – Employee Gross Salary

🐧 Conclusion

The Set G practical is a useful exercise for learning how Linux can search files based on their modification time and display their sizes.

The most important command is:

find . -maxdepth 1 -type f -mtime -7

You can then combine it with other Linux commands depending on the required output:

find → Find files
ls   → Display file information
du   → Display readable size
stat → Display exact size
sort → Sort results
awk  → Format results

The find + sort + awk solution is especially useful for understanding how multiple Linux commands can work together through a pipeline.

💬 What Do You Prefer?

For finding recently modified files, which approach do you prefer?

find + ls, find + du, find + stat, or the find + sort + awk approach?

Share your approach in the comments! 🐧💻

📌 Tags

linux shell unix beginners

Linux Practical Set D Solution – File Operations & Text Processing

Fahad Vahora — Wed, 12 Aug 2026 04:30:00 +0000

In this article, we will solve VNSGU TYBCA Semester 5 Linux (UNIX) Practical – Set D using shell scripting.

This practical focuses on basic file handling and text-processing commands such as:

cat
head
tail
wc
grep

📌 Practical Question

Write a shell script to perform following:

Create a file named marks.txt and insert 5 lines of text.
Display the first 3 lines of marks.txt.
Display the last 2 lines of marks.txt.
Count the number of words, lines, and characters in marks.txt.
Search for the word Linux in marks.txt.

🧠 Commands Used

Command	Purpose
`cat`	Create and display file content
`head`	Display the beginning of a file
`tail`	Display the end of a file
`wc`	Count lines, words, and characters
`grep`	Search for text

✅ Solution 1: Using `read`, `head`, `tail`, `wc` and `grep`

This solution takes 5 lines interactively from the user and stores them in marks.txt.

Shell Script

#!/bin/bash

echo "Enter 5 lines of text:"

> marks.txt

for ((i=1; i<=5; i++))
do
    read -p "Enter line $i: " line
    echo "$line" >> marks.txt
done

echo
echo "----- First 3 Lines -----"
head -n 3 marks.txt

echo
echo "----- Last 2 Lines -----"
tail -n 2 marks.txt

echo
echo "----- File Statistics -----"
echo "Lines      : $(wc -l < marks.txt)"
echo "Words      : $(wc -w < marks.txt)"
echo "Characters : $(wc -m < marks.txt)"

echo
echo "----- Searching for Linux -----"
grep "Linux" marks.txt

🔍 Step-by-Step Explanation

Step 1: Create or Empty the File

> marks.txt

This creates marks.txt if it does not exist.

If the file already exists, its previous content is removed.

Step 2: Take 5 Lines from the User

for ((i=1; i<=5; i++))
do
    read -p "Enter line $i: " line
    echo "$line" >> marks.txt
done

The loop runs exactly 5 times.

For example:

Enter line 1: Linux is an operating system
Enter line 2: Linux supports shell scripting
Enter line 3: Shell commands are useful
Enter line 4: Unix and Linux are related
Enter line 5: Linux is widely used

Each line is appended to marks.txt.

The >> operator is used to append content to the file.

Step 3: Display First 3 Lines

head -n 3 marks.txt

The head command displays the beginning of a file.

Here:

-n 3

means:

Display the first 3 lines.

Step 4: Display Last 2 Lines

tail -n 2 marks.txt

The tail command displays the end of a file.

Here:

-n 2

means:

Display the last 2 lines.

Step 5: Count Lines

wc -l < marks.txt

The -l option counts the number of lines.

For our five-line file:

The < redirects the file content to wc, so only the number is displayed.

Step 6: Count Words

wc -w < marks.txt

The -w option counts the number of words in the file.

Step 7: Count Characters

wc -m < marks.txt

The -m option counts the number of characters.

This is preferable to plain wc when the question specifically asks for characters.

Step 8: Search for Linux

grep "Linux" marks.txt

The grep command searches for the word or pattern Linux.

It displays every line containing Linux.

🖥️ Sample Output

Enter 5 lines of text:
Enter line 1: Linux is an operating system
Enter line 2: Linux supports shell scripting
Enter line 3: Shell commands are useful
Enter line 4: Unix and Linux are related
Enter line 5: Linux is widely used

----- First 3 Lines -----
Linux is an operating system
Linux supports shell scripting
Shell commands are useful

----- Last 2 Lines -----
Unix and Linux are related
Linux is widely used

----- File Statistics -----
Lines      : 5
Words      : 24
Characters : 142

----- Searching for Linux -----
Linux is an operating system
Linux supports shell scripting
Unix and Linux are related
Linux is widely used

The exact word and character counts will depend on the text entered by the user.

🔄 Solution 2: Using `cat` to Insert 5 Lines

The question can also be solved using cat.

#!/bin/bash

echo "Enter 5 lines of text:"

cat > marks.txt

echo
echo "----- First 3 Lines -----"
head -n 3 marks.txt

echo
echo "----- Last 2 Lines -----"
tail -n 2 marks.txt

echo
echo "----- File Statistics -----"
echo "Lines      : $(wc -l < marks.txt)"
echo "Words      : $(wc -w < marks.txt)"
echo "Characters : $(wc -m < marks.txt)"

echo
echo "----- Searching for Linux -----"
grep "Linux" marks.txt

After entering the five lines, press:

Ctrl + D

to finish the input.

Which Method Is Better?

For beginners, Solution 1 is easier to understand because it clearly shows the five iterations of the loop.

The cat method is shorter and demonstrates interactive file creation using cat.

🔄 Solution 3: Automatically Create the File Using Here Document

If you don't want the user to enter the five lines manually, you can use a here document.

#!/bin/bash

cat > marks.txt << EOF
Linux is an operating system
Linux supports shell scripting
Shell commands are useful
Unix and Linux are related
Linux is widely used
EOF

echo "----- First 3 Lines -----"
head -n 3 marks.txt

echo
echo "----- Last 2 Lines -----"
tail -n 2 marks.txt

echo
echo "----- File Statistics -----"
echo "Lines      : $(wc -l < marks.txt)"
echo "Words      : $(wc -w < marks.txt)"
echo "Characters : $(wc -m < marks.txt)"

echo
echo "----- Searching for Linux -----"
grep "Linux" marks.txt

Here:

<< EOF

allows multiple lines of text to be provided as input to the command.

The EOF at the end marks the end of the input.

🔍 Searching for Linux Case-Insensitively

By default:

grep "Linux" marks.txt

is case-sensitive.

Therefore, these are treated differently:

Linux
linux
LINUX

If the search should ignore uppercase/lowercase differences, use:

grep -i "Linux" marks.txt

The -i option makes the search case-insensitive.

🔄 Alternative: Using `sed`

Although head and tail are the simplest commands for this question, sed can also be used.

First 3 Lines

sed -n '1,3p' marks.txt

Here:

-n → Suppresses automatic output
1,3 → Lines 1 to 3
p → Print

Last 2 Lines

We can calculate the total number of lines first:

total=$(wc -l < marks.txt)
start=$((total - 1))

sed -n "${start},${total}p" marks.txt

However, for this practical, head and tail are simpler and easier to remember.

📊 Important Commands at a Glance

Requirement	Command
Create/empty file	`> marks.txt`
Append text	`echo "text" >> marks.txt`
First 3 lines	`head -n 3 marks.txt`
Last 2 lines	`tail -n 2 marks.txt`
Count lines	`wc -l marks.txt`
Count words	`wc -w marks.txt`
Count characters	`wc -m marks.txt`
Search Linux	`grep "Linux" marks.txt`
Case-insensitive search	`grep -i "Linux" marks.txt`

🧠 Why Use `wc -m` for Characters?

A common mistake is to use:

wc marks.txt

and assume that the third value is the character count.

By default, wc generally displays:

lines words bytes

Therefore, when the question specifically asks for characters, use:

wc -m marks.txt

This makes the intention of the script clear.

⚠️ Common Mistakes

Mistake 1: Using `>` Instead of `>>`

This:

echo "$line" > marks.txt

overwrites the file every time.

Therefore, after the loop only the last line would remain.

Use:

echo "$line" >> marks.txt

to append each line.

Mistake 2: Using `wc` for Character Count

Instead of:

wc marks.txt

use:

wc -m marks.txt

when you specifically need the character count.

Mistake 3: Forgetting Case Sensitivity

This:

grep "Linux" marks.txt

does not necessarily match:

linux
LINUX

Use:

grep -i "Linux" marks.txt

when a case-insensitive search is required.

🎯 Practical Exam Tips

Remember these commands:

head -n 3 marks.txt

→ First 3 lines

tail -n 2 marks.txt

→ Last 2 lines

wc -l marks.txt

→ Number of lines

wc -w marks.txt

→ Number of words

wc -m marks.txt

→ Number of characters

grep "Linux" marks.txt

→ Search for Linux

📚 Related Linux Practical Sets

This solution is part of the VNSGU TYBCA Sem 5 Linux (UNIX) Practical – OCT/Nov 2025 solution series.

Set A – Simple Interest & Compound Interest
Set B – Vowels Count & Case Conversion
Set C – Palindrome String
Set D – File Operations & Text Processing
Set E – Display Lines with Validation
Set F – Count Files & Directories
Set G – Recently Modified Files
Set H – Employee Gross Salary

🐧 Conclusion

Set D is an important Linux practical because it combines several commonly used file and text-processing commands in one shell script.

The main commands to remember are:

cat   → File creation/input
head  → Beginning of file
tail  → End of file
wc    → Counting
grep  → Searching

Practice these commands individually first and then combine them into the complete shell script.

💬 What Do You Prefer?

For displaying specific lines from a file, which approach do you prefer?

head / tail or sed?

Share your approach in the comments! 🐧💻

📌 Tags

linux shell unix beginners

Linux Practical Set E Solution – Display Lines from a File with Validation

Fahad Vahora — Wed, 12 Aug 2026 04:30:00 +0000

In this article, we will solve VNSGU TYBCA Semester 5 Linux (UNIX) Practical – Set E using shell scripting.

This practical focuses on:

Command-line arguments
File validation
Numeric validation
Line range validation
Displaying specific lines from a file
sed
head
tail

📌 Practical Question

Write a shell script that will pass file name and two numbers a1 and a2. Display line a1 to a2 from that file. [Proper validation required]

The script should accept:

filename
a1 = starting line number
a2 = ending line number

For example:

./script.sh marks.txt 3 7

This should display lines 3 to 7 from marks.txt.

🧠 What Are Command-Line Arguments?

When a shell script is executed, values can be passed directly from the command line.

Example:

./script.sh marks.txt 3 7

Here:

Argument	Meaning
`$0`	Script name
`$1`	File name
`$2`	Starting line
`$3`	Ending line
`$#`	Number of arguments

So:

$1 = marks.txt
$2 = 3
$3 = 7

✅ Solution 1: Using `sed` with Proper Validation

sed is a very suitable command for displaying a specific range of lines.

Shell Script

#!/bin/bash

# Check number of arguments
if [ $# -ne 3 ]
then
    echo "Usage: $0 <file> <start_line> <end_line>"
    exit 1
fi

file=$1
a1=$2
a2=$3

# Check whether file exists
if [ ! -f "$file" ]
then
    echo "Error: File does not exist."
    exit 1
fi

# Check whether file is readable
if [ ! -r "$file" ]
then
    echo "Error: File is not readable."
    exit 1
fi

# Check whether a1 is a positive integer
if ! [[ "$a1" =~ ^[1-9][0-9]*$ ]]
then
    echo "Error: Starting line must be a positive integer."
    exit 1
fi

# Check whether a2 is a positive integer
if ! [[ "$a2" =~ ^[1-9][0-9]*$ ]]
then
    echo "Error: Ending line must be a positive integer."
    exit 1
fi

# Check line range
if [ "$a1" -gt "$a2" ]
then
    echo "Error: Starting line must be less than or equal to ending line."
    exit 1
fi

# Check whether starting line exists
total_lines=$(wc -l < "$file")

if [ "$a1" -gt "$total_lines" ]
then
    echo "Error: Starting line is beyond the end of the file."
    exit 1
fi

echo "Displaying lines $a1 to $a2 from $file:"
sed -n "${a1},${a2}p" "$file"

🔍 Step-by-Step Explanation

Step 1: Validate Number of Arguments

if [ $# -ne 3 ]

The script requires exactly 3 arguments:

1. File name
2. Starting line
3. Ending line

For example:

./script.sh marks.txt 3 7

If the user enters:

./script.sh marks.txt 3

the script displays the correct usage and exits.

Step 2: Store Arguments in Variables

file=$1
a1=$2
a2=$3

Now the values are easier to understand.

file → marks.txt
a1   → 3
a2   → 7

Step 3: Check File Existence

if [ ! -f "$file" ]

The -f test checks whether the given path is a regular file.

If the file does not exist:

Error: File does not exist.

and the script stops.

Step 4: Check File Read Permission

if [ ! -r "$file" ]

The -r test checks whether the file is readable.

This prevents the script from trying to read a file that the current user cannot access.

Step 5: Validate Starting Line

if ! [[ "$a1" =~ ^[1-9][0-9]*$ ]]

This checks that a1 contains a positive integer.

Valid examples:

Invalid examples:

0
-5
abc
2.5

Step 6: Validate Ending Line

The same validation is applied to a2:

if ! [[ "$a2" =~ ^[1-9][0-9]*$ ]]

This ensures that the ending line is also a positive integer.

Step 7: Validate the Range

if [ "$a1" -gt "$a2" ]

The starting line cannot be greater than the ending line.

For example:

a1 = 3
a2 = 7

is valid.

But:

a1 = 7
a2 = 3

is invalid.

Step 8: Find Total Number of Lines

total_lines=$(wc -l < "$file")

This stores the total number of lines in the file.

For example, if the file contains 20 lines:

total_lines = 20

Step 9: Check Starting Line

if [ "$a1" -gt "$total_lines" ]

If the requested starting line is beyond the end of the file, the script displays an error.

For example:

File has 10 lines
a1 = 15

There is no line 15, so the request is invalid.

Step 10: Display the Required Lines

sed -n "${a1},${a2}p" "$file"

Suppose:

a1 = 3
a2 = 7

Then:

sed -n '3,7p' marks.txt

prints lines:

🖥️ Example File

Suppose marks.txt contains:

Line 1 - Linux
Line 2 - UNIX
Line 3 - Shell
Line 4 - Bash
Line 5 - Commands
Line 6 - File Handling
Line 7 - Text Processing
Line 8 - Permissions
Line 9 - Processes
Line 10 - Networking

Run:

./script.sh marks.txt 3 7

Output:

Displaying lines 3 to 7 from marks.txt:
Line 3 - Shell
Line 4 - Bash
Line 5 - Commands
Line 6 - File Handling
Line 7 - Text Processing

❌ Validation Examples

Missing Arguments

./script.sh marks.txt 3

Output:

Usage: ./script.sh <file> <start_line> <end_line>

File Does Not Exist

./script.sh abc.txt 2 5

Output:

Error: File does not exist.

Invalid Starting Line

./script.sh marks.txt abc 5

Output:

Error: Starting line must be a positive integer.

Invalid Ending Line

./script.sh marks.txt 2 xyz

Output:

Error: Ending line must be a positive integer.

Invalid Range

./script.sh marks.txt 8 3

Output:

Error: Starting line must be less than or equal to ending line.

Starting Line Beyond File

If the file contains only 10 lines:

./script.sh marks.txt 15 20

Output:

Error: Starting line is beyond the end of the file.

🔄 Solution 2: Using `awk`

The same task can also be performed using awk.

Shell Script

#!/bin/bash

if [ $# -ne 3 ]
then
    echo "Usage: $0 <file> <start_line> <end_line>"
    exit 1
fi

file=$1
a1=$2
a2=$3

if [ ! -f "$file" ]
then
    echo "Error: File does not exist."
    exit 1
fi

if [ ! -r "$file" ]
then
    echo "Error: File is not readable."
    exit 1
fi

if ! [[ "$a1" =~ ^[1-9][0-9]*$ ]] || ! [[ "$a2" =~ ^[1-9][0-9]*$ ]]
then
    echo "Error: Line numbers must be positive integers."
    exit 1
fi

if [ "$a1" -gt "$a2" ]
then
    echo "Error: Invalid line range."
    exit 1
fi

awk -v start="$a1" -v end="$a2" \
    'NR >= start && NR <= end {print}' "$file"

How `awk` Works

NR represents the current record/line number.

This condition:

NR >= start && NR <= end

means:

Print lines whose line number is between start and end.

For:

start = 3
end = 7

awk prints lines 3 through 7.

🔄 Solution 3: Using `head` and `tail`

The task can also be solved using head and tail.

#!/bin/bash

if [ $# -ne 3 ]
then
    echo "Usage: $0 <file> <start_line> <end_line>"
    exit 1
fi

file=$1
a1=$2
a2=$3

if [ ! -f "$file" ]
then
    echo "Error: File does not exist."
    exit 1
fi

if ! [[ "$a1" =~ ^[1-9][0-9]*$ ]] || ! [[ "$a2" =~ ^[1-9][0-9]*$ ]]
then
    echo "Error: Line numbers must be positive integers."
    exit 1
fi

if [ "$a1" -gt "$a2" ]
then
    echo "Error: Invalid line range."
    exit 1
fi

count=$((a2 - a1 + 1))

head -n "$a2" "$file" | tail -n "$count"

How It Works

Suppose:

a1 = 3
a2 = 7

First:

head -n 7 marks.txt

gets the first 7 lines.

Then:

tail -n 5

gets the last 5 lines of those 7 lines.

Therefore, the result is:

Lines 3, 4, 5, 6, 7

📊 Comparing the Solutions

Method	Main Command	Difficulty	Recommended
Solution 1	`sed`	⭐⭐	✅ Best
Solution 2	`awk`	⭐⭐⭐	✅ Good
Solution 3	`head` + `tail`	⭐⭐	Alternative

Which Solution Should You Use?

For this practical, sed is the cleanest solution because it directly supports displaying a specific range of lines.

If your syllabus focuses on awk, the second solution is useful.

The head + tail approach is good for understanding how multiple Linux commands can be combined using a pipeline.

🧠 Important Concepts Used

Command-Line Arguments

$1
$2
$3
$#

File Tests

-f
-r

Numeric Comparison

-gt

Regular Expression Validation

[[ "$value" =~ regex ]]

Line Processing

sed
awk
head
tail

Command Substitution

total_lines=$(wc -l < "$file")

⚠️ Common Mistakes

Mistake 1: Forgetting Argument Validation

Don't directly use:

file=$1
a1=$2
a2=$3

without checking $#.

Always make sure the required arguments are provided.

Mistake 2: Not Checking the File

Before reading the file, check:

[ -f "$file" ]

and preferably:

[ -r "$file" ]

Mistake 3: Allowing Invalid Line Numbers

Values such as:

abc
-5
2.5

should not be accepted as line numbers.

Mistake 4: Invalid Range

This is invalid:

a1 = 10
a2 = 5

because the starting line comes after the ending line.

Mistake 5: Forgetting Quotes Around File Names

Prefer:

sed -n "${a1},${a2}p" "$file"

instead of:

sed -n "${a1},${a2}p" $file

Quoting helps when the file name contains spaces or special characters.

🎯 Practical Exam Tips

Remember this basic command:

sed -n '3,7p' marks.txt

It displays lines 3 to 7.

For command-line arguments:

$1 → File
$2 → Starting line
$3 → Ending line

For argument count:

$#

For file validation:

[ -f "$file" ]

For readable file:

[ -r "$file" ]

For positive integer validation:

[[ "$num" =~ ^[1-9][0-9]*$ ]]

📚 Related Linux Practical Sets

This solution is part of the VNSGU TYBCA Sem 5 Linux (UNIX) Practical – OCT/Nov 2025 solution series.

Set A – Simple Interest & Compound Interest
Set B – Vowels Count & Case Conversion
Set C – Palindrome String
Set D – File Operations & Text Processing
Set E – Display Lines with Validation
Set F – Count Files & Directories
Set G – Recently Modified Files
Set H – Employee Gross Salary

🐧 Conclusion

Set E is an excellent practical for learning command-line arguments and input validation.

The main logic is:

Validate arguments
      ↓
Validate file
      ↓
Validate line numbers
      ↓
Validate line range
      ↓
Display required lines

Among the different approaches, sed provides the most direct solution for displaying a range of lines.

Practice the validation carefully because the question specifically mentions:

Proper validation required.

💬 What Do You Prefer?

For displaying a range of lines from a file, which approach do you prefer?

sed, awk, or head + tail?

Share your approach in the comments! 🐧💻

📌 Tags

linux shell unix beginners

Linux Practical Set C Solution – Palindrome String

Fahad Vahora — Tue, 11 Aug 2026 04:30:00 +0000

In this article, we will solve VNSGU TYBCA Semester 5 Linux (UNIX) Practical – Set C using shell scripting.

We will learn how to check whether a given string is a palindrome or not using different shell scripting approaches.

📌 Practical Question

Write a script to check whether a given string is palindrome or not.

🧠 What is a Palindrome?

A palindrome is a word or string that reads the same from left to right and right to left.

Examples

madam
level
radar
racecar

For example:

madam → madam

Since the original string and reversed string are the same, madam is a palindrome.

Non-Palindrome Examples

hello
linux
computer

For example:

hello → olleh

Since they are different, hello is not a palindrome.

✅ Solution 1: Using `for` Loop

This solution checks the string character by character and builds its reverse.

Shell Script

#!/bin/bash

echo "Enter a string:"
read str

reverse=""

for ((i=${#str}-1; i>=0; i--))
do
    ch=${str:$i:1}
    reverse="$reverse$ch"
done

echo "Original String : $str"
echo "Reverse String  : $reverse"

if [ "$str" = "$reverse" ]
then
    echo "String is Palindrome"
else
    echo "String is Not Palindrome"
fi

🔍 Explanation

Step 1: Take Input

read str

The user-entered string is stored in the variable str.

Step 2: Initialize Reverse String

reverse=""

We start with an empty string.

Characters will be added to this variable one by one.

Step 3: Find String Length

${#str}

This returns the number of characters in the string.

For example:

madam

has:

5 characters

Therefore, the last character is at index:

because Bash string indexing starts from 0.

Step 4: Loop from Last Character to First

for ((i=${#str}-1; i>=0; i--))

For:

madam

the indexes are:

m → 0
a → 1
d → 2
a → 3
m → 4

The loop starts from 4 and moves toward 0.

So the characters are read as:

m
a
d
a
m

Step 5: Extract One Character

ch=${str:$i:1}

This extracts one character from the string.

The general syntax is:

${string:start:length}

For example:

${str:2:1}

means:

Start at index 2 and extract 1 character.

Step 6: Build the Reverse

reverse="$reverse$ch"

Each extracted character is added to the reverse variable.

For example:

Original: hello

Reverse building:

o
ol
oll
olle
olleh

Step 7: Compare Strings

if [ "$str" = "$reverse" ]

If the original string and reversed string are equal, the string is a palindrome.

🖥️ Example Output

Example 1

Enter a string:
madam

Original String : madam
Reverse String  : madam
String is Palindrome

Example 2

Enter a string:
hello

Original String : hello
Reverse String  : olleh
String is Not Palindrome

✅ Solution 2: Using `rev` Command

Linux provides a command called rev that reverses characters in each line.

This makes the palindrome program much shorter.

Shell Script

#!/bin/bash

echo "Enter a string:"
read str

reverse=$(echo "$str" | rev)

echo "Original String : $str"
echo "Reverse String  : $reverse"

if [ "$str" = "$reverse" ]
then
    echo "String is Palindrome"
else
    echo "String is Not Palindrome"
fi

🔍 Understanding `rev`

Consider:

echo "madam" | rev

Output:

madam

And:

echo "hello" | rev

Output:

olleh

Therefore:

reverse=$(echo "$str" | rev)

stores the reversed string in the reverse variable.

Then we simply compare:

if [ "$str" = "$reverse" ]

🖥️ Example Output

Enter a string:
level

Original String : level
Reverse String  : level
String is Palindrome

✅ Solution 3: Character-by-Character Comparison

Instead of creating a separate reverse string, we can compare characters from both ends.

Shell Script

#!/bin/bash

echo "Enter a string:"
read str

length=${#str}
isPalindrome=1

for ((i=0, j=length-1; i<j; i++, j--))
do
    if [ "${str:$i:1}" != "${str:$j:1}" ]
    then
        isPalindrome=0
        break
    fi
done

if [ $isPalindrome -eq 1 ]
then
    echo "String is Palindrome"
else
    echo "String is Not Palindrome"
fi

🔍 How This Solution Works

Suppose the input is:

madam

The script compares:

m ↔ m
a ↔ a
d ↔ d

All characters match, so the string is a palindrome.

For:

hello

the first comparison is:

h ↔ o

They are different, so the script immediately stops.

break

This avoids unnecessary comparisons.

📊 Comparing the Solutions

Method	Difficulty	Extra Command	Good for Practical
`for` + Reverse	⭐⭐	No	✅ Excellent
`rev`	⭐ Easy	`rev`	✅ Excellent
Character Comparison	⭐⭐⭐	No	✅ Good

Which one should you use?

For a practical examination:

Beginner-friendly: Use the rev solution.

To demonstrate shell scripting logic: Use the for loop solution.

For better algorithmic understanding: Use character-by-character comparison.

📝 Quick Revision

Reverse using `rev`

reverse=$(echo "$str" | rev)

String length

${#str}

Extract one character

${str:$i:1}

Compare strings

if [ "$str" = "$reverse" ]

Break the loop

break

⚠️ Important Note About Spaces and Case

The basic solutions above treat the input as a normal string.

For example:

Madam

is not considered the same as:

madam

because uppercase and lowercase characters are different.

Similarly:

nurses run

contains a space, so it is different from:

nursesrun

If the practical specifically requires case-insensitive palindrome checking or ignoring spaces, the script needs a small modification.

🎯 Practical Exam Tips

Remember these important points:

A palindrome is the same when read forward and backward.
Bash string indexes start from 0.
${#str} gives the string length.
${str:$i:1} extracts a character.
rev can reverse a string quickly.
Always quote string variables when comparing them.
break can stop the loop as soon as a mismatch is found.

📚 Related Linux Practical Sets

This solution is part of the VNSGU TYBCA Sem 5 Linux (UNIX) Practical – OCT/Nov 2025 solution series.

Set A – Simple Interest & Compound Interest
Set B – Vowels Count & Case Conversion
Set C – Palindrome String
Set D – File Operations & Text Processing
Set E – Display Lines with Validation
Set F – Count Files & Directories
Set G – Recently Modified Files
Set H – Employee Gross Salary

🐧 Conclusion

The Palindrome String practical is a simple but important shell scripting exercise.

It helps students understand:

Strings
Loops
String indexing
Conditions
Command substitution
Linux commands

Try writing the program yourself using the for loop approach first. After understanding the logic, try the shorter rev version.

Happy Learning & Best of Luck for your Linux Practical! 🐧💻

GSEB Std 11 Computer Chapter 1 MCQ Solutions English Medium 2026 New Textbook

Fahad Vahora — Mon, 10 Aug 2026 05:42:48 +0000

Gujarat Board Std 11 Computer – English Medium
Chapter 1 – Introduction to Database Management System
Textbook Swadhyay – MCQ Solutions

📚 Chapter 1: Introduction to Database Management System

As per the new Gujarat Board syllabus introduced from 2026, Chapter 1 of Std 11 Computer is:

Introduction to Database Management System

In this article, we have covered all 10 textbook MCQs from the Chapter 1 Swadhyay along with their correct answers and short explanations.

These questions are useful for students preparing for their GSEB Std 11 Computer examination and quick revision.

📝 Textbook MCQ Solutions

Question 1: Which of the following is the full form of DBMS?

(a) Data Block Management System
(b) Database Management System ✅
(c) Data Byte Management System
(d) Data Bit Management System

✅ Correct Answer: (b) Database Management System

Explanation:
DBMS stands for Database Management System. It is a software application that acts as a bridge between users and databases and helps users manage database information.

Question 2: Which of the following terms refers to processed data?

(a) Information ✅
(b) Raw
(c) Facts
(d) Field

✅ Correct Answer: (a) Information

Explanation:
Information is processed data. Raw data is transformed through processing to become structured, relevant, and meaningful information.

Question 3: Which of the following is not a data model?

(a) Flat
(b) Relational
(c) Rotational ✅
(d) Both (a) and (b)

✅ Correct Answer: (c) Rotational

Explanation:
DBMS supports different data models such as Hierarchical, Network, Relational, Flat, Semi-structured, Associative, and Context models. Rotational is not a valid data model.

Question 4: Which of the following best describes a StudentName in Database?

(a) Relationship
(b) Attribute ✅
(c) Entity
(d) Data

✅ Correct Answer: (b) Attribute

Explanation:
A Field or Attribute represents a specific piece of data that describes a characteristic of an entity. For example, StudentName is an attribute of the Student entity.

Question 5: Which of the following is not a database?

(a) MySQL
(b) LibreOffice Base
(c) LibreOffice Impress ✅
(d) SQL Server

✅ Correct Answer: (c) LibreOffice Impress

Explanation:
MySQL, LibreOffice Base, and SQL Server are database systems. LibreOffice Impress is presentation software used to create presentations, not a database system.

Question 6: Which of the following is not a general component of the database?

(a) Chart ✅
(b) Table
(c) Queries
(d) Form

✅ Correct Answer: (a) Chart

Explanation:
The four basic database objects or components are Tables, Queries, Forms, and Reports. A Chart is not one of these core database components.

Question 7: Which of the following data types is used to store an image in a Base database?

(a) Text
(b) Binary ✅
(c) Boolean
(d) Byte

✅ Correct Answer: (b) Binary

Explanation:
Binary data types, such as LONGVARBINARY, can be used to store digitized images, videos, or sound files in a database.

Question 8: In which of the following forms, can a data not be represented?

(a) Text
(b) Numeric
(c) Alphanumeric
(d) Picture ✅

✅ Correct Answer: (d) Picture

Explanation:
In a database or spreadsheet table, a data value in a cell is generally represented as Text, Numeric, or Alphanumeric data. A Picture is usually treated as a separate object rather than a regular data value stored in a cell.

Question 9: Which of the following is a feature that allows us to enter data in a table in an easy and user friendly manner?

(a) Report
(b) Query
(c) Form ✅
(d) Field

✅ Correct Answer: (c) Form

Explanation:
A Form provides a customized and user-friendly graphical interface (GUI) that makes it easier to add, edit, and delete records in a table.

Question 10: Which of the following cannot be used to store numbers?

(a) TINYINT
(b) DOUBLE
(c) DATE ✅
(d) CHAR

✅ Correct Answer: (c) DATE

Explanation:
The DATE data type is used to store calendar dates, such as YYYY-MM-DD. TINYINT and DOUBLE are numeric data types, while CHAR can store numbers as characters.

🎥 Chapter 1 Video Playlist

Want to learn this chapter through video lessons?

You can also watch the Chapter 1 YouTube Playlist for a better understanding of the concepts.

👉 GSEB Std 11 Computer – Chapter 1 Video Playlist

The video lessons can help students understand the concepts more easily and prepare better for their exams.

📌 Quick Revision – Answer Key

Question	Correct Answer
1	(b) Database Management System
2	(a) Information
3	(c) Rotational
4	(b) Attribute
5	(c) LibreOffice Impress
6	(a) Chart
7	(b) Binary
8	(d) Picture
9	(c) Form
10	(c) DATE

🎯 Conclusion

In this article, we covered all 10 textbook MCQs from GSEB Std 11 Computer – Chapter 1: Introduction to Database Management System, along with their correct answers and short explanations.

These MCQs can be used for quick revision and exam preparation.

If you are preparing for the GSEB Std 11 Computer exam, you can also check the upcoming articles for important questions, extra MCQs, practice questions, and quizzes.

💬 Your Feedback Matters!

If you find any mistake, missing information, or something that can be improved in this article, please let us know in the comments.

You can share:

❓ If any answer seems incorrect.
💡 If any topic needs a simpler explanation.
📚 Which Chapter or topic you want next.
📝 Whether you want more MCQs, Practice Questions, or Quizzes.
👨‍🏫 Students, Teachers, and Parents — everyone is welcome to share their feedback.

Your one comment can help us create better and more useful educational content. ❤️

👇 Share your feedback in the comments!

🏷️ Tags

#gujaratboard #computer #dbms #students

GSEB Std 11 Computer Chapter 1 MCQ Solutions Gujarati medium 2026 New Textbook

Fahad Vahora — Mon, 10 Aug 2026 05:06:29 +0000

Gujarat Board Std 11 Computer – Gujarati Medium
પ્રકરણ ૧ – ડેટાબેઝ મેનેજમેન્ટ સિસ્ટમનો પરિચય
Textbook Swadhyay – MCQ Solutions

📚 પ્રકરણ ૧: ડેટાબેઝ મેનેજમેન્ટ સિસ્ટમનો પરિચય

ગુજરાત બોર્ડના 2026થી લાગુ થયેલા નવા અભ્યાસક્રમ મુજબ ધોરણ 11 કોમ્પ્યુટર વિષયના પ્રકરણ 1નું નામ "ડેટાબેઝ મેનેજમેન્ટ સિસ્ટમનો પરિચય" છે.

આ લેખમાં આ પ્રકરણના પાઠ્યપુસ્તકના સ્વાધ્યાયમાં આપેલા તમામ 10 બહુવિકલ્પી પ્રશ્નો (MCQs) ના સાચા જવાબો અને ટૂંકી સમજૂતી આપવામાં આવી છે.

આ MCQs વિદ્યાર્થીઓને પરીક્ષા પહેલાં Quick Revision કરવામાં મદદરૂપ થશે.

📝 Textbook MCQ Solutions

પ્રશ્ન 1: નીચેનામાંથી કયું DBMS નું પૂરું નામ છે?

(a) ડેટા બ્લોક મેનેજમેન્ટ સિસ્ટમ (Data Block Management System)
(b) ડેટાબેઝ મેનેજમેન્ટ સિસ્ટમ (Database Management System) ✅
(c) ડેટા બાઇટ મેનેજમેન્ટ સિસ્ટમ (Data Byte Management System)
(d) ડેટા બિટ મેનેજમેન્ટ સિસ્ટમ (Data Bit Management System)

✅ સાચો જવાબ: (b) ડેટાબેઝ મેનેજમેન્ટ સિસ્ટમ

સમજૂતી:
DBMS નું પૂરું નામ Database Management System છે. DBMS નો ઉપયોગ ડેટાબેઝમાં રહેલા ડેટાને સ્ટોર, મેનેજ અને નિયંત્રિત કરવા માટે થાય છે.

પ્રશ્ન 2: નીચેનામાંથી કયો શબ્દ પ્રોસેસ કરેલા ડેટાનો ઉલ્લેખ કરે છે?

(a) ઇન્ફોર્મેશન (Information) ✅
(b) રો (Raw)
(c) ફેક્ટ્સ (Facts)
(d) ફીલ્ડ (Field)

✅ સાચો જવાબ: (a) ઇન્ફોર્મેશન

સમજૂતી:
કાચા ડેટા (Raw Data) પર પ્રક્રિયા કરવામાં આવે ત્યારે તે અર્થપૂર્ણ અને ઉપયોગી Information (માહિતી) બને છે.

પ્રશ્ન 3: નીચેનામાંથી કયું ડેટા મોડેલ નથી?

(a) ફ્લેટ (Flat)
(b) રિલેશનલ (Relational)
(c) રોટેશનલ (Rotational) ✅
(d) A અને B બંને

✅ સાચો જવાબ: (c) રોટેશનલ (Rotational)

સમજૂતી:
Flat અને Relational ડેટા મોડેલ છે. પરંતુ Rotational નામનું કોઈ માન્ય ડેટા મોડેલ નથી.

પ્રશ્ન 4: નીચેનામાંથી કયું ડેટાબેઝમાં StudentName નું શ્રેષ્ઠ વર્ણન કરે છે?

(a) રિલેશનશિપ (Relationship)
(b) એટ્રિબ્યુટ (Attribute) ✅
(c) એન્ટિટી (Entity)
(d) ડેટા (Data)

✅ સાચો જવાબ: (b) એટ્રિબ્યુટ

સમજૂતી:
StudentName એ Student entity ની એક વિશેષતા છે. તેથી તેને Attribute કહેવામાં આવે છે.

ઉદાહરણ તરીકે Student entity ના Name, RollNo અને Address તેના attributes હોઈ શકે છે.

પ્રશ્ન 5: નીચેનામાંથી કયું ડેટાબેઝ નથી?

(a) MySQL
(b) લિબ્રેઓફિસ બેઝ (LibreOffice Base)
(c) લિબ્રેઓફિસ ઇમ્પ્રેસ (LibreOffice Impress) ✅
(d) SQL સર્વર (SQL Server)

✅ સાચો જવાબ: (c) લિબ્રેઓફિસ ઇમ્પ્રેસ

સમજૂતી:
MySQL, LibreOffice Base અને SQL Server ડેટાબેઝ સાથે સંબંધિત સોફ્ટવેર છે. જ્યારે LibreOffice Impress નો ઉપયોગ Presentation બનાવવા માટે થાય છે.

પ્રશ્ન 6: નીચેનામાંથી કયું ડેટાબેઝનું સામાન્ય ઘટક નથી?

(a) ચાર્ટ (Chart) ✅
(b) ટેબલ (Table)
(c) ક્વેરીઝ (Queries)
(d) ફોર્મ (Form)

✅ સાચો જવાબ: (a) ચાર્ટ

સમજૂતી:
ડેટાબેઝમાં Table, Query, Form અને Report જેવા મુખ્ય ઘટકોનો ઉપયોગ થાય છે. Chart ડેટાબેઝનું સામાન્ય મૂળભૂત ઘટક નથી.

પ્રશ્ન 7: બેઝ ડેટાબેઝમાં ઇમેજ સ્ટોર કરવા માટે નીચેનામાંથી કઈ ડેટા ટાઇપનો ઉપયોગ થાય છે?

(a) ટેક્સ્ટ (Text)
(b) બાઇનરી (Binary) ✅
(c) બૂલીયન (Boolean)
(d) બાઇટ (Byte)

✅ સાચો જવાબ: (b) બાઇનરી

સમજૂતી:
Image જેવી ડિજિટલ ફાઇલોને ડેટાબેઝમાં સંગ્રહ કરવા માટે Binary data નો ઉપયોગ કરી શકાય છે. આવી માહિતી Binary formatમાં સ્ટોર કરવામાં આવે છે.

પ્રશ્ન 8: નીચેનામાંથી કયા સ્વરૂપમાં ડેટા વેલ્યૂ રજૂ કરી શકાતી નથી?

(a) ટેક્સ્ટ (Text)
(b) ન્યુમેરિક (Numeric)
(c) આલ્ફાન્યુમેરિક (Alphanumeric)
(d) પિક્ચર (Picture) ✅

✅ સાચો જવાબ: (d) પિક્ચર

સમજૂતી:
ડેટા વેલ્યૂ સામાન્ય રીતે Text, Numeric અથવા Alphanumeric સ્વરૂપમાં રજૂ કરી શકાય છે. Picture ને સામાન્ય ડેટા વેલ્યૂ તરીકે સીધી રીતે રજૂ કરવાને બદલે તેને યોગ્ય Binary formatમાં સ્ટોર કરવામાં આવે છે.

પ્રશ્ન 9: નીચેનામાંથી કયું આપણને સરળ અને યુઝર ફ્રેન્ડલી રીતે ટેબલમાં ડેટા એન્ટર કરવાની મંજૂરી આપે છે?

(a) રિપોર્ટ (Report)
(b) ક્વેરી (Query)
(c) ફોર્મ (Form) ✅
(d) ફીલ્ડ (Field)

✅ સાચો જવાબ: (c) ફોર્મ

સમજૂતી:
Form એ યુઝર માટે સરળ interface આપે છે, જેના દ્વારા ટેબલમાં ડેટા સરળતાથી Enter, View અથવા Edit કરી શકાય છે.

પ્રશ્ન 10: નીચેનામાંથી કોનો ઉપયોગ સંખ્યાઓ સ્ટોર કરવા માટે કરી શકાતો નથી?

(a) TINYINT
(b) DOUBLE
(c) DATE ✅
(d) CHAR

✅ સાચો જવાબ: (c) DATE

સમજૂતી:
TINYINT અને DOUBLE સંખ્યાત્મક (Numeric) ડેટા સ્ટોર કરવા માટે વપરાય છે. CHAR માં સંખ્યાઓને character તરીકે સ્ટોર કરી શકાય છે. જ્યારે DATE ડેટા ટાઇપનો ઉપયોગ તારીખ સ્ટોર કરવા માટે થાય છે.

🎥 Chapter 1 Video Playlist

જો તમે આ પ્રકરણને વિડિયો દ્વારા શીખવા અને સમજવા માંગતા હો, તો નીચેની YouTube Playlist પણ જોઈ શકો છો.

👉 GSEB Std 11 Computer – Chapter 1 Video Playlist

YouTube Playlist – Chapter 1

આ Playlist દ્વારા વિદ્યાર્થીઓ પ્રકરણના topics ને વધુ સરળતાથી સમજી શકે છે અને MCQsની તૈયારી પણ કરી શકે છે.

📌 Quick Revision – Answer Key

પ્રશ્ન	સાચો જવાબ
1	(b) Database Management System
2	(a) Information
3	(c) Rotational
4	(b) Attribute
5	(c) LibreOffice Impress
6	(a) Chart
7	(b) Binary
8	(d) Picture
9	(c) Form
10	(c) DATE

🎯 Conclusion

આ લેખમાં ધોરણ 11 કોમ્પ્યુટર – પ્રકરણ 1: ડેટાબેઝ મેનેજમેન્ટ સિસ્ટમનો પરિચય ના પાઠ્યપુસ્તકના સ્વાધ્યાયમાં આપેલા તમામ 10 MCQs ના સાચા જવાબો અને ટૂંકી સમજૂતી આપવામાં આવી છે.

વિદ્યાર્થીઓ આ પ્રશ્નોનો ઉપયોગ પરીક્ષા પહેલાં Quick Revision માટે કરી શકે છે.

જો તમને આ પ્રકરણના Important Extra MCQs, Practice Questions અથવા Quiz જોઈએ, તો તે પણ આગળના લેખમાં મેળવી શકશો.

📚 Related Topics

GSEB Std 11 Computer Chapter 1 Notes
DBMS Basics for Beginners
GSEB Std 11 Computer Important Questions
GSEB Std 11 Computer MCQ Practice

Note: આ લેખ Gujarat Board Std 11 Computer Gujarati Medium ના 2026થી લાગુ થયેલા નવા અભ્યાસક્રમને ધ્યાનમાં રાખીને તૈયાર કરવામાં આવ્યો છે.

💬 તમારો Feedback અમારે માટે મહત્વનો છે!

આ લેખમાં કોઈ ભૂલ, માહિતીની ખામી અથવા સુધારાની જરૂરિયાત જણાય તો અમને જરૂર જણાવો.

તમારા Comment દ્વારા તમે નીચેની બાબતો શેર કરી શકો છો:

❓ કોઈ પ્રશ્નનો જવાબ ખોટો લાગતો હોય તો જણાવો.
💡 કોઈ Topic વધુ સરળ રીતે સમજાવવો જોઈએ એવું લાગે તો જણાવો.
📚 કોઈ નવા Chapter અથવા Topic માટે Article જોઈએ તો જણાવો.
📝 વધુ MCQs, Practice Questions અથવા Quiz જોઈએ તો જણાવો.
👨‍🏫 Teachers, Students અને Parents — દરેકનો Feedback અમારે માટે મહત્વનો છે.

તમારો એક Comment અમને વધુ સારા અને ઉપયોગી Educational Articles બનાવવામાં મદદ કરી શકે છે. ❤️

👇 તમારો Feedback Comment માં જરૂર જણાવો!

🏷️ Tags

#gujaratboard #computer #dbms #students

Linux Practical Set B Solution – Vowels Count & Case Conversion

Fahad Vahora — Mon, 10 Aug 2026 04:30:00 +0000

In this article, we will solve VNSGU TYBCA Semester 5 Linux (UNIX) Practical – Set B using shell scripting.

We will learn how to:

Count the number of vowels in a string
Convert a string into uppercase
Convert a string into lowercase
Perform the same task using different Linux/UNIX approaches

📌 Practical Question

Write a script to count the number of vowels in the entered string and convert the string into upper case or lower case.

🧠 Concepts Used

This practical covers:

read
Variables
String length
for loop
if condition
case
tr
Bash parameter expansion
String manipulation

✅ Solution 1: Using `for` Loop

This is one of the best approaches for understanding the logic behind vowel counting.

Shell Script

#!/bin/bash

echo "Enter a string:"
read str

count=0

for ((i=0; i<${#str}; i++))
do
    ch=${str:$i:1}

    case "$ch" in
        a|e|i|o|u|A|E|I|O|U)
            count=$((count + 1))
            ;;
    esac
done

echo "Number of vowels: $count"

echo "Uppercase: ${str^^}"
echo "Lowercase: ${str,,}"

Example Output

Enter a string:
Hello Linux

Number of vowels: 4
Uppercase: HELLO LINUX
Lowercase: hello linux

🔍 Understanding the Script

Step 1: Take String Input

read str

The entered string is stored in the variable str.

Step 2: Initialize Counter

count=0

Initially, the number of vowels is zero.

Whenever a vowel is found, we increase the counter:

count=$((count + 1))

Step 3: Find String Length

${#str}

This gives the number of characters in the string.

For example:

Hello

has a length of:

Step 4: Get One Character

ch=${str:$i:1}

This extracts one character from the string.

For example, if:

str = Hello

then the loop extracts:

H
e
l
l
o

one by one.

Step 5: Check for Vowels

case "$ch" in
    a|e|i|o|u|A|E|I|O|U)
        count=$((count + 1))
        ;;
esac

If the character is one of:

a e i o u
A E I O U

the counter is increased.

Step 6: Convert to Uppercase

${str^^}

This converts the string into uppercase.

Example:

hello linux

becomes:

HELLO LINUX

Step 7: Convert to Lowercase

${str,,}

This converts the string into lowercase.

Example:

HELLO LINUX

becomes:

hello linux

Note: ${str^^} and ${str,,} are Bash parameter-expansion features and are not available in very old shells.

✅ Solution 2: Using `tr`

Linux provides the tr command for character translation.

We can use it to convert the string into uppercase/lowercase and also count vowels.

Shell Script

#!/bin/bash

echo "Enter a string:"
read str

lower=$(echo "$str" | tr '[:upper:]' '[:lower:]')

count=$(echo "$lower" | tr -cd 'aeiou' | wc -c)

upper=$(echo "$str" | tr '[:lower:]' '[:upper:]')

echo "Number of vowels: $count"
echo "Uppercase: $upper"
echo "Lowercase: $lower"

Example Output

Enter a string:
Hello Linux

Number of vowels: 4
Uppercase: HELLO LINUX
Lowercase: hello linux

🔍 How `tr` Works

Convert to Lowercase

tr '[:upper:]' '[:lower:]'

Converts uppercase letters into lowercase.

Convert to Uppercase

tr '[:lower:]' '[:upper:]'

Converts lowercase letters into uppercase.

Remove Everything Except Vowels

tr -cd 'aeiou'

Here:

-c → complement
-d → delete

So characters other than a, e, i, o, u are removed.

For:

Hello Linux

the result becomes approximately:

eoiu

Then:

wc -c

counts the remaining characters.

Therefore:

count=$(echo "$lower" | tr -cd 'aeiou' | wc -c)

gives the total number of vowels.

✅ Solution 3: Using `grep`

Another approach is to use grep to identify vowels.

Shell Script

#!/bin/bash

echo "Enter a string:"
read str

count=$(echo "$str" | grep -o -i '[aeiou]' | wc -l)

upper=$(echo "$str" | tr '[:lower:]' '[:upper:]')
lower=$(echo "$str" | tr '[:upper:]' '[:lower:]')

echo "Number of vowels: $count"
echo "Uppercase: $upper"
echo "Lowercase: $lower"

Example Output

Enter a string:
Welcome to Linux

Number of vowels: 6
Uppercase: WELCOME TO LINUX
Lowercase: welcome to linux

📊 Comparing the Solutions

Method	Vowel Counting	Case Conversion	Difficulty
`for` + `case`	✅	Bash	⭐ Easy
`tr` + `wc`	✅	`tr`	⭐⭐
`grep` + `wc`	✅	`tr`	⭐⭐

Which solution should you use?

For a practical examination, I recommend the for loop + case solution if you want to demonstrate your shell scripting logic.

If the examiner expects Linux command usage, the tr solution is a very good option.

📝 Quick Revision

Count vowels using loop

case "$ch" in
    a|e|i|o|u|A|E|I|O|U)
        count=$((count + 1))
        ;;
esac

Uppercase

${str^^}

Lowercase

${str,,}

Uppercase using `tr`

echo "$str" | tr '[:lower:]' '[:upper:]'

Lowercase using `tr`

echo "$str" | tr '[:upper:]' '[:lower:]'

Count vowels using `tr`

echo "$str" | tr -cd 'aeiou' | wc -c

🎯 Practical Exam Tips

While writing this program in the practical exam, remember:

Initialize the vowel counter with 0.
Check both uppercase and lowercase vowels.
Use quotes around string variables when passing them to commands.
Understand how ${#str} gives the string length.
Remember that ${str^^} and ${str,,} are Bash-specific features.
If you want a more portable command-based approach, use tr.

📚 Related Linux Practical Sets

This solution is part of the VNSGU TYBCA Sem 5 Linux (UNIX) Practical – OCT/Nov 2025 solution series.

Set A – Simple Interest & Compound Interest
Set B – Vowels Count & Case Conversion
Set C – Palindrome String
Set D – File Operations & Text Processing
Set E – Display Lines with Validation
Set F – Count Files & Directories
Set G – Recently Modified Files
Set H – Employee Gross Salary

🐧 Conclusion

The Vowels Count and Case Conversion practical is a useful shell scripting exercise for understanding strings, loops, conditions, Linux commands, and Bash parameter expansion.

Try writing each solution yourself instead of simply copying the code. Understanding the logic will make it much easier to solve similar questions during the practical examination.

Happy Learning & Best of Luck for your Linux Practical! 🐧💻

Linux Practical Set A Solution – Simple Interest & Compound Interest

Fahad Vahora — Sun, 09 Aug 2026 05:55:13 +0000

In this article, we will solve VNSGU TYBCA Semester 5 Linux (UNIX) Practical – Set A using shell scripting.

We will calculate:

Simple Interest (SI)
Compound Interest (CI)
Total Amount

We will also see different approaches, including solutions with bc and without bc.

📌 Practical Question

Write a shell script to calculate the Simple Interest and Compound Interest for given amount.

📐 Formulas

Simple Interest

SI = (P × R × T) / 100

Where:

P = Principal Amount
R = Rate of Interest
T = Time

Simple Interest Amount

Amount = P + SI

Compound Interest

For annual compounding:

CI = P × (1 + R/100)^T - P

Compound Amount

CA = P × (1 + R/100)^T

✅ Solution 1: Using `bc`

bc is a command-line calculator available on Linux/UNIX systems.

It is useful when we need decimal calculations in shell scripts.

Shell Script

#!/bin/bash

echo "Enter Principal Amount:"
read P

echo "Enter Rate of Interest (%):"
read R

echo "Enter Time (in years):"
read T

SI=$(echo "scale=2; ($P * $R * $T) / 100" | bc)

CA=$(echo "scale=2; $P * (1 + $R / 100)^$T" | bc)

CI=$(echo "scale=2; $CA - $P" | bc)

echo "-----------------------------"
echo "Principal Amount : $P"
echo "Rate of Interest : $R%"
echo "Time             : $T years"
echo "Simple Interest  : $SI"
echo "Compound Interest: $CI"
echo "Compound Amount  : $CA"
echo "-----------------------------"

Example Output

Enter Principal Amount:
10000

Enter Rate of Interest (%):
10

Enter Time (in years):
2

-----------------------------
Principal Amount : 10000
Rate of Interest : 10%
Time             : 2 years
Simple Interest  : 2000.00
Compound Interest: 2100.00
Compound Amount  : 12100.00
-----------------------------

How it works

SI=$(echo "scale=2; ($P * $R * $T) / 100" | bc)

Here, bc performs the decimal calculation.

scale=2

means that the result can contain 2 digits after the decimal point.

For compound interest:

CA=$(echo "scale=2; $P * (1 + $R / 100)^$T" | bc)

The ^ operator is used for exponentiation.

✅ Solution 2: Without `bc`

Bash's normal arithmetic expansion:

$(( ... ))

works with integers, not floating-point numbers.

Therefore, if the practical only requires integer input and integer output, we can calculate SI and CI using Bash arithmetic.

Shell Script

#!/bin/bash

echo "Enter Principal Amount:"
read P

echo "Enter Rate of Interest (%):"
read R

echo "Enter Time (in years):"
read T

SI=$((P * R * T / 100))

AMOUNT=$P
for ((i=1; i<=T; i++))
do
    AMOUNT=$((AMOUNT * (100 + R) / 100))
done

CI=$((AMOUNT - P))

echo "-----------------------------"
echo "Principal Amount : $P"
echo "Rate of Interest : $R%"
echo "Time             : $T years"
echo "Simple Interest  : $SI"
echo "Compound Interest: $CI"
echo "Compound Amount  : $AMOUNT"
echo "-----------------------------"

Example

For:

P = 10000
R = 10
T = 2

Output:

Simple Interest  : 2000
Compound Interest: 2100
Compound Amount  : 12100

Important Note

This method uses Bash integer arithmetic.

For example:

$((10 / 3))

produces:

not:

3.3333

So this method is suitable when decimal precision is not required.

✅ Solution 3: Using `awk`

If you don't want to use bc but still want decimal calculations, awk is a very good alternative.

Shell Script

#!/bin/bash

echo "Enter Principal Amount:"
read P

echo "Enter Rate of Interest (%):"
read R

echo "Enter Time (in years):"
read T

awk -v P="$P" -v R="$R" -v T="$T" '
BEGIN {
    SI = (P * R * T) / 100
    CA = P * (1 + R / 100)^T
    CI = CA - P

    printf "-----------------------------\n"
    printf "Principal Amount : %.2f\n", P
    printf "Rate of Interest : %.2f%%\n", R
    printf "Time             : %d years\n", T
    printf "Simple Interest  : %.2f\n", SI
    printf "Compound Interest: %.2f\n", CI
    printf "Compound Amount  : %.2f\n", CA
    printf "-----------------------------\n"
}'

Example Output

Enter Principal Amount:
10000

Enter Rate of Interest (%):
10

Enter Time (in years):
2

-----------------------------
Principal Amount : 10000.00
Rate of Interest : 10.00%
Time             : 2 years
Simple Interest  : 2000.00
Compound Interest: 2100.00
Compound Amount  : 12100.00
-----------------------------

🔍 Difference Between the Solutions

Method	Decimal Support	Easy to Understand	External Command
`bc`	✅ Yes	⭐⭐⭐	`bc`
Bash arithmetic	❌ Integer only	⭐⭐⭐⭐	No
`awk`	✅ Yes	⭐⭐	`awk`

Which one should you use?

For a Linux practical examination:

If bc is allowed: use the bc solution.

If bc is not allowed: use the Bash arithmetic solution when integer output is acceptable.

If decimal output is required but bc is not allowed: use awk.

🧠 Important Shell Concepts Used

This practical helps you practice several important shell scripting concepts:

1. Taking Input

read P

2. Arithmetic Expansion

$(( ... ))

3. Command Substitution

SI=$(...)

4. `bc`

Used for floating-point calculations.

5. `awk`

Can perform floating-point calculations and formatted output.

6. `for` Loop

Used in the pure Bash compound-interest solution.

🎯 Practical Exam Tip

Don't just memorize the script.
Understand these three things:

1. How to take input
2. How to apply the SI and CI formulas
3. How to display the result

Once you understand these, you can easily modify the program if the examiner changes the question slightly.

📚 Related Article

This solution is part of the VNSGU TYBCA Sem 5 Linux (UNIX) Practical – OCT/Nov 2025 series.

You can also practice the other practical sets:

Set A – Simple Interest & Compound Interest
Set B – Vowels & Case Conversion
Set C – Palindrome
Set D – File Operations
Set E – Display Lines with Validation
Set F – Files & Directories
Set G – Recently Modified Files
Set H – Employee Gross Salary

⚠️ Note

The Compound Interest calculation in this article assumes annual compounding.

The Bash-only solution uses integer arithmetic, so decimal precision may differ from the bc or awk versions.

🐧 Conclusion

The Simple Interest and Compound Interest problem is a good beginner-level shell scripting practical because it combines user input, arithmetic operations, variables, loops, and command-line utilities.

Practice all three approaches so that you are comfortable solving the question even when the examination environment has different restrictions.

Happy Learning & Best of Luck for your Linux Practical! 🐧💻

VNSGU TYBCA Linux(Unix) Semester 5 OCT/Nov 2025 Practical Question Papers Sets

Fahad Vahora — Sun, 09 Aug 2026 05:46:56 +0000

VNSGU TYBCA Sem 5 Linux (UNIX) Practical Question Paper – OCT/Nov 2025

Are you preparing for the VNSGU TYBCA Semester 5 Linux (UNIX) Practical Examination?

This article contains the Linux (UNIX) Shell Scripting Practical Question Paper Sets A to H for the OCT/Nov 2025 examination.

These practical sets cover important topics such as shell scripting, string handling, file handling, command-line arguments, file searching, validation, and arithmetic operations.

📚 VNSGU TYBCA Sem 5 – Linux (UNIX)

Details	Information
University	Veer Narmad South Gujarat University (VNSGU)
Course	TYBCA
Semester	Semester 5
Subject	Linux (UNIX)
Exam	OCT/Nov 2025
Type	Practical Examination
Sets	A to H

🐧 Linux (UNIX) Practical Question Sets

📌 Set A – Simple Interest & Compound Interest

Write a shell script to calculate the Simple Interest and Compound Interest for given amount.

📌 Set B – Vowels Count & Case Conversion

Write a script to count the number of vowels in the entered string and convert the string into upper case or lower case.

📌 Set C – Palindrome String

Write a script to check whether a given string is palindrome or not.

📌 Set D – File Operations & Text Processing

Write a shell script to perform following:

Create a file named marks.txt and insert 5 lines of text.
Display the first 3 lines of marks.txt.
Display the last 2 lines of marks.txt.
Count the number of words, lines, and characters in marks.txt.
Search for the word Linux in marks.txt.

Commands Covered

cat
head
tail
wc
grep

📌 Set E – Display Specific Lines from File

Write a shell script that will pass file name and two numbers a1 and a2. Display line a1 to a2 from that file.

Proper validation required.

The script should properly validate the input and handle invalid arguments or file names.

Concepts Covered

Command-line arguments
File validation
Line numbers
sed
Input validation

📌 Set F – Count Files and Directories

Write a shell script to find total number of files and total number of directories in current working directory.

Concepts Covered

Directory handling
File testing
Loops
find
Current working directory

📌 Set G – Recently Modified Files

Write a shell script to find all files in the current directory that were modified in the last 7 days and display their names and sizes.

Concepts Covered

File searching
Modification time
find
File size
Shell scripting

📌 Set H – Employee Gross Salary

Write a shell script that computes the gross salary of an employee according to the following:

If Basic Salary is < 50000

HRA = 20% of Basic Salary
DA = 164% of Basic Salary

If Basic Salary is > 50000

HRA = 15% of Basic Salary
DA = 136% of Basic Salary

Input

The basic salary should be entered interactively through the keyboard.

Formula

Gross Salary = Basic Salary + DA + HRA

📖 Topics Covered in These Practical Sets

These eight practical sets cover several important Linux and UNIX shell scripting concepts:

Shell Scripting
Variables
User Input
Arithmetic Operations
if-else
Loops
String Handling
String Case Conversion
Palindrome Checking
File Handling
Command-Line Arguments
File Validation
Text Processing
head
tail
wc
grep
find
File Size
File Modification Time
Input Validation

🎯 Linux Practical Exam Preparation Tips

If you are preparing for the VNSGU TYBCA Linux practical examination, practice each set yourself instead of only memorizing the script.

1. Understand Shell Syntax

Practice basic shell scripting syntax such as:

#!/bin/bash

variables, read, conditions, loops, and command substitution.

2. Practice Linux Commands

Make sure you are comfortable with commands such as:

cat
head
tail
wc
grep
find
cut
tr
sed

3. Practice Validation

For programs involving files or command-line arguments, always check:

Whether the required arguments are provided
Whether the file exists
Whether the file is readable
Whether the entered values are valid

4. Practice Without Copy-Paste

Try writing every program from scratch. This will help you understand the logic and make it easier to solve variations of the same question during the practical exam.

📝 Quick Revision

Set	Practical Topic
A	Simple Interest & Compound Interest
B	Vowels Count & Case Conversion
C	Palindrome String
D	File Operations & Text Processing
E	Display Lines with Validation
F	Count Files & Directories
G	Recently Modified Files
H	Employee Gross Salary

📌 Conclusion

These VNSGU TYBCA Semester 5 Linux (UNIX) Practical Sets A–H cover a useful range of shell scripting problems for practical examination preparation.

Students should practice each program on a Linux/UNIX environment and understand the logic behind every command and statement.

All the best for your Linux (UNIX) Practical Examination! 🐧💻

⚠️ Disclaimer

This article is intended for educational and examination preparation purposes. Students should verify official examination details and question papers with the relevant VNSGU sources.

DEV Community: Fahad Vahora

Linux Practical Set H Solution – Employee Gross Salary

📌 Practical Question

If Basic Salary is less than ₹50,000

If Basic Salary is greater than ₹50,000

Input Requirement

Gross Salary Formula

🧠 Understanding the Problem

⚠️ Important Note About ₹50,000

🧮 Example Calculation

✅ Solution 1: Using Basic Bash if-else

Shell Script

🔍 Step-by-Step Explanation

Step 1: Take Basic Salary

Step 2: Check Salary Below ₹50,000

Step 3: Check Salary Above ₹50,000

Step 4: Calculate Gross Salary

🖥️ Example Output – Basic Salary Less Than ₹50,000

🖥️ Example Output – Basic Salary Greater Than ₹50,000

❌ Example Output – Basic Salary Exactly ₹50,000

⚠️ Limitation of Basic Bash Arithmetic

✅ Solution 2: Using awk

Shell Script

🖥️ Example Output

🔍 Why Use awk?

✅ Solution 3: Using bc

Shell Script

🖥️ Example Output

🔍 Understanding the bc Solution

📊 Comparing the Solutions

Which Solution Should You Use?

🧠 Important Operators Used

Less Than

Greater Than

Equal

⚠️ Common Mistakes

Mistake 1: Using Assignment Instead of Comparison

Mistake 2: Incorrect Percentage Calculation

Mistake 3: Forgetting DA Is More Than 100%

Mistake 4: Forgetting the Gross Salary Formula

Mistake 5: Ignoring the ₹50,000 Case

🎯 Practical Exam Tips

📝 Quick Revision

Salary below ₹50,000

Salary above ₹50,000

Gross Salary

Compare Less Than

Compare Greater Than

📚 Related Linux Practical Sets

🐧 Conclusion

💬 What Do You Prefer?

📌 Tags

Linux Practical Set F Solution – Count Files and Directories

📌 Practical Question

Important

🧠 Concepts Used

✅ Solution 1: Using find

Shell Script

🔍 Step-by-Step Explanation

Step 1: Find Files

Step 2: Count the Files

Step 3: Find Directories

🖥️ Example

✅ Solution 2: Using Shell Loop and File Tests

Shell Script

🔍 How This Solution Works

Step 1: Initialize Counters

Step 2: Loop Through Items

Step 3: Check for File

Step 4: Check for Directory

🖥️ Example

✅ Solution 3: Using find with -mindepth

Shell Script

🔍 Understanding -mindepth

📊 Comparing the Solutions

Which Solution Should You Use?

🧠 Important Difference: -maxdepth 1

⚠️ Common Mistakes

Mistake 1: Counting Recursively

Mistake 2: Counting . as a Directory

✅ Solution 1: Using Basic Bash `if-else`

✅ Solution 2: Using `awk`

🔍 Why Use `awk`?

✅ Solution 3: Using `bc`

🔍 Understanding the `bc` Solution

✅ Solution 1: Using `find`

✅ Solution 3: Using `find` with `-mindepth`

🔍 Understanding `-mindepth`

🧠 Important Difference: `-maxdepth 1`

Mistake 2: Counting `.` as a Directory

⏱️ Understanding `-mtime`

⚠️ Important: `-mtime` Uses 24-Hour Periods

✅ Solution 1: Using `find` and `ls`

✅ Solution 3: Using `find` and `stat`

Understanding `stat`

✅ Solution 4: Using `find`, `sort` and `awk`

Understanding the `find` Output

Displaying the Result with `awk`

🧠 Important Difference: `-mtime` vs `-mmin`

Using `-mtime`

Using `-mmin`

Mistake 1: Forgetting `-type f`

Mistake 3: Using `-mtime 7`

Mistake 4: Confusing `sort -n` and `sort -nr`

Mistake 5: Parsing `ls` Carelessly

✅ Solution 1: Using `read`, `head`, `tail`, `wc` and `grep`