A bash script is a file having instructions that can also be executed individually on a command line. With scripting, you can automate repetitive tasks. To create a bash script, you can start by creating a file in your favorite editor & saving it with the .sh extension.

Shebang (#!)

The first line in every bash script is the shebang character, which tells the operating system which interpreter to use to parse the rest of the code. The shebang takes the following form,

#!interpreter [arguments]

Where, the interpreter is full path to the binary file & arguments are optional.

Executing the Script

The bash script can be executed in two ways, either by sourcing the file itself or by creating an executable. The way we can do it is as mentioned below,

• By sourcing the file itself

source bash-refresher.sh

• By creating an executable

chmod +x bash-refresher.sh
./bash-refresher.sh

Printing

Bash uses echo to display the argument passed to the command.

#!/usr/bin/env bash

echo "Hello, World!"

Commenting

Commenting plays very important role in programming, so that the developer can understand why a particular block of code was written. In bash, there are multiple ways in which you can comment your code.

Single line comments

Anything followed by the # hash character is skipped, this way you can write single line comment in bash.

# This is one-liner comment

Multi line comments

Multi-line comments in bash can be written using the : bash operator and ' ' pair of single quotes.

: '
This is a way one can write multi line comments in bash.
echo "This will not be echoed!"
'

Variables

You can define variables in bash using the = assignment operator and can use the $ dollar sign to access the variable.

The assignment operator should not have space on either side while defining a variable

#!/usr/bin/env bash

language="bash"
echo "This article is about the $language scripting"

Reading Input

To read input from the user you can use read command. To add a prompt , one can use the -p flag followed by the prompt string, whereas to read the input silently one can use the -s flag. The value entered by the user, is assigned to the variable name following the read command.

#!/usr/bin/env bash

read -p "Enter username:    " username
read -sp "Enter password:     " password

You can access the value entered by the user, using the $ dollar sign followed by the variable name.

Conditional Statements

You can define conditional statements in bash using if-elif-else-fi block. The conditions must be passed in single [ ] or double square[[ ]] brackets. In bash we use the then keyword to execute the block of code, when a certain condition returns True.

Leave a space before and after the end of the condition statement inside the square brackets [[ condition ]]

• Syntax for if-statements

if [[ condition ]]
then
    <statements>
elif [[ condition ]]
then
    <statements>
else
    <statements>
fi

• Example for if-statements

The condition flags are listed at the end of the article, also you can use the logical operators to chain conditions.

#!/usr/bin/env bash

echo -p "Please enter your age: " age

if [[ -z $age || $age -le 0 ]]; 
then
  echo "Please enter valid age! o_O"

elif [[ $age -gt 0 && $age -lt 21 ]]; 
then
  echo "we're young! \o/"

elif [[ $age -eq 21 ]]; 
then
  echo "we're forever 21! :D"

else
  echo "we're just not 21 anymore! :("

fi

Case Statements

Case statements in bash are similar to switch cases in other programming languages. If a particular condition is matched, the statement block for that case is executed. If no case is matched the default statement is executed.

• Syntax for case-statements

case variable in 
    case_condition )
         statements
    ;;
*)
    default_statements
esac

semi-colon ; indicates the end of the command & beginning of a new one. The asterisk * defines the default case

• Example for case-statements

#!/usr/bin/env bash

read -p "Joey doesn't share food! [True|False] ?" input

case $input in
  "True")
  echo "Right! \o/"
  ;;
  "False")
  echo "Oh my God! o_O"
  ;;
  * )
  echo "Invalid Choice!"
esac

Loops

Similar to other languages, bash also supports the while and the for loops. The statements to be executed must be enclosed within the do-done block.

For Loop

• Syntax - for loop

for iterable in iterables
    do
        <statements>
    done

• Example - for loop

In this example, we are iterating over an array of strings, to access the element we use "${array[@]}" as iterables.

#!/usr/bin/env bash

friends=("Joey" "Chandler" "Ross")
for friend in "${friends[@]}"
do
    echo "Hi I'm $friend"
done

While Loop

• Syntax - while loop

while condition
    do
        <statements>
    done

• Example - while loop

