Author name: Vikram Chiluka

Dot Product:

The dot product, commonly known as the scalar product in mathematics, is an algebraic operation that takes two equal-length sequences of numbers and produces a single number.

Given two vectors A and B, we must find the dot product of the two vectors.

For Example :

Let A = a1i+a2j+a3k

B= b1i+b2j+b3k

Where

i is the unit vector along the x-axis.

j is the unit vector along the y-axis.

k is the unit vector along the z-axis.

The Formula to calculate the dot product

Dot product = a1*b1+a2*b2+a3*b3

Calculating Dot Product of Two Vectors in Python

The numpy.dot() method of the numpy library provides an efficient way to find the dot product of two sequences.

numpy.dot() is a method that accepts two sequences as arguments, whether they are vectors or multidimensional arrays, and displays the output, which is the dot product. To use this approach, we must first import Python’s numpy module.

Syntax:

numpy.dot(vector_a, vector_b, out = None )

Parameters

vector_a: It is an array. If a is complex, its complex conjugate is utilized to compute the dot product.

vector_b: It is an array. If b is complex, its complex conjugate is utilized to compute the dot product.

out: It is an array. This is optional. The output parameter must be C-contiguous, and its datatype must be the same as the datatype returned by dot (a,b).

Return Value:

Returns the Dot Product of given vectors a and b. Scalar is returned if vector a and vector b are both 1D.

How to find the Dot Product of Scalars?

Given two scalar values and use numpy.dot() function to display their dot product.

Approach:

• Import numpy library using the import keyword.
• Give the first scalar value as static input and store it in a variable.
• Give the second scalar value as static input and store it in another variable.
• Calculate the dot product of the given two scalar values using the numpy.dot() function by passing the given first and second scalar values as the arguments.
• Store it in another variable.
• Print the dot product of the given two scalar values.
• The Exit of the Program.

Below is the implementation:

# Import numpy library using the import keyword
import numpy as np
# Give the first scalar value as static input and store it in a variable.
x = 4
# Give the second scalar value as static input and store it in another variable.
y = 6
# Calculate the dot product of the given two scalar values using the numpy.dot()
# function by passing the given first and second scalar values as the arguments.
# Store it in another variable.
dot_prdct = np.dot(x, y)
# Print the dot product of the given two scalar values.
print("The dot product of given scalars x{", x, "} and y {", y, "} = ")
print(dot_prdct)

Output:

The dot product of given scalars x{ 4 } and y { 6 } = 
24

How to find the Dot Product of Arrays?

Given two arrays, and the task is to calculate the dot product of the given two vectors.

These arrays might be one-dimensional, two-dimensional, or multi-dimensional. And we’ll compute their dot product with the help of dot(). For the dot product, we are evaluating two 2-D arrays.

Matrix multiplication is used to compute the dot product for 2-D arrays.

Approach:

• Import numpy library using the import keyword
• Give the 2- Dimensional array as static input and store it in a variable.
• Give the other 2- Dimensional array as static input and store it in another variable.
• Calculate the dot product of the given two arrays using the numpy.dot() function by passing the given two 2-D arrays as the arguments.
• Store it in another variable.
• Print the dot product of the given two 2- Dimensional arrays.
• The Exit of the Program.

Below is the implementation:

# Import numpy library using the import keyword
import numpy as np
# Give the 2- Dimensional array as static input and store it in a variable.
x = [[3, 1], [5, 2]]
# Give the other 2- Dimensional array as static input and store it in another
# variable.
y = [[8, 5], [2, 4]]
# Calculate the dot product of the given two arrays using the numpy.dot()
# function by passing the given two 2-D arrays as the arguments.
# Store it in another variable.
dot_prdct = np.dot(x, y)
# Print the dot product of the given two 2- Dimensional arrays
print("The dot product of given two 2-D arrays x ", x, " and y ", y, " = ")
print(dot_prdct)

Output:

The dot product of given two 2-D arrays x [[3, 1], [5, 2]] and y [[8, 5], [2, 4]] = 
[[26 19]
[44 33]]

Note:

The dot product is not commutative for two-dimensional or multi-dimensional arrays. That means a.b does not equal b.a.

If we calculated dot product as a.b rather than b.a, the output is not the same for both of them. It is different for both.

What is Tiling Problem?

In the Tiling Problem, we would be given a wall of size 4*n, which means that the wall’s height is 4 and its length is n. ( given as the input).

Now we have an endless number of little 4*1 tiles that can be put on the wall in two distinct ways. Look at the below figure for more clarity:

Our goal is to fill the entire wall with all of the possible patterns using the small tiles in any of the approaches described above.

Tiling Problem Solution in Python:

One can either manually implement the naive technique using loops and if-else statements or use the quicker Recursion approach. If you want to learn about recursion, just have a glance over it what the recursion is? before going to the code.

We will use recursion to divide a large problem into smaller ones. Now, let’s look at the minor problems with both arrangements.

1st Arrangement: The first tile is placed using Method 1, reducing the length of the wall by 4, and the space above the present tile can only be filled in one way ( 3 tiles according to Method 1 )
2nd Arrangement: Next, using Method 2, we may place the first tile, reducing the length of the wall by one.

After the first arrangement has been completed. We call the same method but with a lower number of n to recursively call the same operations for the remaining wall.

The ultimate solution will be the sum of the possible ways in both the arrangements in each recursive call.

Program to Solve the Tiling Problem in Python

Recursion is used to simplify the code implementation. Just make sure you understand the solution that is given below:

• Using Recursion (Static Input)
• Using Recursion (User Input)

Method #1: Using Recursion (Static Input)

Approach:

• Give the n value as static input and store it in a variable.
• Create a recursive function say total_possiblearrangements() which accepts the given n value as an argument that returns the total number of possible arrangements in both ways.
• Inside the function, Check if the given n value is less than or equal to 3 using the if conditional statement.
• If it is true, then return 1.
• Return the value of total_possiblearrangements(gvn_n_val-1) + total_possiblearrangements(gvn_n_val-4) (Recursive Logic).
• Pass the given n value as an argument to the total_possiblearrangements() function and store it in a variable.
• Print the above result.
• The Exit of the Program.

