Forem: Sanjay Khati Chhetri

Introduction to Big O Notation

Sanjay Khati Chhetri — Mon, 24 Jul 2023 01:07:51 +0000

Different Types of Algorithms in Data Structure.

What is Algorithm?

An Algorithm is a sequence of steps that describe how a problem can be solved. Every computer program that ends with a result is basically based on an Algorithm. These can also be used to solve mathematical problems and on many matters of day-to-day life. Algorithms are generally created independent of underlying languages, i.e. an algorithm can be implemented in more than one programming language.

The Algorithm are different Categories which are described as below:

Search − Algorithm to search an item in a data structure.
Sort − Algorithm to sort items in a certain order.
Insert − Algorithm to insert item in a data structure.
Update − Algorithm to update an existing item in a data structure.
Delete − Algorithm to delete an existing item from a data structure.

These are the categories by which every problem become easy and can easily solved.

How to Write an Algorithm?

here are no well-defined standards for writing algorithms. Rather, it is problem and resource dependent. Algorithms are never written to support a particular programming code.

As we know that all programming languages share basic code constructs like loops (do, for, while), flow-control (if-else), etc. These common constructs can be used to write an algorithm.

We write algorithms in a step-by-step manner, but it is not always the case. Algorithm writing is a process and is executed after the problem domain is well-defined. That is, we should know the problem domain, for which we are designing a solution.

Example

Let's try to learn algorithm-writing by using an example.

Problem − Design an algorithm to add two numbers and display the result.

**Step 1** − START

**Step 2** − declare three integers **a**, **b** & **c**

**Step 3** − define values of **a** & **b**

**Step 4** − add values of **a** & **b**

**Step 5** − store output of step 4 to **c**

**Step 6** − print **c**

**Step 7** − STOP

Algorithms tell the programmers how to code the program. Alternatively, the algorithm can be written as

**Step 1** − START ADD

**Step 2** − get values of **a** & **b**

**Step 3** − c ← a + b

**Step 4** − display c

**Step 5** − STOP

In design and analysis of algorithms, usually the second method is used to describe an algorithm. It makes it easy for the analyst to analyze the algorithm ignoring all unwanted definitions. He can observe what operations are being used and how the process is flowing.

Advantages and Disadvantages of Algorithms.

Advantages of Algorithm

It is a step wise representation of a solution for a give problem
Algorithm use a definite procedure
It does not depend upon any programming language which make algorithm easily understandable without any programming knowledge.
Every step in algorithm has logical reason so it can be easily debugged.
Algorithm divide the problem into smaller problems due to which every problem can easily solved.

Disadvantages of Algorithm

Algorithm is Time Consuming
Every problem cannot be converted into algorithm which makes it difficult
Difficult to show looping and branching in Algorithm

Types of Algorithms

Based on how they function, we can divide Algorithms into multiple types. Let’s take a look at some of the important ones.

1. Recursive Algorithm

This is one of the most interesting Algorithms as it calls itself with a smaller value as inputs which it gets after solving for the current inputs. In more simpler words, It’s an Algorithm that calls itself repeatedly until the problem is solved.

Example:

To find factorial using recursion, here is the pseudo code:

    Fact(x)
        If x is 0      /\*0 is the base value and x is 0 is base case\*/
            return 1
    return (x\*Fact(x-1))  /\* breaks the problem into small problems\*/

2. Divide and Conquer Algorithm

This is another effective way of solving many problems. In Divide and Conquer algorithms, divide the algorithm into two parts, the first parts divides the problem on hand into smaller subproblems of the same type. Then on the second part, these smaller problems are solved and then added together (combined) to produce the final solution of the problem.

Example:

Merge sort , Quick sort

3. Dynamic Programming Algorithm

These algorithms work by remembering the results of the past run and using them to find new results. In other words, dynamic programming algorithm solves complex problems by breaking it into multiple simple subproblems and then it solves each of them once and then stores them for future use.

Example:

Fibonacci sequence, here is the pseudo code :

Fib(n)
    if n=0
        return 0
    else
        prev\_Fib=0,curr\_Fib=1
    repeat n-1 times  /\*if n=0 it will skip\*/
        next\_Fib=prev\_Fib+curr\_Fib   
        prev\_Fib=curr\_Fib
        curr\_Fib=new\_Fib
    return curr\_Fib

4. Greedy Algorithm

These algorithms are used for solving optimization problems. In this algorithm, we find a locally optimum solution (without any regard for any consequence in future) and hope to find the optimal solution at the global level.

The method does not guarantee that we will be able to find an optimal solution.