In this example, we have a while loop that would be executed until a valid password is entered.

​ The -z flag checks if the value is empty

#!/usr/bin/env bash

while [ -z $INPUT ]
do
  echo -e "Enter new password.Password should not be blank"
  read -s INPUT
done

Functions

Functions are reusable blocks of code. In bash, you can define a function in two ways, by typing function_name() or using the function keyword.

A function can take no arguments or can have multiple arguments passed as command-line arguments. Command line arguments can be accessed using the $ dollar sign and indexes starting at 1, like $1 for the first argument, $2 for the second, and so on.

Unlike other languages, one does not have to call the function in bash using empty parenthesis, simply typing the function_name works.

• Syntax for functions

function function_name() {
    <statements>
}

# calling a function
function_name

• Example of functions

In the example, we have two functions, one that takes no arguments and second one that takes two command line arguments & display it as a conversation.

#!/usr/bin/env bash

function joey_tribbiani(){
  echo "How you doin'?"
}

trained_for_nothing(){
  echo "$1 : You got a job?"
  echo "$2 : Are you kidding? I'm trained for nothing!"
}

joey_tribbiani
trained_for_nothing Ross Rachel

Extras

Bash Expansions

• Command Substitution $(command)

  This allows user to execute a command in subshell & replace the command substitution with the output of the command enclosed. Another way to do this is by enclosing command within back ticks.

  `command`
  

• Arithmetic Expansion $(( expression ))

  This allows user to evaluate the expression and replace it with the result of the expression enclosed.

• Parameter Expansion ${parameter}

  This allows user to access the value of the parameter and replace it.

Built-in Variables

Bash has few builtin variables that are very useful while writing a bash script. The table below shows the variable and its description. Remember that the $ dollar sign is used to access the variable in bash.

The difference between $@ and $* is that, if you pass them inside quotes as a string, * takes all the positional arguments as a single parameter whereas @ will pass each positional argument separately

File Conditions

Below table gives list of few operators that can be used to test a particular property of a file.

Comparison Operators

Below table gives list of few of the comparison operators available in bash.

Exit Commands

There are two commands that work as exit commands with different purposes, the exit and the return command

Conclusion

Having bash knowledge plays a key role if you use Linux in your day-to-day work. I hope this article, helps you refresh your bash skills.

Thanks for reading 🙇🏻‍♂️

References

• Ryan Tutorials

• Bash Reference Manual

In python, there is no switch case, unlike other programming languages. So the question comes how do we write a switch case in python?

Basically, there are two ways in which you can try to implement the switch case logic in python where you intend to execute certain statements when a particular case is matched.

• Using if-elif-else block
• Using python dictionary

In this article, we will check both the ways by writing a function that performs arithmetic operations on the numbers passed to the function. The function would take the two numbers and operation as function arguments and return the result based on the operation passed to the function.

Let's begin

Function to write switch-case using if-elif-else

The if-elif-else is used in python to write conditional statements as in other programming languages. You can write a switch case by checking every operation passed to function and based on the condition you can return the result.

This is how it is done,

def switch_case_function(x, y, op):
    if op == "add":
        return x + y
    elif op == "sub":
        return x - y
    elif op == "div":
        return x/y
    elif op == "mul":
        return x * y
    else:
        return "no valid operation"

switch_case_function(4,5,"add")

Function to write switch-case using python dictionary

Python dictionaries are used to store data in key-value pairs. The key of the dictionary must be an immutable datatype. The dictionary itself is mutable and it does not allow duplicate keys.

You can create a python dictionary in the following ways:

# creating an empty dictionary in python
mapping = {}        
mapping = dict() 

# creating a dictionary with key-value pairs
mapping = {"language" : "python", "creator" : "guido van rossum"}
mapping = dict(language="python", creator="guido van rossum")

The main thing to notice here is while you use dict() and pass the key-value pair, you can directly pass the key as the variable name instead of passing it as strings, as when creating a dictionary using curly braces.

To get a value from the dictionary you can use the built-in get() method on the dictionary object. It returns the value of the key if a key exists else returns the default.

