├── README.md
├── Shell Programming Code
    ├── Current Date And Time.sh
    ├── Check if a File exist.sh
    ├── string is a Palindrome.sh
    ├── Fibonacci .sh
    ├── factorial using Function.sh
    ├── factorial.sh
    ├── Count Occurrence in a File word.sh
    ├── Find the Largest and Smallest Number in Array.sh
    ├── Menu Driver Calculator.sh
    ├── FCFS Without Arrival Time.sh
    ├── SJF Without Arrival Time.sh
    ├── FCFS With Arrival Time.sh
    └── Priority Without Arrival Time.sh
├── Console Name.sh
├── Sumation.sh
├── factorial.sh
├── Pyramidh Pattern.sh
├── prime number.sh
├── shellcode.sh
├── Task Manager.sh
└── Simple File Backup.sh


/README.md:
--------------------------------------------------------------------------------
1 | # Basic-Sheel-Programming  
2 | Operating System (Ubuntu)
3 | 


--------------------------------------------------------------------------------
/Shell Programming Code/Current Date And Time.sh:
--------------------------------------------------------------------------------
1 | echo "Current date and time: $(date)"
2 | 


--------------------------------------------------------------------------------
/Console Name.sh:
--------------------------------------------------------------------------------
 1 | #PrintBranner
 2 | figlet -f slant -c "SAJJAD JIM" | lolcat 
 3 | figlet -f digital -c "S.M. SAJJAD HOSSAIN JIM" | lolcat
 4 | 
 5 | 
 6 | # nano ~/.bashrc
 7 | 
 8 | 
 9 | 
10 | 


--------------------------------------------------------------------------------
/Shell Programming Code/Check if a File exist.sh:
--------------------------------------------------------------------------------
 1 | echo "Enter the file name:"
 2 | read filename
 3 | 
 4 | if [ -e "$filename" ]
 5 | then
 6 |   echo "File exists"
 7 | else
 8 |   echo "File does not exist"
 9 | fi
10 | 


--------------------------------------------------------------------------------
/Shell Programming Code/string is a Palindrome.sh:
--------------------------------------------------------------------------------
 1 | echo "Enter a string:"
 2 | read str
 3 | 
 4 | rev=$(echo $str | rev)
 5 | 
 6 | if [ "$str" == "$rev" ]
 7 | then
 8 |   echo "$str is a palindrome"
 9 | else
10 |   echo "$str is not a palindrome"
11 | fi
12 | 


--------------------------------------------------------------------------------
/Shell Programming Code/Fibonacci .sh:
--------------------------------------------------------------------------------
 1 | echo "Enter the number of terms:"
 2 | read n
 3 | 
 4 | a=0
 5 | b=1
 6 | 
 7 | echo "Fibonacci sequence:"
 8 | for ((i=0; i<n; i++))
 9 | do
10 |   echo -n "$a "
11 |   temp=$((a + b))
12 |   a=$b
13 |   b=$temp
14 | done
15 | echo
16 | 


--------------------------------------------------------------------------------
/Sumation.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # Main script to calculate the summation of numbers from 1 to N
 4 | read -p "Enter a number N: " N
 5 | sum=0
 6 | 
 7 | for ((i = 1; i <= N; i++)); do
 8 |     sum=$((sum + i))
 9 | done
10 | 
11 | echo "The summation of numbers from 1 to $N is: $sum"
12 | 


--------------------------------------------------------------------------------
/Shell Programming Code/factorial using Function.sh:
--------------------------------------------------------------------------------
 1 | factorial() {
 2 |   if (( $1 == 0 || $1 == 1 ))
 3 |   then
 4 |     echo 1
 5 |   else
 6 |     echo $(( $1 * $(factorial $(( $1 - 1 ))) ))
 7 |   fi
 8 | }
 9 | 
10 | echo "Enter a number:"
11 | read num
12 | result=$(factorial $num)
13 | echo "Factorial of $num is $result"
14 | 


--------------------------------------------------------------------------------
/Shell Programming Code/factorial.sh:
--------------------------------------------------------------------------------
 1 | # Factorial Code in Shell Programming (Simple Version)
 2 | 
 3 | echo "Enter a number:"
 4 | read num
 5 | 
 6 | factorial=1
 7 | 
 8 | # Calculate factorial using a loop
 9 | for ((i=1; i<=num; i++))