Below is the implementation:

# Create a recursive function say total_possiblearrangements() which accepts the
# given n value as an argument that returns the total number of possible
# arrangements in both ways.


def total_possiblearrangements(gvn_n_val):
        # Inside the function, Check if the given n value is less than or equal to 3
        # using the if conditional statement.

    if(gvn_n_val <= 3):
        # If it is true, then return 1.
        return 1
        # Return the value of total_possiblearrangements(gvn_n_val-1) +
        # total_possiblearrangements(gvn_n_val-4) (Recursive Logic).
    return total_possiblearrangements(gvn_n_val-1) + total_possiblearrangements(gvn_n_val-4)


# Give the n value as static input and store it in a variable.
gvn_n_val = 3
# Pass the given n value as an argument to the total_possiblearrangements()
# function and store it in a variable.
rslt = total_possiblearrangements(gvn_n_val)
# Print the above result.
print("The total number of possible arrangements in both ways = ")
print(rslt)

Output:

The total number of possible arrangements in both ways = 
1

Method #2: Using Recursion (User Input)

Approach:

• Give the n value as user input using the int(input()) function and store it in a variable.
• Create a recursive function say total_possiblearrangements() which accepts the given n value as an argument that returns the total number of possible arrangements in both ways.
• Inside the function, Check if the given n value is less than or equal to 3 using the if conditional statement.
• If it is true, then return 1.
• Return the value of total_possiblearrangements(gvn_n_val-1) + total_possiblearrangements(gvn_n_val-4) (Recursive Logic).
• Pass the given n value as an argument to the total_possiblearrangements() function and store it in a variable.
• Print the above result.
• The Exit of the Program.

Below is the implementation:

# Create a recursive function say total_possiblearrangements() which accepts the
# given n value as an argument that returns the total number of possible
# arrangements in both ways.


def total_possiblearrangements(gvn_n_val):
        # Inside the function, Check if the given n value is less than or equal to 3
        # using the if conditional statement.

    if(gvn_n_val <= 3):
        # If it is true, then return 1.
        return 1
        # Return the value of total_possiblearrangements(gvn_n_val-1) +
        # total_possiblearrangements(gvn_n_val-4) (Recursive Logic).
    return total_possiblearrangements(gvn_n_val-1) + total_possiblearrangements(gvn_n_val-4)


# Give the n value as user input using the int(input()) function and store it in a variable.
gvn_n_val = int(input("Enter n value = "))
# Pass the given n value as an argument to the total_possiblearrangements()
# function and store it in a variable.
rslt = total_possiblearrangements(gvn_n_val)
# Print the above result.
print("The total number of possible arrangements in both ways = ")
print(rslt)

Output:

Enter n value = 4
The total number of possible arrangements in both ways = 
2

Let us look at a highly exciting subject called Printing all possible subsequences/subsets of a given string.

There are two options for each element in the specified string:

Include the first element in the subsequence and then determine the subsequence for the other elements.
Alternatively, leave out the first element and determine the subsequence for the remaining elements.
The same logic is used in each recursive call until we reach the last index of the provided array.

In that scenario, we just print the created subsequence and then return to identify the next subsequence.

Python Code

• Using Built-in Functions (Static Input)
• Using Built-in Functions (User Input)

Method #1: Using Recursive Function (Static Input)

Approach:

• Give the string as static input and store it in a variable.
• Create a recursive function say possible_subsequences() which accepts the given string, result string, and index pointing for the given string as the arguments and returns all the subsequences or subsets of a given string.
• Inside the possible_subsequences() function, check if the index argument(k) is equal to the given length of the string or not using the if conditional statement.
• If it is true, then check if the length of the result string is not equal to 0 using the if conditional statement.
• If it is true, then print the result string.
• Else, Pass the given string, result string, and k+1 for the function itself(recursive logic). It excludes the first character.
• Add the given string at the index k to the result string and store it in the same variable.
• Pass the given string, result string, and k+1 for the function itself(recursive logic). It includes the first character.
• Return.
• Pass the given string, empty string and 1st index(0) to the recursive function possible_subsequences().
• Print the first character of the given string.
• The Exit of the Program.

Below is the implementation:

# Create a recursive function say possible_subsequences() which accepts the
# given string, result string, and index pointing for the given string as
# the arguments and returns all the subsequences or subsets of a given string.


def possible_subsequences(gvn_str, rslt, k):
    # Inside the possible_subsequences() function, check if the index argument(k)
        # is equal to the given length of the string or not using the if conditional
        # statement.
    if (k == len(gvn_str)):
        # If it is true, then check if the length of the result string is not equal
                # to 0 using the if conditional statement.
        if (len(rslt) != 0):
          # If it is true, then print the result string.
            print(rslt)
    else:
        # Else, Pass the given string, result string, and k+1 for the function itself
                # (recursive logic). It excludes the first character.
        possible_subsequences(gvn_str, rslt, k+1)

        # Add the given string at the index k to the result string and store it in
        # the same variable.It includes the first character.
        rslt += gvn_str[k]
        # Pass the given string, result string, and k+1 for the function itself
        # (recursive logic).
        possible_subsequences(gvn_str, rslt, k+1)
    # Return.
    return


# Give the string as static input and store it in a variable.
gvn_str = "pqr"
print("The all possible subsequences of a given string are :")
# Pass the given string, empty string and 1st index(0) to the recursive function
# possible_subsequences().
possible_subsequences(gvn_str, "", 0)
# Print the first character of the given string.
print(gvn_str[0])

Output:

The all possible subsequences of a given string are :
r
q
qr
p
pr
pq
pqr
p

Method #2: Using Recursive Function (User Input)

Approach:

• Give the string as user input using the input() function and store it in a variable.
• Create a recursive function say possible_subsequences() which accepts the given string, result string, and index pointing for the given string as the arguments and returns all the subsequences or subsets of a given string.
• Inside the possible_subsequences() function, check if the index argument(k) is equal to the given length of the string or not using the if conditional statement.
• If it is true, then check if the length of the result string is not equal to 0 using the if conditional statement.
• If it is true, then print the result string.
• Else, Pass the given string, result string, and k+1 for the function itself(recursive logic). It excludes the first character.
• Add the given string at the index k to the result string and store it in the same variable.
• Pass the given string, result string, and k+1 for the function itself(recursive logic). It includes the first character.
• Return.
• Pass the given string, empty string and 1st index(0) to the recursive function possible_subsequences().
• Print the first character of the given string.
• The Exit of the Program.

Below is the implementation:

# Create a recursive function say possible_subsequences() which accepts the
# given string, result string, and index pointing for the given string as
# the arguments and returns all the subsequences or subsets of a given string.


def possible_subsequences(gvn_str, rslt, k):
    # Inside the possible_subsequences() function, check if the index argument(k)
        # is equal to the given length of the string or not using the if conditional
        # statement.
    if (k == len(gvn_str)):
        # If it is true, then check if the length of the result string is not equal
                # to 0 using the if conditional statement.
        if (len(rslt) != 0):
          # If it is true, then print the result string.
            print(rslt)
    else:
        # Else, Pass the given string, result string, and k+1 for the function itself
                # (recursive logic). It excludes the first character.
        possible_subsequences(gvn_str, rslt, k+1)

        # Add the given string at the index k to the result string and store it in
        # the same variable.It includes the first character.
        rslt += gvn_str[k]
        # Pass the given string, result string, and k+1 for the function itself
        # (recursive logic).
        possible_subsequences(gvn_str, rslt, k+1)
    # Return.
    return


# Give the string as user input using the input() function and store it in a variable.
gvn_str = input("Enter some random string = ")
print("The all possible subsequences of a given string are :")
# Pass the given string, empty string and 1st index(0) to the recursive function
# possible_subsequences().
possible_subsequences(gvn_str, "", 0)
# Print the first character of the given string.
print(gvn_str[0])

Output:

Enter some random string = xyz
The all possible subsequences of a given string are :
z
y
yz
x
xz
xy
xyz
x

Hello, programmer! Today, in this tutorial, we will do some basic coding in Python to find which quadrant of the s a specific point belongs to in space.

In 2D space, there are a total of four coordinates.

The condition for each quadrant, in this case, is as follows:

Quadrant 1: negative x and a positive y.
Quadrant 2:  x and y are both positive.
Quadrant 3:  x and y are both negative.
Quadrant 4: positive x and a negative y.

Finding Quadrant from x and y values – Python

• Using If-Else Conditional Statements (Static Input)
• Using If-Else Conditional Statements (User Input)

Method #1: Using If-Else Conditional Statements (Static Input)

Approach:

• Give the x-coordinate as static input and store it in a variable.
• Give the y-coordinate as static input and store it in another variable.
• Check if the given x-coordinate is less than 0 and y-coordinate is less than 0 using the if conditional statement.
• If it is true, then print “The point is in 3rd Quadrant”.
• Check if the given x-coordinate is less than 0 and y-coordinate is greater than 0 using the if conditional statement.
• If it is true, then print “The point is in 1st Quadrant”.
• Check if the given x-coordinate is greater than 0 and y-coordinate is greater than 0 using the if conditional statement.
• If it is true, then print “The point is in 2nd Quadrant”.
• Else print “The point is in 4th Quadrant”.
• The Exit of the Program.

Below is the implementation:

# Give the x-coordinate as static input and store it in a variable.
x_coordinate = 6
# Give the y-coordinate as static input and store it in another variable.
y_coordinate = -2
# Check if the given x-coordinate is less than 0 and y-coordinate is less than 0
# using the if conditional statement.
if(x_coordinate < 0 and y_coordinate < 0):
    # If it is true, then print "The point is in 3rd Quadrant".
    print("The point is in 3rd Quadrant")
# Check if the given x-coordinate is less than 0 and y-coordinate is greater
# than 0 using the if conditional statement.
elif(x_coordinate < 0 and y_coordinate > 0):
    # If it is true, then print "The point is in 1st Quadrant".
    print("The point is in 1st Quadrant")
# Check if the given x-coordinate is greater than 0 and y-coordinate is greater
# than 0 using the if conditional statement.
elif(x_coordinate > 0 and y_coordinate > 0):
    # If it is true, then print "The point is in 2nd Quadrant".
    print("The point is in 2nd Quadrant")
# Else print "The point is in 4th Quadrant".
else:
    print("The point is in 4th Quadrant")

Output:

The point is in 4th Quadrant

Method #2: Using If-Else Conditional Statements (User Input)

Approach:

• Give the x-coordinate as user input using the int(input()) function and store it in a variable.
• Give the y-coordinate as user input using the int(input()) function and store it in another variable.
• Check if the given x-coordinate is less than 0 and y-coordinate is less than 0 using the if conditional statement.
• If it is true, then print “The point is in 3rd Quadrant”.
• Check if the given x-coordinate is less than 0 and y-coordinate is greater than 0 using the if conditional statement.
• If it is true, then print “The point is in 1st Quadrant”.
• Check if the given x-coordinate is greater than 0 and y-coordinate is greater than 0 using the if conditional statement.
• If it is true, then print “The point is in 2nd Quadrant”.
• Else print “The point is in 4th Quadrant”.
• The Exit of the Program.

Below is the implementation:

# Give the x-coordinate as user input using the int(input()) function and store it in a variable.
x_coordinate = int(input("Enter x coordinate = "))
# Give the y-coordinate as user input using the int(input()) function and store it in another variable.
y_coordinate = int(input("Enter x coordinate = "))
# Check if the given x-coordinate is less than 0 and y-coordinate is less than 0
# using the if conditional statement.
if(x_coordinate < 0 and y_coordinate < 0):
    # If it is true, then print "The point is in 3rd Quadrant".
    print("The point is in 3rd Quadrant")