def switch_case_function(x,y,op):
    operation_mapping = dict(add=x+y, sub=x-y, mul=x*y, div=x/y)
    # returns no valid operation if key does not exists.
    return operation_mapping.get(op, "no valid operation") 

switch_case_function(4,5,"add")

Conclusion

Python does not have switch cases unlike other programming languages but you can implement the logic using the two methods shown above. The code is more readable when you write using python dictionaries. You can make your own choice.

Thanks for reading 🙇🏻‍♂️

In this article, we will take a look at recursion in python. The purpose of this article is not about analyzing the complexity or which approach is better (iterative or recursive). As many searches, sort, and traversal programs use recursion as their solution, it becomes important to understand the basics of recursion prior to getting into the DSA.

Recursion as the name says is a way in which a function recursively calls itself directly or indirectly. While you intend to write recursion, you have to be very careful as the function calls can get into infinite loops. However, there is a default upper limit set for the number of recursion calls, beyond which the program runs into stack overflow or runtime error. A recursion algorithm has two cases, the recursive case, and the base case. Recursion is terminated once the base case is recognized. Generally, the base case output is already known so we can directly return the value when this case is encountered.

With recursion, you can break complex problems into similar smaller ones. Also, the code is more readable than the iterative approach. Recursion is slower than iteration as it has to maintain the stack and uses more memory.

The greet() function calls itself recursively, if you call the function and run this code, it will result in an infinite loop that would print "hello" as output as there is no base case in the function to terminate the recursion. However, in python, you can encounter the RecursionError once the upper limit of the recursion call is reached.

You can get or set the recursion limit in python using the sys module, to do so execute the following code in your python terminal,

import sys

# fetch the recursion upper limit
sys.getrecursionlimit()
# ouput: 1000

# if you intend to change the upper limit, you can do so by executing
sys.setrecursionlimit(200)

That's it for the basic understanding of recursion.

Now, let's see an example for finding the factorial of a number using recursion.

Factorial of a number is a product of all positive numbers smaller than or equal to the number. It is represented by using exclamation after the number. Also, remember that the Factorial of 0 is 1 (0!=1).

def factorial(number):
    '''
    The base case here is when the number becomes 0, we already know 0! = 1
    we can directly return 1 once the base case is reached.
    '''
    if number == 0:
        return 1
    return number * factorial(number-1)

factorial(4)

Visualize the factorial recursion code below by clicking the next option

You can observe, the factorial function calls itself with a number decremented by 1, once it reaches the base-case the recursion stops and starts returning the value for each function call until it reaches the actual call factorial(4) and returns the value 24.

I hope this article, helps you understand the basics of recursion. As an exercise, you can try implementing the fibonacci series using python and visualize the code on pythontutor.

Thanks for reading 🙇🏻‍♂️

references

https://www.hackerearth.com/practice/basic-programming/recursion/recursion-and-backtracking/tutorial/ https://everythingcomputerscience.com/discrete_mathematics/Recurssion.html

In this article, we will try to understand what are binary trees, as we go along we will be exploring different tree data structures so we must have a basic understanding of the binary tree.

A binary tree is a tree comprising nodes, with each node having at most two other nodes referred to as the left child and the right child of the node.

Each node contains three components data element, pointer to the left child and pointer to the right child, they are recursively defined. If there is no child the pointer points to null.

A data element can be any type of data, while the left and the right pointer point to binary trees on the left and the right side of the node respectively.

The image below represents a binary tree and the node structure if you extract a node element.

Binary Tree in Python

class BinaryTree:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

root_node = Node(1)

Some important definitions

• The topmost node is called the root node.
• The nodes that are connected downwards and are next to each other are called children.
• The node without any children is called a leaf node.
• Node with at least one child is called an internal node.
• Node without any child is called an external node.
• Nodes with the same parent are called siblings.

Types of Binary Trees

• Full Binary Tree
• Complete Binary Tree
• Perfect Binary Tree
• Degenerate Binary Tree
• Balanced Binary Tree

I hope this article gave you a basic understanding of the binary tree. We will be exploring each type of BT in the later articles.

Thanks for reading 🙇🏻‍♂️

references

https://www.hackerearth.com/practice/data-structures/trees/binary-and-nary-trees/tutorial/