10 | do
11 |   factorial=$((factorial * i))
12 | done
13 | 
14 | echo "Factorial of $num is $factorial"
15 | 


--------------------------------------------------------------------------------
/Shell Programming Code/Count Occurrence in a File word.sh:
--------------------------------------------------------------------------------
 1 | echo "Enter the file name:"
 2 | read filename
 3 | 
 4 | if [ -e "$filename" ]
 5 | then
 6 |   echo "Enter the word to count:"
 7 |   read word
 8 |   count=$(grep -o -i "\\b$word\\b" "$filename" | wc -l)
 9 |   echo "The word '$word' occurs $count times in the file."
10 | else
11 |   echo "File not found"
12 | fi
13 | 


--------------------------------------------------------------------------------
/factorial.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash   
 2 | 
 3 | # Function to calculate factorial 
 4 | factorial() {
 5 |     local num=$1
 6 |     fact=1
 7 |     for ((i = 2; i <= num; i++)); do
 8 |         fact=$((fact * i))
 9 |     done
10 |     echo $fact 
11 | }
12 | 
13 | # Main script
14 | read -p "Enter a number N: " N
15 | result=$(factorial $N)
16 | echo "The factorial of $N is: $result"
17 | 


--------------------------------------------------------------------------------
/Pyramidh Pattern.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash   
 2 |  
 3 | # Main script to print pyramid pattern
 4 | read -p "Enter the number of rows N: " N
 5 | 
 6 | for ((i = 1; i <= N; i++)); do
 7 |     # Print spaces
 8 |     for ((j = i; j < N; j++)); do
 9 |         echo -n " "
10 |     done
11 |     # Print stars
12 |     for ((k = 1; k <= (2 * i - 1); k++)); do
13 |         echo -n "*"
14 |     done
15 |     echo ""
16 | done
17 | 


--------------------------------------------------------------------------------
/Shell Programming Code/Find the Largest and Smallest Number in Array.sh:
--------------------------------------------------------------------------------
 1 | echo "Enter numbers separated by space:"
 2 | read -a arr
 3 | 
 4 | largest=${arr[0]}
 5 | smallest=${arr[0]}
 6 | 
 7 | for num in "${arr[@]}"
 8 | do
 9 |   if ((num > largest))
10 |   then
11 |     largest=$num
12 |   fi
13 |   if ((num < smallest))
14 |   then
15 |     smallest=$num
16 |   fi
17 | done
18 | 
19 | echo "Largest: $largest"
20 | echo "Smallest: $smallest"
21 | 


--------------------------------------------------------------------------------
/prime number.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # Function to check if a number is prime
 4 | is_prime() {
 5 |     local num=$1
 6 |     if [ "$num" -le 1 ]; then
 7 |         echo 0
 8 |         return
 9 |     fi
10 |     for ((i = 2; i * i <= num; i++)); do
11 |         if [ $((num % i)) -eq 0 ]; then
12 |             echo 0
13 |             return
14 |         fi
15 |     done
16 |     echo 1
17 | }
18 | 
19 | # Main script to sum prime numbers
20 | read -p "Enter a number N: " N
21 | sum=0
22 | 
23 | for ((i = 2; i <= N; i++)); do
24 |     if [ $(is_prime $i) -eq 1 ]; then
25 |         sum=$((sum + i))
26 |     fi
27 | done
28 | 
29 | echo "The sum of prime numbers between 1 and $N is: $sum"
30 | 


--------------------------------------------------------------------------------
/Shell Programming Code/Menu Driver Calculator.sh:
--------------------------------------------------------------------------------
 1 | while true
 2 | do
 3 |   echo -e "\nCalculator Menu"
 4 |   echo "1. Addition"
 5 |   echo "2. Subtraction"
 6 |   echo "3. Multiplication"
 7 |   echo "4. Division"
 8 |   echo "5. Exit"
 9 |   echo "Enter your choice:"