The algorithm has 5 components:

The first one is a candidate set from which we try to find a solution.
A selection function which helps choose the best possible candidate.
A feasibility function which helps in deciding if the candidate can be used to find a solution.
An objective function which assigns value to a possible solution or to a partial solution
Solution function that tells when we have found a solution to the problem.

Huffman Coding and Dijkstra’s algorithm are two prime examples where Greedy algorithm is used.

In Huffman coding, The algorithm goes through a message and depending on the frequency of the characters in that message, for each character, it assigns a variable length encoding. To do Huffman coding, we first need to build a Huffman tree from the input characters and then traverse through the tree to assign codes to the characters.

Example:

Huffman tree, Counting money

5. Brute Force Algorithm

This is one of the simplest algorithms in the concept. A brute force algorithm blindly iterates all possible solutions to search one or more than one solution that may solve a function. Think of brute force as using all possible combinations of numbers to open a safe.

Example:

Exact string
Matching algorithm

6. Backtracking Algorithm

Backtracking is a technique to find a solution to a problem in an incremental approach. It solves problems recursively and tries to get to a solution to a problem by solving one piece of the problem at a time. If one of the solutions fail, we remove it and backtrack to find another solution.

In other words, a backtracking algorithm solves a subproblem and if it fails to solve the problem, it undoes the last step and starts again to find the solution to the problem.

N Queens problem is one good example to see Backtracking algorithm in action. The N Queen Problem states that there are N pieces of Queens in a chess board and we have to arrange them so that no queen can attack any other queen in the board once organized.

Exploring Variable Scope in Python with Nested Functions

Sanjay Khati Chhetri — Wed, 21 Jun 2023 00:42:39 +0000

Introduction:

Understanding variable scope is key to writing clean, efficient Python code. As variables can have different scopes, knowing how and when to access them is crucial. In this post, we will discuss variable scope in Python using an illustrative example involving nested functions. We will explore how variables in global, enclosed, and local scopes are accessed by different functions.

Example Python Code:

Below is the code snippet we will use to demonstrate variable scope.

global_var = 10

def enclosed_fn(enclosed_var):
    enclosed_var = 8
    print("i am inside the enclosed function, i can access variables in global scope:",global_var,"and enclosed scope:",enclosed_var,"\n")

    def local_fn():
        local_var = 5
        print("i am inside the local function, i can access variables in global scope:",global_var,"enclosed scope:",enclosed_var,"and local scope:",local_var,"\n")
    local_fn()

enclosed_fn()

print("i am a example of global function called print() , i can access variable declared outside the function or in global scope:",global_var,"\n")

Understanding the Code:

In this code, we define a global variable global_var, an enclosed function enclosed_fn, and a local function local_fn nested within enclosed_fn. Each function prints a statement demonstrating its ability to access variables from different scopes.

Global Scope:
Variables declared outside of any function or block are considered global variables. Their lifecycle extends throughout the entire runtime of the program. In our example, global_var is a global variable.
Enclosed Scope:
When a function is nested within another function, variables declared in the outer function can be accessed within the inner function. These variables are in the enclosing scope. In our example, enclosed_fn defines the variable enclosed_var, which is in the enclosing scope for local_fn.
Local Scope:
Variables declared within a function are considered local variables with a lifecycle limited to the execution of that function. In our example, local_fn defines the variable local_var, which has local scope.
Built-in Scope:
The scope that includes pre-defined attribute, such as the print(), str(), len(), range() function. These are available in any part of your Python code, without the need for any explicit import or declaration.

Takeaways from the Code:

The enclosed_fn can access variables in both global and enclosed scopes.
The local_fn (nested within enclosed_fn) can access variables in global, enclosed, and local scopes.
The built-in global function print() can access global_var from the global scope.

Conclusion:

Understanding variable scope in Python is essential for managing the interactions among different parts of your code. By examining this example with nested functions, we have demonstrated how variables in global, enclosed, and local scopes can be accessed by functions on different levels. This knowledge will enable you to write cleaner and more efficient Python programs.

A Comprehensive Guide to Variable Scope in Python

Sanjay Khati Chhetri — Wed, 21 Jun 2023 00:07:25 +0000

Introduction:

Mastering the concept of variable scope is crucial for every Python developer, as it governs the visibility and lifecycle of variables within your code. This in-depth article will discuss the significance of variable scope, explore different types of scopes - including built-in, global, enclosing, and local - with relevant code examples, and provide best practices for managing variable scope effectively.

1. Types of Variable Scopes in Python:

In Python, there are four levels of variable scope:

a. Built-in Scope

: This scope includes Python's pre-defined built-in functions and attributes like print(), len(), range(), and str(). These built-in functions are available globally within the program.

def example_function():
    print("This function uses the built-in 'print()' function.")

example_function()

b. Global Scope

: Variables declared outside of any function or block are considered global variables. Their lifecycle extends across the entire runtime of the program, and they can be accessed from any part of the code, including functions.

global_var = "I am a global variable"

def example_function():
    print(global_var)

example_function()      # Output: "I am a global variable"
print(global_var)       # Output: "I am a global variable"

c. Enclosing Scope

: When a function is nested within another function, variables declared in the outer function are accessible within the inner function. These variables are said to be in the enclosing scope.

def outer_function():
    enclosing_var = "I am in the enclosing scope"

    def inner_function():
        print(enclosing_var)

    inner_function()

outer_function()         # Output: "I am in the enclosing scope"

d. Local Scope

: Variables declared within a function are considered local variables. Their lifecycle is limited to the execution of that function, and they can only be accessed within the function or block in which they are declared.

def example_function():
    local_var = "I am a local variable"
    print(local_var)

example_function()      # Output: "I am a local variable"
print(local_var)        # Raises NameError, since local_var is not defined outside the function

2. The `global` and `nonlocal` Keywords

a. The `global` keyword

: To modify a global variable from within a function, you need to use the global keyword to explicitly inform Python that you want to reference a global variable, not create a new local variable.

counter = 0

def increment_counter():
    global counter
    counter += 1

increment_counter()
print(counter)  # Output: 1

b. The `nonlocal` keyword

: To modify an enclosing variable from within a nested function, use the nonlocal keyword. This tells Python that you want to reference a variable from an enclosing scope rather than create a new local variable.

def outer_function():
    enclosing_var = "Original value"

    def inner_function():
        nonlocal enclosing_var
        enclosing_var = "Modified value"

    inner_function()
    print(enclosing_var)

outer_function()  # Output: "Modified value"

3. Best Practices for Managing Variable Scope:

Adopting best practices for handling variable scope can help you write cleaner, more maintainable code:

Limit usage of global variables: Excessive use of global variables can lead to code that is hard to maintain and prone to conflicts. Instead, use function arguments and return values to pass data between functions.
Employ function arguments and return values: Rather than rely on global variables, pass necessary data as function arguments and return values to share the results between different parts of your code.
Restrict variable scope: Declare variables as local when possible to minimize their exposure and the potential for unintended modifications, thus reducing the risk of bugs.

Conclusion:

In this comprehensive guide, we've discussed the four variable scope levels in Python (built-in, global, enclosing, and local) and explored how to modify variables from different scopes using the global and nonlocal keywords. By understanding these concepts and adopting best practices for managing variable scope, you'll be better equipped to write efficient, maintainable, and bug-free Python programs.

operators in python

Sanjay Khati Chhetri — Mon, 19 Jun 2023 23:56:04 +0000

Exploring Python Operators: Simplifying Complex Operations Through Code Examples

Introduction:

Python operators are powerful tools in a programmer’s arsenal that make manipulating data and performing various operations amazingly simple and efficient. In this blog post, we will explore the different types of operators available in Python, including arithmetic, comparison, logical, identity, assignment, bitwise, and membership operators. We will guide you through numerous code examples to help you understand their functionality and application within the context of operators.

Arithmetic Operators:

These operators handle mathematical operations on numbers.

Addition +: Adds two numbers and returns an integer or float value, depending on the input
Subtraction -: Subtracts two numbers
Multiplication *: Multiplies two numbers
Division /: Divides two numbers
Exponent **: Calculates the power of a number
Floor Division //: Divides two numbers and rounds down to the nearest whole number, returning a float value
Modulus %: Determines the remainder of the division of two numbers and returns an integer value

Let's explore each of these arithmetic operators through code examples:

print(2+3) # Addition
print(2-3) # Subtraction
print(2*3) # Multiplication
print(2/3) # Division
print(2**3) # Exponent
print(2//3) # Floor Division
print(2%3, "\n") # Modulus

Comparison Operators:

Comparison operators compare values and return a Boolean result.

Equal ==: Determines if two values are equal
Not Equal !=: Determines if two values are not equal
Greater Than >: Checks if the first value is greater than the second value
Less Than <: Checks if the first value is less than the second value
Greater Than or Equal >=: Checks if the first value is greater than or equal to the second value
Less Than or Equal <=: Checks if the first value is less than or equal to the second value

Below are code examples for each comparison operator:

print(2==3) #Equal
print(2!=3) #Not Equal
print(2>3) #Greater Than
print(2<3) #Less Than
print(2>=3) # Greater Than or Equal
print(2<=3, "\n") #Less Than or Equal

Logical Operators:

These operators are essential for decision-making and flow control within the code.

And and: Returns True if both conditions are true; otherwise False
Or or: Returns True if at least one condition is true; otherwise False
Not not: Reverses the result of the condition – True becomes False and vice versa

Here are some code examples using logical operators with if-else constructs:

print(2==3 and 2!=3) # And

a = True
b = True
if a and b:
    print("All true!")
else:
    print("Not all true!")

a = True
b = False
if a and b:
    print("All true!")
else:
    print("Not all true!\n")

print(2==3 or 2!=3) # Or

a = True
b = False
if a or b:
    print("At least one true!")
else:
    print("Both false!")

a = False
b = False
if a or b:
    print("At least one true!")
else:
    print("Both false!\n")

print(not(2==3 and 2!=3)) # Not

a = True
b = True
if not(a) or not(b):
    print("Not true!")
else:
    print("True!")

a = False
b = False
if not(a) and not(b):
    print("Not true!\n")
else:
    print("True!\n")

Identity Operators:

These operators test the identity of objects.

Is is: Determines if two variables point to the same object
Is Not is not: Determines if two variables do not point to the same object

Code examples for both identity operators are shown below:

x = 2
y = 3
print(x is y) # is
print(x is not y, "\n") # is not

Assignment Operators:

Assignment operators assign values to variables.

Equals =: Assigns a value to a variable
Addition equals +=: Adds the specified value to the variable
Subtraction equals -=: Subtracts the specified value from the variable
Multiplication equals *=: Multiplies the variable by the specified value
Division equals /=: Divides the variable by the specified value
Exponent equals **=: Raises the variable to the power of the specified value
Floor Division equals //=: Performs floor division on the variable by the specified value
Modulus equals %=: Performs modulo operation on the variable by the specified value

Let's see these assignment operators in action:

x = 2
print(x)
x += 3 # Addition
print(x)
x -= 3 # Subtraction
print(x)
x *= 3 # Multiplication
print(x)
x /= 3 # Division
print(x)
x **= 3 # Exponent
print(x)
x //= 3 # Floor Division
print(x)
x %= 3 # Modulus
print(x, "\n")

Bitwise Operators:

Bitwise operators work on bits – the smallest units of data in computers.

And &: Performs bitwise AND on each bit of the two values
Or |: Performs bitwise OR on each bit of the two values
Xor ^: Performs bitwise XOR on each bit of the two values
Not ~: Inverts each bit of the value
Left Shift <<: Shifts the bits of the value to the left by the specified number of positions
Right Shift >>: Shifts the bits of the value to the right by the specified number of positions

Example code showcasing bitwise operators:

print(2&3) # And
print(2|3) # Or
print(2^3) # Xor
print(~2) # Not
print(2<<3) # Left Shift
print(2>>3, "\n") # Right Shift

Membership Operators:

These operators test the presence of an element within a sequence (e.g., string, list, or tuple).

In in: Checks if an element is in the sequence
Not In not in: Checks if an element is not in the sequence

Have a look at an example of membership operators using a list:

x = [1,2,3,4,5]
print(2 in x) # in
print(2 not in x) # not in

Conclusion:

Python operators provide a simple and efficient way to perform various operations on values and variables. By understanding the functionalities of different types of operators, you can enhance your programming skills, write concise code, and handle complex tasks with ease. Through the exploration of various code examples in this blog post, we hope to provide you clarity on the power and flexibility that comes with Python operators. So go ahead, harness the power of Python operators to make your coding experience smoother and more enjoyable!

Forem: Sanjay Khati Chhetri

Introduction to Big O Notation

Exploring Variable Scope in Python with Nested Functions

Introduction:

Example Python Code:

Understanding the Code:

Takeaways from the Code:

Conclusion:

A Comprehensive Guide to Variable Scope in Python

Introduction:

1. Types of Variable Scopes in Python:

a. Built-in Scope

b. Global Scope

c. Enclosing Scope

d. Local Scope

2. The global and nonlocal Keywords

a. The global keyword

b. The nonlocal keyword

3. Best Practices for Managing Variable Scope:

Conclusion:

operators in python

Exploring Python Operators: Simplifying Complex Operations Through Code Examples

2. The `global` and `nonlocal` Keywords

a. The `global` keyword

b. The `nonlocal` keyword