# Check if the given x-coordinate is less than 0 and y-coordinate is greater
# than 0 using the if conditional statement.
elif(x_coordinate < 0 and y_coordinate > 0):
    # If it is true, then print "The point is in 1st Quadrant".
    print("The point is in 1st Quadrant")
# Check if the given x-coordinate is greater than 0 and y-coordinate is greater
# than 0 using the if conditional statement.
elif(x_coordinate > 0 and y_coordinate > 0):
    # If it is true, then print "The point is in 2nd Quadrant".
    print("The point is in 2nd Quadrant")
# Else print "The point is in 4th Quadrant".
else:
    print("The point is in 4th Quadrant")

Output:

Enter x coordinate = -4
Enter x coordinate = -2
The point is in 3rd Quadrant

When we write a program, we can make mistakes that cause errors when we run it. When a Python program meets an unhandled error, it terminates. These errors can be divided into two categories:

1. Syntax Errors
2. Logical Errors(Exceptions)

Syntax Errors:

Syntax error or parsing error refers to an error caused by not following the right structure (syntax) of the language.

For Example:

numb = 10
if(numb > 0)    # colon(:) is missing here 
print("positive number")
else:
    print("Negative number")

Output:

 File "/home/ba12f4db06be8a7ce06b7796040d87d0.py", line 2
    if(numb > 0)
               ^
SyntaxError: invalid syntax

An arrow in the example indicates where the parser encountered the syntax problem.

We can see that there is no colon: in the if statement in line 2

Logical Errors(Exceptions):

Exceptions or logical errors are errors that occur at runtime (after passing the syntax test).

An exception is a condition in a program that interrupts the flow of the program and causes the code to stop running. Python has a fantastic approach to handling exceptions so that the code runs without problems or disruptions.

For example, they occur when we attempt to open (read) a file that does not exist (FileNotFoundError), divide an integer by zero (ZeroDivisionError), or import a module that does not exist (ImportError).

Python generates an exception object if these types of runtime issues occur. If the error is not handled appropriately, it prints a traceback to the error as well as some information about why the issue happened.

Exceptions can be either built-in errors/exceptions or bespoke exceptions.

The following are some examples of common in-built exceptions:

• ZeroDivisionError
• NameError
• IndentationError
• IOError
• EOFError

 Python test Exception Creation

For Example:

gvn_num1 = int(input("Enter 1st number = "))
gvn_num2 = int(input("Enter 2nd number = "))
print("The division of (1st number/2nd number) =  ")
print(gvn_num1/gvn_num2)

Output:

Enter 1st number = 6
Enter 2nd number = 0
The division of (1st number/2nd number) = 
Traceback (most recent call last):
File "jdoodle.py", line 4, in <module>
print(gvn_num1/gvn_num2)
ZeroDivisionError: division by zero

Handling Exceptions by try -except Blocks in Python

We use try-except statements to avoid errors from occurring and halting the program’s progress. The entire logic of the code is contained within the try block, and the except block handles conditions where an exception/error occurs.

Syntax:

try:
    # block of code
except <Exception Name>:
    # block of code
# Rest of code

How to Handle ZeroDivisionError in Python?

try:
    gvn_num1 = int(input("Enter 1st number = "))
    gvn_num2 = int(input("Enter 2nd number = "))
    print(gvn_num1/gvn_num2)
except ZeroDivisionError:  # exception name for handling it
    print("The Denominator cannot be zero.Enter a valid number")

Output:

Enter 1st number = 5
Enter 2nd number = 0
The Denominator cannot be zero.Enter a valid number

NameError Exception:

In Python, there are various standard exceptions, one of which is NameError. When the identifier being referenced is not declared in the local or global scope, a NameError is thrown. NameError can be caused by a variety of factors, including:

1. When built-in function is misspelled

num = int(input("Enter number = "))
prnt(num)

Output:

Enter number = 3
Traceback (most recent call last):
File "jdoodle.py", line 2, in <module>
prnt(num)
NameError: name 'prnt' is not defined

Here print is misspelled

2. Using variables that aren’t defined

gvn_str = input("Enter string = ")
print(gvn_string)

Output:

Enter string = hello
Traceback (most recent call last):
File "jdoodle.py", line 2, in <module>
print(gvn_string)
NameError: name 'gvn_string' is not defined

Here gvn_string is not defined, we gave gvn_str.

3. Defining a variable after its use

print(gvn_str)
gvn_str = input("Enter string = ")

Here we get Name Error since gvn_str is defined after it is used.

4. Incorrect use of scope.

How to Handle NameError Exception in Python?

try:
    gvn_str = "hello"
    print(gvn_string)
except NameError:
    print("NameError Exception. Please check ")

Output:

NameError Exception. Please check

The following are some of the most common built-in exceptions in Python programming are

AssertionError, FloatingPointError, ImportError, AttributeError, OverflowError, OSError etc

Conclusion

You now have an introduction to exceptional handling, and I hope you understand the fundamental concepts of exception handling.

In this session, we will learn about The Ladders Problem, which is a highly interesting problem. Let us first define what we hope to accomplish with this problem.

Let us First See, What the Ladders Problem is?

In the problem, we are given two inputs: the number of steps and the maximum number of steps that a man can take at one time.

For example, if the maximum number of steps is 3, At any given time, a person can take one, two, or three steps.

We must count all of the ways the man can reach the top of the ladder by taking one, two, or three steps at a time.

Here Comes the Solution

The problem may now be solved with standard looping and if-else statements. However, following the Recursion technique is a preferable option. If you are unfamiliar with how Recursion works, I recommend just having a glance over it.

To answer this problem, we shall seek the smallest problems, i.e. for n = 1 to n = n.

Consider that the maximum number of steps is three.