10 |   read choice
11 | 
12 |   if ((choice == 5))
13 |   then
14 |     echo "Exiting..."
15 |     break
16 |   fi
17 | 
18 |   echo "Enter two numbers:"
19 |   read a
20 |   read b
21 | 
22 |   case $choice in
23 |     1) echo "Result: $((a + b))";;
24 |     2) echo "Result: $((a - b))";;
25 |     3) echo "Result: $((a * b))";;
26 |     4) 
27 |       if ((b == 0))
28 |       then
29 |         echo "Division by zero is not allowed"
30 |       else
31 |         echo "Result: $((a / b))"
32 |       fi
33 |       ;;
34 |     *) echo "Invalid choice";;
35 |   esac
36 | done
37 | 


--------------------------------------------------------------------------------
/Shell Programming Code/FCFS Without Arrival Time.sh:
--------------------------------------------------------------------------------
 1 | # 1. FCFS Without Arrival Time
 2 | # First-Come, First-Served (FCFS) scheduling without considering arrival time.
 3 | # Processes are executed in the order provided.
 4 | 
 5 | echo "Enter the number of processes:"
 6 | read n
 7 | 
 8 | echo "Enter burst times (space-separated):"
 9 | read -a burst_time
10 | 
11 | # Initialize waiting time and turnaround time
12 | waiting_time[0]=0
13 | turnaround_time[0]=${burst_time[0]}
14 | 
15 | for ((i=1; i<n; i++))
16 | do
17 |   waiting_time[i]=$((waiting_time[i-1] + burst_time[i-1]))
18 |   turnaround_time[i]=$((waiting_time[i] + burst_time[i]))
19 | done
20 | 
21 | # Display results
22 | echo -e "\nProcess\tBurst Time\tWaiting Time\tTurnaround Time"
23 | for ((i=0; i<n; i++))
24 | do
25 |   echo -e "$((i+1))\t${burst_time[i]}\t\t${waiting_time[i]}\t\t${turnaround_time[i]}"
26 | done
27 | 


--------------------------------------------------------------------------------
/shellcode.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # Display menu
 4 | echo "Welcome to the Shell Script Program!"
 5 | echo "Please select an option:"
 6 | echo "1. Display current date and time"
 7 | echo "2. Display disk space usage"
 8 | echo "3. List files in the current directory"
 9 | echo "4. Exit"
10 | 
11 | # Read user input
12 | read -p "Enter your choice (1-4): " choice
13 | 
14 | # Execute based on choice
15 | case $choice in
16 |     1)
17 |         echo "Current Date and Time:"
18 |         date
19 |         ;;
20 |     2)
21 |         echo "Disk Space Usage:"
22 |         df -h
23 |         ;;
24 |     3)
25 |         echo "Files in the Current Directory:"
26 |         ls
27 |         ;;
28 |     4)
29 |         echo "Exiting the program. Goodbye!"
30 |         exit 0
31 |         ;;
32 |     *)
33 |         echo "Invalid choice, please select a valid option."
34 |         ;;
35 | esac
36 | 


--------------------------------------------------------------------------------
/Shell Programming Code/SJF Without Arrival Time.sh:
--------------------------------------------------------------------------------
 1 | # 3. SJF Without Arrival Time
 2 | # Shortest Job First (SJF) scheduling without considering arrival time.
 3 | 
 4 | echo "Enter the number of processes:"
 5 | read n
 6 | 
 7 | echo "Enter burst times (space-separated):"
 8 | read -a burst_time
 9 | 
10 | # Sort burst times and calculate waiting and turnaround times
11 | sorted_burst_time=($(for bt in "${burst_time[@]}"; do echo $bt; done | sort -n))
12 | 
13 | waiting_time[0]=0
14 | turnaround_time[0]=${sorted_burst_time[0]}
15 | 
16 | for ((i=1; i<n; i++))
17 | do
18 |   waiting_time[i]=$((waiting_time[i-1] + sorted_burst_time[i-1]))
19 |   turnaround_time[i]=$((waiting_time[i] + sorted_burst_time[i]))
20 | done
21 | 
22 | # Display results
23 | echo -e "\nProcess\tBurst Time\tWaiting Time\tTurnaround Time"
24 | for ((i=0; i<n; i++))
25 | do
26 |   echo -e "$((i+1))\t${sorted_burst_time[i]}\t\t${waiting_time[i]}\t\t${turnaround_time[i]}"
27 | done
28 | 


--------------------------------------------------------------------------------
/Shell Programming Code/FCFS With Arrival Time.sh:
--------------------------------------------------------------------------------
 1 | # 2. FCFS With Arrival Time
 2 | # FCFS scheduling with consideration of arrival time.
 3 | 
 4 | echo "Enter the number of processes:"
 5 | read n
 6 | 
 7 | echo "Enter arrival times (space-separated):"
 8 | read -a arrival_time
 9 | 
10 | echo "Enter burst times (space-separated):"
11 | read -a burst_time
12 | 
13 | # Initialize waiting time, turnaround time, and completion time
14 | waiting_time=()
15 | turnaround_time=()
16 | completion_time=()
17 | 
18 | completion_time[0]=$((arrival_time[0] + burst_time[0]))
19 | turnaround_time[0]=$((completion_time[0] - arrival_time[0]))
20 | waiting_time[0]=$((turnaround_time[0] - burst_time[0]))
21 | 
22 | for ((i=1; i<n; i++))
23 | do
24 |   if ((completion_time[i-1] < arrival_time[i]))
25 |   then
26 |     completion_time[i]=$((arrival_time[i] + burst_time[i]))
27 |   else
28 |     completion_time[i]=$((completion_time[i-1] + burst_time[i]))
29 |   fi
30 | 
31 |   turnaround_time[i]=$((completion_time[i] - arrival_time[i]))
32 |   waiting_time[i]=$((turnaround_time[i] - burst_time[i]))
33 | done
34 | 
35 | # Display results
36 | echo -e "\nProcess\tArrival Time\tBurst Time\tWaiting Time\tTurnaround Time"
37 | for ((i=0; i<n; i++))
38 | do
39 |   echo -e "$((i+1))\t${arrival_time[i]}\t\t${burst_time[i]}\t\t${waiting_time[i]}\t\t${turnaround_time[i]}"
40 | done
41 | 


--------------------------------------------------------------------------------
/Shell Programming Code/Priority Without Arrival Time.sh:
--------------------------------------------------------------------------------
 1 | # 4. Priority Without Arrival Time
 2 | # Priority scheduling without considering arrival time.
 3 | 
 4 | echo "Enter the number of processes:"
 5 | read n
 6 | 
 7 | echo "Enter burst times (space-separated):"
 8 | read -a burst_time
 9 | 
10 | echo "Enter priorities (space-separated, lower number = higher priority):"
11 | read -a priority
12 | 
13 | # Sort by priority
14 | for ((i=0; i<n-1; i++))
15 | do
16 |   for ((j=0; j<n-i-1; j++))
17 |   do
18 |     if ((priority[j] > priority[j+1]))
19 |     then
20 |       # Swap priorities
21 |       temp=${priority[j]}
22 |       priority[j]=${priority[j+1]}
23 |       priority[j+1]=$temp
24 | 
25 |       # Swap burst times
26 |       temp=${burst_time[j]}
27 |       burst_time[j]=${burst_time[j+1]}
28 |       burst_time[j+1]=$temp
29 |     fi
30 |   done
31 | done
32 | 
33 | waiting_time[0]=0
34 | turnaround_time[0]=${burst_time[0]}
35 | 
36 | for ((i=1; i<n; i++))
37 | do
38 |   waiting_time[i]=$((waiting_time[i-1] + burst_time[i-1]))
39 |   turnaround_time[i]=$((waiting_time[i] + burst_time[i]))
40 | done
41 | 
42 | # Display results
43 | echo -e "\nProcess\tPriority\tBurst Time\tWaiting Time\tTurnaround Time"
44 | for ((i=0; i<n; i++))
45 | do
46 |   echo -e "$((i+1))\t${priority[i]}\t\t${burst_time[i]}\t\t${waiting_time[i]}\t\t${turnaround_time[i]}"
47 | done
48 | 


--------------------------------------------------------------------------------
/Task Manager.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash  
 2 | 
 3 | # Task Manager Script
 4 | 
 5 | # Array to hold tasks
 6 | declare -a tasks
 7 | task_count=0
 8 | 
 9 | # Function to add a task