No of steps in a ladder (n)                     Total possible Ways   

1                                                             Only one possible way

2                                                             2  Possible ways – Take 1 step two times or 2 steps 1 time

3                                                            4  possible ways – Take 1 step 3 times, Take 2 steps 1 time and 1 step 1                                                                                          time, Take 1 step 1 time and 2 steps 1 time, Take 3 steps 1 time Take                                                                                     1  step

n>3                                                       (Take 1 step+ Take 2 steps + Take 3 steps ) and find the remaining

                                                             F(n) = F(n-1)+F(n-2)+F(n-3)

Python code

In this case, we are calculating the number of methods for k maximum steps. As a result, we shall compute the values in the order (n-1), (n-2), (n-3) and so on till (n-k).

Finally, we will add together all of the values obtained and return the final result. The code for implementing the same is provided below.

Method #1: Using Built-in Functions (Static Input)

Approach:

• Create a function say total_possibleways() which accepts the given two n, k values as the arguments and returns the total possible ways that a man can reach the top of the ladder.
• Inside the function, check if the given n value is less than 0 using the if conditional statement.
• If it is true, then return 0.
• Check if the given n value is equal to 0 (already at the top) using the if conditional statement.
• If it is true, then return 1.
• Similarly, Check if the given n value is less than 3.
• If it is true, then return the given n value.
• Take a variable and initialize its value with 0.
• Loop from 1 to the given k value using the for loop.
• Inside the loop, pass gvn_n-iterator value, gvn_k (recursive function) as arguments to the total_possibleways() function and it to the above declared variable.
• Store it in another variable.
• Return the above result.
• Give the n value as static input and store it in a variable.
• Give the k value as static input and store it in another variable.
• Pass the given n, k values to the above total_possibleways() function and store it in another variable.
• Print the above result i.e, total possible ways.
• The Exit of the Program.

Below is the implementation:

# Create a function say total_possibleways() which accepts the given two n, k values
# as the arguments and returns the total possible ways that a man can reach the top
# of the ladder


def total_possibleways(gvn_n, gvn_k):
    # Inside the function, check if the given n value is less than 0 using the
    # if conditional statement.

    if(gvn_n < 0):
        # If it is true, then return 0.
        return 0

    # Check if the given n value is equal to 0 (already at the top) using
        # the if conditional statement.
    if(gvn_n == 0):
        # If it is true, then return 1.
        return 1
        # Similarly, Check if the given n value is less than 3.
    if(gvn_n < 3):
        # If it is true, then return the given n value.
        return gvn_n

    # Take a variable and initialize its value with 0.
    rslt = 0
    # Loop from 1 to the given k value using the for loop.
    for itr in range(1, gvn_k+1):
        # Inside the loop, pass gvn_n-iterator value, gvn_k (recursive function)
        # as arguments to the total_possibleways() function and it to the above
        # declared variable.
        # Store it in another variable.
        rslt += total_possibleways(gvn_n-itr, gvn_k)
    # Return the above result.
    return rslt


# Give the n value as static input and store it in a variable.
gvn_n = 10
# Give the k value as static input and store it in another variable.
gvn_k = 12
# Pass the given n, k values to the above total_possibleways() function and
# store it in another variable.
fnl_rslt = total_possibleways(gvn_n, gvn_k)
# Print the above result i.e, total possible ways
print("The total possible ways = ", fnl_rslt)

Output:

The total possible ways =  512

Method #2: Using Built-in Functions (User Input)

Approach:

• Create a function say total_possibleways() which accepts the given two n, k values as the arguments and returns the total possible ways that a man can reach the top of the ladder.
• Inside the function, check if the given n value is less than 0 using the if conditional statement.
• If it is true, then return 0.
• Check if the given n value is equal to 0 (already at the top) using the if conditional statement.
• If it is true, then return 1.
• Similarly, Check if the given n value is less than 3.
• If it is true, then return the given n value.
• Take a variable and initialize its value with 0.
• Loop from 1 to the given k value using the for loop.
• Inside the loop, pass gvn_n-iterator value, gvn_k (recursive function) as arguments to the total_possibleways() function and it to the above declared variable.
• Store it in another variable.
• Return the above result.
• Give the n value as user input using the int(input()) function and store it in a variable.
• Give the k value as user input using the int(input()) function and store it in another variable.
• Pass the given n, k values to the above total_possibleways() function and store it in another variable.
• Print the above result i.e, total possible ways.
• The Exit of the Program.

Below is the implementation:

# Create a function say total_possibleways() which accepts the given two n, k values
# as the arguments and returns the total possible ways that a man can reach the top
# of the ladder


def total_possibleways(gvn_n, gvn_k):
    # Inside the function, check if the given n value is less than 0 using the
    # if conditional statement.

    if(gvn_n < 0):
        # If it is true, then return 0.
        return 0

    # Check if the given n value is equal to 0 (already at the top) using
        # the if conditional statement.
    if(gvn_n == 0):
        # If it is true, then return 1.
        return 1
        # Similarly, Check if the given n value is less than 3.
    if(gvn_n < 3):
        # If it is true, then return the given n value.
        return gvn_n

    # Take a variable and initialize its value with 0.
    rslt = 0
    # Loop from 1 to the given k value using the for loop.
    for itr in range(1, gvn_k+1):
        # Inside the loop, pass gvn_n-iterator value, gvn_k (recursive function)
        # as arguments to the total_possibleways() function and it to the above
        # declared variable.
        # Store it in another variable.
        rslt += total_possibleways(gvn_n-itr, gvn_k)
    # Return the above result.
    return rslt


# Give the n value as user input using the int(input()) function and store it in a variable.
gvn_n = int(input("Enter No of steps(n) =  "))
# Give the k value as user input using the int(input()) function and store it in another variable.
gvn_k = int(input("Enter maximum no of steps(k) = "))
# Pass the given n, k values to the above total_possibleways() function and
# store it in another variable.
fnl_rslt = total_possibleways(gvn_n, gvn_k)
# Print the above result i.e, total possible ways
print("The total possible ways = ", fnl_rslt)