10 | add_task() {
11 |     read -p "Enter task description: " task
12 |     tasks+=("$task")
13 |     ((task_count++))
14 |     echo "Task added: $task"
15 | }
16 | 
17 | # Function to list all tasks
18 | list_tasks() {
19 |     if [ $task_count -eq 0 ]; then
20 |         echo "No tasks available."
21 |         return
22 |     fi
23 |     echo "Tasks:"
24 |     for (( i=0; i<task_count; i++ )); do
25 |         echo "$((i + 1)). ${tasks[i]}"
26 |     done
27 | }
28 | 
29 | # Function to remove a task
30 | remove_task() {
31 |     list_tasks
32 |     read -p "Enter task number to remove: " task_num
33 |     if [[ $task_num -gt 0 && $task_num -le $task_count ]]; then
34 |         unset 'tasks[$((task_num - 1))]'
35 |         tasks=("${tasks[@]}") # Re-index the array
36 |         ((task_count--))
37 |         echo "Task $task_num removed."
38 |     else
39 |         echo "Invalid task number."
40 |     fi
41 | }
42 | 
43 | # Function to clear all tasks
44 | clear_tasks() {
45 |     tasks=()
46 |     task_count=0
47 |     echo "All tasks cleared."
48 | }
49 | 
50 | # Main menu function
51 | menu() {
52 |     while true; do
53 |         echo "======================="
54 |         echo "      Task Manager"
55 |         echo "======================="
56 |         echo "1. Add Task"
57 |         echo "2. List Tasks"
58 |         echo "3. Remove Task"
59 |         echo "4. Clear Tasks"
60 |         echo "5. Exit"
61 |         read -p "Choose an option: " option
62 | 
63 |         case $option in
64 |             1) add_task ;;
65 |             2) list_tasks ;;
66 |             3) remove_task ;;
67 |             4) clear_tasks ;;
68 |             5) echo "Exiting..."; exit 0 ;;
69 |             *) echo "Invalid option. Please try again." ;;
70 |         esac
71 |     done
72 | }
73 | 
74 | # Start the script
75 | menu
76 | 


--------------------------------------------------------------------------------
/Simple File Backup.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash 
 2 | 
 3 | # Simple File Backup System
 4 | 
 5 | # Default backup directory
 6 | BACKUP_DIR="$HOME/backups"
 7 | 
 8 | # Create backup directory if it doesn't exist
 9 | mkdir -p "$BACKUP_DIR"
10 | 
11 | # Function to back up a file
12 | backup_file() {
13 |     read -p "Enter the file to back up: " file
14 |     if [[ -f "$file" ]]; then
15 |         cp "$file" "$BACKUP_DIR/$(basename "$file").bak"
16 |         echo "Backup of '$file' created in '$BACKUP_DIR'."
17 |     else
18 |         echo "File '$file' does not exist."
19 |     fi
20 | }
21 | 
22 | # Function to list all backups
23 | list_backups() {
24 |     echo "Existing backups in '$BACKUP_DIR':"
25 |     ls "$BACKUP_DIR"
26 | }
27 | 
28 | # Function to restore a file from backup
29 | restore_file() {
30 |     read -p "Enter the name of the backup file to restore: " backup_file
31 |     if [[ -f "$BACKUP_DIR/$backup_file" ]]; then
32 |         cp "$BACKUP_DIR/$backup_file" .
33 |         echo "Backup '$backup_file' restored to current directory."
34 |     else
35 |         echo "Backup file '$backup_file' does not exist."
36 |     fi
37 | }
38 | 
39 | # Function to clear all backups
40 | clear_backups() {
41 |     rm -f "$BACKUP_DIR"/*
42 |     echo "All backups cleared."
43 | }
44 | 
45 | # Main menu function
46 | menu() {
47 |     while true; do
48 |         echo "======================="
49 |         echo "   File Backup System"
50 |         echo "======================="
51 |         echo "1. Back Up a File"
52 |         echo "2. List Backups"
53 |         echo "3. Restore a File"
54 |         echo "4. Clear All Backups"
55 |         echo "5. Exit"
56 |         read -p "Choose an option: " option
57 | 
58 |         case $option in
59 |             1) backup_file ;;
60 |             2) list_backups ;;
61 |             3) restore_file ;;
62 |             4) clear_backups ;;
63 |             5) echo "Exiting..."; exit 0 ;;
64 |             *) echo "Invalid option. Please try again." ;;
65 |         esac
66 |     done
67 | }
68 | 
69 | # Start the script
70 | menu
71 | 


--------------------------------------------------------------------------------