Output:

Enter No of steps(n) = 3
Enter maximum no of steps(k) = 4
The total possible ways = 4

Every college or university student faces numerous challenges while studying. They do everything they can to get an A on a programming project. College students must learn quickly in order to achieve high grades.

Each project given to students is designed to assess their comprehension of the concept of a programming language and how much it can be implemented in the program. Most students fail to complete their projects because they demand proper guidance and consistent work.

Choosing a programming assignment to assist and complete homework is the finest method to cope with things. If it is created by experts, they will be able to deal with code at all levels of difficulty with ease.

1) Planning is essential.

You must be able to manage your time well and grasp the big picture. A deliberate approach to coding is the best approach. When you examine conditions and deadlines, you will reduce stress, which can lead to procrastination. In turn, good preparation will increase your effectiveness and save you time. A thorough comprehension of the coding methods and stages will be a magic wand that will boost your GPA significantly.

2)Conduct preliminary research before beginning the assignment.

Do not begin working on homework immediately after it is announced. This may appear to be an argument because you are urged to begin working on the task as soon as it is assigned. Simply take the time to acquire information on the topic or scope of the homework. When writing an assignment, the best strategy is to extensively research the topic before beginning to write the document.

Thorough and detailed research provides you with a wider understanding of the subject. You’ll also meet others who have written about the same subject. You will obtain elements that will support your concept as a result of this.

3)Additional coding skills or courses should be taken.

There are numerous methods for improving your coding performance. Tutoring and extra lessons can help if you have the time and money to do so. If you want to improve your grades but cannot afford a private tutor, seek reputable free online programming classes. Such courses have the potential to earn high grades in terms of both ecology and effectiveness. Choose an online school and work on improving your knowledge.

4)Get rid of the pen and paper.

Many of you feel your creativity emerge when you pick up a pen and paper. But let’s be honest! Writing a computer code does not necessitate the use of a pen and paper; rather, it wastes your valuable time, making it difficult to meet deadlines. So, the next time you sit down to create code, put down the pen and paper.

5)Talk to other programmers.

Simply talking about the program with other students and developers is an incredible method to learn about it. Speak with the programmers about what you’re studying, what inspires you the most, or what you’re currently working on. This interaction can aid in learning about institutions, assistance, and programming languages. And new models, as well as describing other notions that you would never have thought of in such a way.

6)Make use of your mistakes to improve yourself.

Nobody becomes an expert developer right away. Self-improvement is an ongoing and difficult effort. Simply shift your perspective and learn from your errors. Failures should be seen positively because they help you become a more capable and skilled specialist. When your lecturer comments on your coding task, ask for a full explanation and, in turn, comment on your errors. Failure analysis will provide you with additional experience and allow you to learn more quickly.

7)Become a member of a coding group.

Learning in the company of other STEM students and like-minded individuals can assist you to gain a thorough understanding of coding. Because COVID-19 had an impact on offline community events, many programming camps moved online and have now acquired great potential. Being a part of something larger than yourself is a great source of energy and inspiration. If you are having difficulty with a complex coding task, you will have numerous opportunities to get guidance from community members.

8)Never, ever give up on a programming project.

We all agree that it’s easier said than done because no programmer has ever finished a program on the first try. There’s always the challenge of sitting around, trying to figure out why an error occurred, and figuring out which code will get rid of it. It is not only time-intensive, but it may also be frustrating numerous times, prompting you to consider quitting every now and then. However, our specialists advise you to never give up on your program. Instead, take pauses when you reach a dead-end and return later to complete it effectively.

9)Feel free to experiment with new ideas.

Having numerous projects running at the same time is the most efficient way to test and try new sources. Don’t lose time if you test a new code or terminal and the result falls short of your expectations. You should spend no more than forty minutes on any new code idea. If things don’t go as planned, it’s preferable to leave this business and come back later when you may have more support.

10)Ask for help and support.

As students, we are often hesitant to ask questions because we believe they are silly and that we will be judged for asking simple questions. However, our experts advise that you should always seek help and go to your professors with any doubts you have, simple or complex, in order to ensure your own clarity of the concepts, which will save you a lot of trouble later.

11)A positive attitude about all that learners do

Perhaps the most important piece of advice for college students attempting to accomplish homework is to have a positive attitude. While preparation is time-consuming, kids must recognize the importance of it as they progress through their academic careers. As a result, learn to accept it and approach new difficulties with a constructive attitude.

This will assist in viewing the work as a stepping stone toward accomplishing learning objectives. This mindset exposes kids to the lessons that come with completing assignments. At the end of the day, if some of the questions or portions are challenging, the student can ask for assistance, and it will be simpler to finish chores with a good attitude.

12)Take into account the Teachers’ expectations.

While professional coding techniques vary widely, it is critical for students to remember that in order to receive excellent grades in their programs, they must meet the expectations of their teachers. As a result, it is critical that you always grasp your professors’ expectations and explain your programs to make them self-explanatory so that they can understand why you developed a given code in a certain way.

13)Don’t take the easy way out to good grades.

Yes, it is tough to submit each assignment flawlessly as a student, however, cheating or duplicating existing codes and programs to accomplish your programming assignment is not beneficial for your GPA. As much as you may believe that your teachers will not notice, plagiarism is a major issue in academics today, and professors pay close attention to it.

Itertools Module:

Itertools is a Python module that contains a collection of functions for dealing with iterators. They make it very simple to iterate through iterables such as lists and strings.

Itertools in Python refers to a Python module that allows the creation of iterators, which aids in efficient looping, as well as time and space efficiency. itertools enable us to solve complex problems quickly and easily. Iterators are classified into three types.

This module provides the following types of iterators:

1. Combinatorics Generators
2. Infinite Iterators
3. Terminating Iterators

itertools.product() Function:

Cartesian Product of two sets is defined in mathematics as the set of all ordered pairs (a, b) where a belongs to A and b belongs to B.

itertools.product() belongs to the Python itertools library’s Combinatoric iterators category.

itertools.product() returns the cartesian product from the specified iterator, with the output being lexicographically sorted.

There are two ways to use itertools.product():

itertools.product(*iterables, repeat=1):

This function returns the cartesian product of the provided iterable with itself for the number of times specified by the optional keyword “repeat.”

For example, product(arr, repeat=4) is equivalent to product (arr, arr, arr, arr).
itertools.product(*iterables):

This function returns the cartesian product of all iterables passed as arguments. For instance, product (arr1, arr2, arr3, arr4).

Consider the following example to gain a better idea.

Examples:

Example1:

Input:

Given first List = [10, 9, 8]
Given second List = [12, 3, 40]

Output:

The cartesian product of the given two lists = 
[(10, 12), (10, 3), (10, 40), (9, 12), (9, 3), (9, 40), (8, 12), (8, 3), (8, 40)]

Example2:

Input:

Given first List = [78, 2, 6]
Given second List = [4, 2, 7]

Output:

The cartesian product of the given two lists = 
[(78, 4), (78, 2), (78, 7), (2, 4), (2, 2), (2, 7), (6, 4), (6, 2), (6, 7)]

Itertools.product() Function with Examples in Python

• Using Built-in Functions (Static Input)
• Using Built-in Functions (User Input)

Method #1: Using Built-in Functions (Static Input)

Approach:

• Import product() function from itertools module using the import keyword.
• Create a function say CartesianProdct() which accepts the two lists as the arguments and returns the cartesian product of the given two lists.
• Inside the function, Using the product() method, return a list of all computed tuples.
• Inside the main function, Give the first list as static input and store it in a variable.
• Give the second list as static input and store it in another variable.
• Pass the given two lists as the arguments to the above declared CartesianProdct() function and store it in another variable.
• Print the cartesian product of the given two lists.
• The Exit of the Program.

Below is the implementation:

# Import product() function from itertools module using the import keyword.
from itertools import product

# Create a function say CartesianProdct() which accepts the two lists as
# the arguments and returns the cartesian Product of the given two lists


def CartesianProdct(gvn_fstlst, gvn_scndlst):

    # Using the product() method, return a list of all computed tuples.
    return list(product(gvn_fstlst, gvn_scndlst))


# Inside the main function,
# Give the first list as static input and store it in a variable.
gvn_fstlst = [10, 9, 8]
# Give the second list as static input and store it in another variable.
gvn_scndlst = [12, 3, 40]
# Pass the given two lists as the arguments to the above declared CartesianProdct()
# function and store it in another variable.
rslt = CartesianProdct(gvn_fstlst, gvn_scndlst)
# Print the cartesian product of the given two lists
print("The cartesian product of the given two lists = ")
print(rslt)

Output:

The cartesian product of the given two lists = 
[(10, 12), (10, 3), (10, 40), (9, 12), (9, 3), (9, 40), (8, 12), (8, 3), (8, 40)]

Method #2: Using Built-in Functions (User Input)

Approach:

• Import product() function from itertools module using the import keyword.
• Create a function say CartesianProdct() which accepts the two lists as the arguments and returns the cartesian product of the given two lists.
• Inside the function, Using the product() method, return a list of all computed tuples.
• Inside the main function,
• Give the first list as user input using list(),map(),input(),and split() functions.
• Store it in a variable.
• Give the second list as user input using list(),map(),input(),and split() functions.
• Store it in another variable.
• Pass the given two lists as the arguments to the above declared CartesianProdct() function and store it in another variable.
• Print the cartesian product of the given two lists.
• The Exit of the Program.

Below is the implementation:

# Import product() function from itertools module using the import keyword.
from itertools import product

# Create a function say CartesianProdct() which accepts the two lists as
# the arguments and returns the cartesian Product of the given two lists


def CartesianProdct(gvn_fstlst, gvn_scndlst):

    # Using the product() method, return a list of all computed tuples.
    return list(product(gvn_fstlst, gvn_scndlst))


# Inside the main function,
# Give the first list as user input using list(),map(),input(),and split() functions.
# Store it in a variable.
gvn_fstlst = list(map(int, input(
   'Enter some random List Elements separated by spaces = ').split()))
# Give the second list as user input using list(),map(),input(),and split() functions.
# Store it in another variable.
gvn_scndlst = list(map(int, input(
   'Enter some random List Elements separated by spaces = ').split()))
# Pass the given two lists as the arguments to the above declared CartesianProdct()
# function and store it in another variable.
rslt = CartesianProdct(gvn_fstlst, gvn_scndlst)
# Print the cartesian product of the given two lists
print("The cartesian product of the given two lists = ")
print(rslt)

Output:

Enter some random List Elements separated by spaces = 78 2 6
Enter some random List Elements separated by spaces = 4 2 7
The cartesian product of the given two lists = 
[(78, 4), (78, 2), (78, 7), (2, 4), (2, 2), (2, 7), (6, 4), (6, 2), (6, 7)]

Calendar Module:

The calendar module allows you to output calendars like a program and includes extra calendar-related operations. Calendar module functions and classes make use of an idealized calendar, the current Gregorian calendar extended in both directions indefinitely.

itermonthdays() Method:

The itermonthdays() method returns an iterator for a month and year given. The days returned will be merely day numbers. The procedure is similar to itermonthdates ().

Syntax:

itermonthdays(year, month)

Parameter Values:

year: This is required. It is a number. The year for which the calendar should be created.

month: This is required. It is a number. The month for which the calendar should be created.

Return Value:

The iterator of the chosen month is returned.

Program for calendar itermonthdays() Method with Examples in Python

• Using Built-in Functions (Static Input)
• Using Built-in Functions (User Input)

Method #1: Using Built-in Functions (Static Input)

Example1:

Approach:

• Import calendar module using the import keyword.
• Give the year as static input and store it in a variable.
• Give the month as static input and store it in another variable.
• Call the Calendar() function and store it in another variable.
• Apply itermonthdays() method to the above calendar by passing the given year, month as the arguments and store it in another variable.
• Iterate in the above result using the for loop.
• Inside the loop, print the iterator value.
• The Exit of the Program.

Below is the implementation:

# Import calendar module using the import keyword.
import calendar
# Give the year as static input and store it in a variable.
gvn_yr = 2015
# Give the month as static input and store it in another variable.
gvn_mont = 4
# Call the Calendar() function and store it in another variable.
calendr = calendar.Calendar()
# Apply itermonthdays() method to the above calendar by passing the given year,
# month as the arguments and store it in another variable.
rslt = calendr.itermonthdays(gvn_yr, gvn_mont)
# Iterate in the above result using the for loop.
for itr in rslt:
    # Inside the loop, print the iterator value.
    print(itr)

Output:

0
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
0
0
0

Example2:

Approach:

• Import calendar module using the import keyword.
• Give the year as static input and store it in a variable.
• Give the month as static input and store it in another variable.
• Call the Calendar() function by setting firstweekday=2 and store it in another variable.
• Apply itermonthdays() method to the above calendar by passing the given year, month as the arguments and store it in another variable.
• Iterate in the above result using the for loop.
• Inside the loop, print the iterator value.
• The Exit of the Program.

Below is the implementation:

# Import calendar module using the import keyword.
import calendar
# Give the year as static input and store it in a variable.
gvn_yr = 2012
# Give the month as static input and store it in another variable.
gvn_mont = 5
# Call the Calendar() function by setting firstweekday=2 and store it in
# another variable.
calendr = calendar.Calendar(firstweekday=2)
# Apply itermonthdays() method to the above calendar by passing the given year,
# month as the arguments and store it in another variable.
rslt = calendr.itermonthdays(gvn_yr, gvn_mont)
# Iterate in the above result using the for loop.
for itr in rslt:
    # Inside the loop, print the iterator value.
    print(itr)

Output:

0
0
0
0
0
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
0
0
0
0
0

Method #2: Using Built-in Functions (User Input)

Example1:

Approach:

• Import calendar module using the import keyword.
• Give the year as user input using the int(input()) function and store it in a variable.
• Give the month as user input using the int(input()) function and store it in another variable.
• Call the Calendar() function and store it in another variable.
• Apply itermonthdays() method to the above calendar by passing the given year, month as the arguments and store it in another variable.
• Iterate in the above result using the for loop.
• Inside the loop, print the iterator value.
• The Exit of the Program.

Below is the implementation:

# Import calendar module using the import keyword.
import calendar
# Give the year as user input using the int(input()) function and store it in a variable.
gvn_yr = int(input("Enter some random year = "))
# Give the month as user input using the int(input()) function and store it in another variable.
gvn_mont = int(input("Enter some random month = "))
# Call the Calendar() function and store it in another variable.
calendr = calendar.Calendar()
# Apply itermonthdays() method to the above calendar by passing the given year,
# month as the arguments and store it in another variable.
rslt = calendr.itermonthdays(gvn_yr, gvn_mont)
# Iterate in the above result using the for loop.
for itr in rslt:
    # Inside the loop, print the iterator value.
    print(itr)

Output:

Enter some random year = 2005
Enter some random month = 7
0
0
0
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

Calendar Module:

The calendar module allows you to output calendars like a program and includes extra calendar-related operations. Calendar module functions and classes make use of an idealized calendar, the current Gregorian calendar extended in both directions indefinitely.

iterweekdays() method:

The iterweekdays() method returns an iterator of weekday numbers for one week. The first number returned by the iterator will be the same as the firstweekday() returned number.

Syntax:

iterweekdays()

Parameters: This method has no parameters.

Return Value: Returns an iterator of weekday numbers.

Program for calendar iterweekdays() Method with Examples in Python

• Using Built-in Functions (Static Input)
• Using Built-in Functions (User Input)

Method #1: Using Built-in Functions (Static Input)

Example1:

Approach:

• Import calendar module using the import keyword.
• Set the firstweekday=0 using the Calendar() function by passing the firstweekday=0 as an argument.
• Store it in a variable.
• Apply the iterweekdays() method for the above result and store it in another variable.
• Iterate in the above result using the for loop.
• Inside the loop, print the iterator value.
• The Exit of the Program.

Below is the implementation:

# Import calendar module using the import keyword.
import calendar
# Set the firstweekday=0 using the Calendar() function by passing the
# firstweekday=0 as an argument.
# Store it in a variable.
calendr = calendar.Calendar(firstweekday=0)
# Apply the iterweekdays() method for the above result and store it in
# another variable.
rslt = calendr.iterweekdays()
# Iterate in the above result using the for loop.
for itr in rslt:
    # Inside the loop, print the iterator value.
    print(itr)

Output:

0
1
2
3
4
5
6

Explanation:

It prints the seven days of the week starting from 0

Example2:

Approach:

• Import calendar module using the import keyword.
• Set the firstweekday=2 using the Calendar() function by passing the firstweekday=2 as an argument.
• Store it in a variable.
• Apply the iterweekdays() method for the above result and store it in another variable.
• Iterate in the above result using the for loop.
• Inside the loop, print the iterator value.
• The Exit of the Program.

Below is the implementation:

# Import calendar module using the import keyword.
import calendar
# Set the firstweekday=2 using the Calendar() function by passing the
# firstweekday=2 as an argument.
# Store it in a variable.
calendr = calendar.Calendar(firstweekday=2)
# Apply the iterweekdays() method for the above result and store it in
# another variable.
rslt = calendr.iterweekdays()
# Iterate in the above result using the for loop.
for itr in rslt:
    # Inside the loop, print the iterator value.
    print(itr)

Output:

2
3
4
5
6
0
1

Explanation:

It prints the seven days of the week starting from 2