Forem: Debjoty Mitra

Seaborn - Unlock the Power of Data Visualization

Debjoty Mitra — Sat, 25 Mar 2023 12:05:22 +0000

What is Seaborn?

Seaborn is a matplotlib-based Python data visualization library. It provides a sophisticated interface for creating visually appealing and instructive statistical visuals. It has beautiful default styles, and it is also designed to work very well with Pandas data frame objects.

Installation

To install Seaborn on your system, you have to run this code on your command line:

>> pip install seaborn

Importing

To use seaborn in our code, first, we have to import it. We will import the seaborn module under the name sns (the tidy way):

Data

Now, where can we find our data to visualize? The good thing about Seaborn is that it comes with built-in data sets.

Let's talk about some plots that help us see how a set of data is spread out. These plots are:

1. displot

Now, the displot is showing our data in histogram form. We only need to pass a single column from our data frame to displot.

2. jointplot

jointplot() lets you match up two scatterplots for two sets of data by letting you choose wh*ich* parameter to compare:

“scatter”
“reg”
“resid”
“kde”
“hex”

Here are different kinds of plots we can create by changing the value of the kind attribute.

3. pairplot

pairplot will plot pairwise relationships across an entire data frame (for the numerical columns) and supports a color hue argument (for categorical columns). We just have to pass the data through the method.

4. kdeplot

kdeplots are Kernel Density Estimation plots. These KDE plots replace every single observation with a Gaussian (Normal) distribution centered around that value.

Categorical Data Plots

5. Barplot and Countplot

B*arplot*

These extremely similar plots enable the extraction of aggregate data from a categorical feature in the data. The barplot is an all-purpose plot that aggregates categorical data based on a function, by default the mean. We can use an estimator attribute to change the default. Here we are using standard deviation.

Countplot

This is essentially the same as a barplot except the estimator is explicitly counting the number of occurrences. Which is why we only pass the x value:

6. Boxplot and Violinplot

Boxplots and violinplots are two types of graphs that can be used to demonstrate the distribution of categorical data. A box plot, also known as a box-and-whisker plot, is a type of graph that displays the distribution of quantitative data in a manner that makes it easier to make comparisons between different variables or between different levels of a categorical variable. The whiskers extend to show the rest of the distribution, with the exception of points that are determined to be "outliers" using a method that is a function of the interquartile range. The box displays the quartiles of the dataset, while the whiskers show the rest of the distribution.

B*oxplot*

Violinplot

A violin plot plays a similar role as a box and whisker plot. It shows the distribution of quantitative data across several levels of one (or more) categorical variables such that those distributions can be compared. Unlike a box plot, in which all of the plot components correspond to actual data points, the violin plot features a kernel density estimation of the underlying distribution.

Machine Learning Process

Debjoty Mitra — Wed, 01 Feb 2023 19:40:08 +0000

Introduction

To build a machine-learning model, we normally follow a step-by-step process. We can divide all the steps into three groups. Those are:

Data Pre-Processing
Modeling
Evaluation

Data Pre-Processing

After collecting the data, the first thing we have to do is clean the data. Data cleaning is the process of fixing or removing incorrect, corrupted, incorrectly formatted, duplicate, or incomplete data within a dataset. After cleaning the data, we have to split the data into training & test sets. We do it to avoid overfitting. I will explain it more in the upcoming blogs. Now we have to do feature scaling. This helps to ensure that features with different units of measurement or scales do not dominate the model training process.

Modeling

Now comes the most interesting part, model building. We have to build a model and train it using the training set that we got after splitting our data. We have to decide which model we should use according to the data we have. After completing the training part, now our model is ready to make predictions.

Evaluation

And finally, we move on to evaluations. We will calculate some performance metrics and make a verdict about our model, whether it's a good-fitting model and if it works for our data or not. And this is a very important step to make sure that the models we build really serve the purpose that they're designed for.

Introduction to Machine Learning

Debjoty Mitra — Wed, 23 Nov 2022 11:49:25 +0000

Introduction

In 1959, Arthur Samuel defined machine learning as follows:

“Field of study that gives computers the ability to learn without being explicitly programmed”

"Explicitly programmed" in this case means that we don't have to code everything for our machine to do a task. We will show our machine some examples, and then it will figure things out on its own.

Examples

Now we will see some examples of machine learning that we use in our daily life maybe without even knowing it.

Virtual Assistants

Smartphone assistants like Apple Siri uses machine learning to recognize speech, answer questions and do other smart things. Assistants like Siri and Google Assistant are powered by automatic speech recognition and Natural Language Processing (NLP).

Self Driving Car

One of the most exciting and cutting-edge uses of machine learning algorithms is in autonomous vehicles. Self driving carr can significantly reduce traffics, and most importantly they can reduce road accidents

Spam or Fraud Detection

Machine learning is used in every spam filter, such as in Gmail.

ML systems are also used by credit card companies and banks to automatically detect fraudulent behavior.

How Machines Learn?

There are basically two types of ways our machine can learn:

Supervised Learning

Used most in real-world applications
Rapid advancement

In this type of learning, we give the machine some input and some labeled output. This input data will help the machine to train itself so that it can predict the outcome as accurately as possible as soon as it gets input. In the Coursera video, we saw an example of regression where the task is to predict a number. There is also a second major type of supervised learning which is called classification.

Unsupervised Learning

In this type of learning, we give the machine some data that is not tagged or labeled. The idea is that the computer will be compelled to construct a succinct representation through mimicry, a key way of learning in humans, and then use that for creative output.

Why Machine Learning?

It allows for building practical systems for real-world applications that couldn't be solved otherwise.
Learning is wildly regarded as a key approach to building general-purpose artificial intelligence systems.
The science and engineering of machine learning offer insights into human intelligence.

Graph and Trees - Basic

Debjoty Mitra — Tue, 08 Nov 2022 17:03:52 +0000

Graph

A graph is a non-linear data structure composed of nodes and edges. The nodes are also known as vertices; edges are lines or arcs connecting any two nodes in the graph. There are two types of representation techniques for a graph. Those are:

Matrix: Even though we won't be using it frequently, it's still helpful to have some familiarity with it.
List:
- Arrays of Vectors
- Vectors of Vectors

Vertices and Edges

This is a graph with five Vertices. We can also call them Nodes. If we connect the vertices with lines, then the lines will be called Edges.

Basically, all the edges above are bidirectional. It means that we can go from 1 to 3 and also from 3 to 1. We can make an edge unidirectional by giving it a detection using an arrow.

Tree

A tree is a graph that has no cycles in it.

This is not a tree because there is a cycle between 1, 2, and 3. If we remove that edge, then it will become a tree.

If a tree has n nodes, then the number of edges it will have is n-1.

Matplotlib - Visualization with Python

Debjoty Mitra — Sun, 06 Nov 2022 09:53:57 +0000

Introduction

Matplotlib is the “grandfather” library of data visualization with Python. John Hunter created it. He created it to try to replicate MatLab’s (another programming language) plotting capabilities in Python. So if you are familiar with MatLab, matplotlib will feel natural to you. It is an excellent 2D and 3D graphics library for generating scientific figures.

Matplotlib allows you to create reproducible figures programmatically. Let’s learn how to use it! Before continuing this lecture, I encourage you just to explore the official Matplotlib web page: http://matplotlib.org/

Installation

To install matplotlib on your system, you have to run this code on your command line:

>> pip install matplotlib

Importing

To use matplotlib in our code, first, we have to import it. We will Import the matplotlib.pyplot module under the name plt (the tidy way):

Basic Example

Let’s begin our journey with a very simple example using two numpy arrays. You can also use lists, but you’ll most likely be passing NumPy arrays or Pandas columns (which also behave like arrays).

We can create a very simple line plot using the following code. Here, we are creating a plot and also giving the titles:

Creating Multi plots on the Same Canvas

The subplot() method requires three parameters to specify the figure's layout. The first and second arguments indicate rows and columns, which are used to structure the layout. The third input is the current plot's index.

Matplotlib Object-Oriented Method

Now that we’ve seen the basics, let’s break it all down with a more formal introduction of Matplotlib’s Object Oriented API. This means we will instantiate figure objects and then call methods or attributes from those objects.

The main idea in using the more formal Object Oriented method is to create figure objects and then just call methods or attributes off of that object. This approach is nicer when dealing with a canvas that has multiple plots on it.
To begin, we create a figure instance. Then we can add axes to that figure:

If you understand the fifth line, then you are good to go. The code is a little more complicated, but the advantage is that we now have full control over where the plot axes are placed, and we can easily add more than one axis to the figure:

subplots()

With the subplot() function, we can draw multiple plots in one figure. This object will act as a more automatic axis manager.

Then, when you make the subplots() object, you can tell it how many rows and columns you want, and it will create it according to your desire.

Now, let’s see what is actually stored inside the variable axis

Basically, the variable axes is an array of axes to plot on. We can also iterate through this array and do whatever we want, like that:

A common issue with matplolib is overlapping subplots or figures. We can use the fig.tight_layout() or plt.tight_layout() method, which automatically adjusts the positions of the axes on the figure canvas so that there is no overlapping content:

Figure size, aspect ratio, and DPI

Matplotlib allows the aspect ratio, DPI, and figure size to be specified when the Figure object is created. You can use the figsize and dpi keyword arguments.

figsize is a tuple of the width and height of the figure in inches
dpi is the dots-per-inch (pixel per inch).

For example:

The same arguments can also be passed to layout managers, such as the subplots function:

Saving figures

Matplotlib can generate high-quality output in a number of formats, including PNG, JPG, EPS, SVG, PGF, and PDF. To save a figure to a file, we can use the savefig method in the Figure class:

Here we can also optionally specify the DPI and choose between different output formats:

Legends

You can use the label=“label text” keyword argument when plots or other objects are added to the figure, and then use the legend method without arguments to add the legend to the figure:

Observe how our legend overlaps with a portion of the actual plot! The legend function accepts the keyword argument loc, which specifies where in the figure the legend should be drawn. The permitted values of loc are the numeric identifiers for the various locations where the legend can be drawn. I suggest you see the documentation page for information. These are some of the most frequent loc values:

Setting colors, linewidths, linetypes

Matplotlib gives you a lot of options for customizing colors, line widths, and line types. There is a basic MATLAB-like syntax.

Colors with MatLab-like syntax

With matplotlib, we can define the colors of lines and other graphical elements in a number of ways. First of all, we can use the MATLAB-like syntax where 'b' means blue, 'g' means green, etc. The MATLAB API for selecting line styles is also supported, where, for example, 'b.-' means a blue line with dots:

Colors with the color = parameter

With the color and alpha keyword arguments, we can also define colors by their names or RGB hex codes, and we can add an alpha value if we want to. Alpha indicates opacity.

Line and marker styles

To change the line width, we can use the linewidth or lw keyword argument. The line style can be selected using the linestyle or ls keyword arguments:

fig, ax = plt.subplots(figsize=(12,6))

ax.plot(x, x+1, color="red", linewidth=0.25)
ax.plot(x, x+2, color="red", linewidth=0.50)
ax.plot(x, x+3, color="red", linewidth=1.00)
ax.plot(x, x+4, color="red", linewidth=2.00)

# possible line style options ‘-‘, ‘–’, ‘-.’, ‘:’, ‘steps’
ax.plot(x, x+5, color="green", lw=3, linestyle='-')
ax.plot(x, x+6, color="green", lw=3, ls='-.')
ax.plot(x, x+7, color="green", lw=3, ls=':')

# custom dash
line, = ax.plot(x, x+8, color="black", lw=1.50)
line.set_dashes([5, 10, 15, 10]) # format: line length, space length, ...

# possible marker symbols: marker = '+', 'o', '*', 's', ',', '.', '1', '2', '3', '4', ...
ax.plot(x, x+ 9, color="blue", lw=3, ls='-', marker='+')
ax.plot(x, x+10, color="blue", lw=3, ls='--', marker='o')
ax.plot(x, x+11, color="blue", lw=3, ls='-', marker='s')
ax.plot(x, x+12, color="blue", lw=3, ls='--', marker='1')

# marker size and color
ax.plot(x, x+13, color="purple", lw=1, ls='-', marker='o', markersize=2)
ax.plot(x, x+14, color="purple", lw=1, ls='-', marker='o', markersize=4)
ax.plot(x, x+15, color="purple", lw=1, ls='-', marker='o', markersize=8, markerfacecolor="red")
ax.plot(x, x+16, color="purple", lw=1, ls='-', marker='s', markersize=8, markerfacecolor="yellow", markeredgewidth=3,markeredgecolor="green");

Control over axis appearance

In this section, we will look at controlling axis sizing properties in a matplotlib figure.

Plot range

We can configure the ranges of the axes using the set_ylim and set_xlim methods in the axis object, or axis('tight') for automatically getting “tightly fitted” axes ranges:

Special Plot Types

There are many specialized plots we can create, such as bar plots, histograms, scatter plots, and much more. Most of these types of plots we will actually create using Seaborn, a statistical plotting library for Python. But here are a few examples of these types of plots:

Pandas - Data Manipulation and Analysis

Debjoty Mitra — Fri, 28 Oct 2022 17:50:38 +0000

Introduction

Python's Pandas package is used to manipulate data collections. It offers tools for data exploration, cleaning, analysis, and manipulation. Wes McKinney came up with the name "Pandas" in 2008, and it refers to both "Panel Data" and "Python Data Analysis.”

How to Install Pandas

To install Pandas, first, make sure that Python and Pip is already installed in your system. If they are installed, then you can install Pandas just by running this command on the command line.

>> pip install pandas

You can use other Python distributions like Spyder or Anaconda where pandas are already installed.

Write your first code using Pandas

To use Pandas in our code, first, we have to import it. Here we are importing pandas as pd. Here, pd is an alias for panda.

Series

A series in pandas is like a column in a table that can hold data like a one-dimensional array of any type. To create a Pandas series, we can write this code:

Here we have used a method called Series() to convert a list into a series. After that, we can print the series using print() function. If we observe the output, we will see that there are 5 rows and 2 columns. In the end, it’s showing the data type of the elements in the list that we have converted into a series. The first column is the column of labels. If nothing else is specified, the values are labeled with their index number. The first value has index 0, second value has index 1 etc. This label can be used to access a specified value.

Now, its clear that we can use use the labels as an index and access a specific value using it. The fun thing is, we can name our own labels using the index argument.

After creating our labels, we can access an item by referring to the label like we access a dictionary value using the key:

Key/Value Objects as Series

You can also use a key-value object, like a dictionary, when creating a series.

Use the index option to specify only the words you wish to be included in the Series, leaving out the rest of the words in the dictionary.

Now let's see what happens when we add two series.

It is creating a new series by adding the same labeled data together and converting them into floats. If the same index is missing, then the output will be NaN.

DataFrames

A Pandas DataFrame is a 2-dimensional data structure, like a 2-dimensional array, or a table with rows and columns. To understand it better, first, let’s compare it with the pandas series.

The first visible difference here is that a series has a specific data type, but a data frame doesn’t.

Dictionary and Data Frame

Here we can see that the keys of the dictionary are used as the titles of the columns, and the lists are the data of the columns. Now, what is happening here is that we are passing a list and it is creating a data frame. It also defines its index and column names on its own. If we want to use our own name as an index or column name, we have to pass it as an argument through the DataFrame() method.

Generate Data Frame

In the example above, we are passing a 2D array, index, and column name. After that, the DataFrame() method automatically allocates the index and column name.

Selection and Indexing

Firstly, DataFrame columns are just Series:

Now, let’s learn the various methods to grab data from a DataFrame

We can grab any column by using the column name. To access multiple columns, we have to pass a list of column names like that:

We can also use the SQL Syntax but it is not recommended as it creates confusions:

Creating a new column:

We can add a new column to our DataFrame like below. We can assign either Array or Series to define the new column. In the example below, we are adding two columns, which are basically two series, and assigning a new column named ‘new’:

Removing Columns

We have to use.drop() method to drop a column or row. Here axis=0 means row and axis=1 means column. We have to mention it if we want to remove the column. The default value is 0.

But there is a problem. If we try to print df again, we will see that column new is still there.

But why? Because to remove the column completely from the DataFrame, we have to use the inplace attribute. The Python developers kept that feature so that we do not have to face unwanted data loss.

Congratulations! The new column is completely removed from the DataFrame. We can also drop a row by changing the axis from 1 to 0:

Locate Rows

We already know that a dataframe is like a table with rows and columns. If we want to display or store a specific row, we have to use the loc method:

Alternatively, you can choose based on position rather than the label using iloc:

We can also select a subset of rows and columns by the following method:

Conditional Selection

An important feature of pandas is conditional selection using bracket notation, very similar to Numpy:

Here we can see a truth table based on the conditions we have given. When a cell satisfies our conditions, it's giving True. Otherwise, it's giving false. Now, if we want to print the value instead of true or false, we can write our code like this:

Now, it is printing only the values that satisfy our conditions.

What if our condition is only based on a specific column and we want to print the values according to the data of that column? In that case, we have to mention that specific column using this notation:

For printing a specific column of our new filtered data frame, we just have to mention this like that:

For two conditions, you can use | and & with parenthesis:

More Index Details
Let's discuss some more features of indexing, including resetting the index or setting it to something else. We'll also talk about index hierarchy!

By using the .split() function, we can create a new column. It will create a list, and then we will create a new column using that:

We can also set an existing column as an index by using the set_index() method and passing the name of the column through it:

Again, we have to use the inplace argument if we want to make the change permanent.

Missing Data

Let's show a few convenient methods to deal with missing data in pandas:

First, let’s create a new data frame using a dictionary:

Here what we are doing is, we are intentionally putting some nan data to our data frame and assuming that those are missing data.

If we want to remove those missing values from our data frame, there is a method called .dropna(). It will remove all the rows that contain at least one missing data point. We can use the asix argument if we check the missing data column-wise.

We can use the thresh attribute if we need to keep some missing values by mentioning how many missing values we will consider:

Here, thresh=2 means - keep only the rows with at least 2 non-NA values.

If we want to fill our missing values with something else, we have to write our code like that by using the .fillna() method:

Sometimes we have to fill in our missing data using a mean value. For that we can code like that:

Groupby

Groupby allows you to group together rows based on a column and perform an aggregate function on them. Here aggregate function means a function that takes some data and returns may be the sum of those data or the mean value of those data.

Firstly, let us create a data frame using a dictionary:

Now you can use the .groupby() method to group rows together based off of a column name. For instance, let's group based on company. This will create a DataFrameGroupBy object:

You can save this object as a new variable:

And then call aggregate methods on the object:

Here, we are using the variable to call aggregate methods on the object. We can also do this directly like that:

More examples of aggregate methods:

You can also do things such as max and min.

Some other useful aggregate functions that you may find yourself doing are things such as count which just counts the number of instances or column. In this case it was able to return the person column because it's able to count how many instances of a person occur in that column or company. So we have two people and they have two sales each and that's makes sense.

One last useful thing I want to show you with groupby is the describe() method and that gives you a bunch of useful information all at once.

And if you don't like this format, you can actually transpose this. So, you can say something like:

So, whatever format you like better you can describe to that and then you can actually just call column names of this if you're just interested in a single column.

NumPy - Numerical Python

Debjoty Mitra — Mon, 17 Oct 2022 18:55:56 +0000

Introduction

NumPy (or Numpy) is a Linear Algebra Library for Python, the reason it is so important for Data Science with Python is that almost all of the libraries in the PyData Ecosystem rely on NumPy as one of their main building blocks. Numpy is also incredibly fast, as it has bindings to C libraries.

It is highly recommended you install Python using the Anaconda distribution to make sure all underlying dependencies (such as Linear Algebra libraries) all sync up with the use of a conda install.

Installation Instructions

It is highly recommended you install Python using the Anaconda distribution to make sure all underlying dependencies (such as Linear Algebra libraries) all sync up with the use of a conda install. If you have Anaconda, install NumPy by going to your terminal or command prompt and typing:

conda install numpy

If you do not have Anaconda and can not install it, please refer to Numpy’s official documentation on various installation instructions.

How to code using NumPy?

To use NumPy in our program, first, we have to import it. To do this, we have to write the following line:

import numpy as np

Convert a 1D list to a 1D array using NumPy:

Convert a 2D list to a 2D array:

numpy.arrange()

np.arrange() is like range() that we use in loops. We can write this in three ways:

arange(stop): Values are generated within the half-open interval [0, stop) (in other words, the interval includes the start but excludes the stop).

arange(start, stop): Values are generated within the half-open interval [start, stop).

arange(start, stop, step) Values are generated within the half-open interval [start, stop), with spacing between values given by step.

Zeros and Ones

np.zeros() return a new array of given shape and type, filled with zeros.

np.ones() return a new array of given shapes and types, filled with zeros.

numpy.linspace()

numpy.linspace() returns evenly spaced numbers over a specific interval.

numpy.eye()

It returns a 2-D array with ones on the diagonal and zeros elsewhere.

Create an array with random numbers

We can use the random module to create an array with random numbers.

Change the shape of an array

We can reshape our array by using reshape(). But we have to make sure that the dimension is the same.

Find the maximum and minimum of an array and their index

Find the shape and data type of an array

It will return a tuple with the dimensions of the array.

Array Indexing (1D Array)

NumPy array indexing is similar to list indexing.

There is a problem in slicing the array. To understand it better, let’s see an example:

From the photo above, we can see that, when you edit c, it also affects b. It is happening because in the 3rd line we are not copying the array. Instead of copying, it only shows the live view of the array b. So, to fix this issue what we can do is we can use a method called .copy().

Now, changing c is not affecting b.

Array Indexing (2D Array)

This code will help you to understand 2D array indexing and slicing. Slicing is almost similar to the 1D array. Just you have to think row and column-wise.

We can also filter our data using conditions like these:

NumPy Operations

We can add two arrays like a normal variable and what will happen is all the elements will be added with the corresponding other array elements. Other operators will act like the same way.

Introduction to Python

Debjoty Mitra — Sat, 15 Oct 2022 12:47:33 +0000

What is python?

Python is a popular programming language. It was created by Guido van Rossum, and released in 1991. It is used for web development (server-side), software development, mathematics, and system scripting. Python is a dynamic, interpreted (byte code-compiled) language. There are no type declarations of variables, parameters, functions, or methods in the source code. This makes the code short and flexible, and you lose the compile-time type checking of the source code. Python tracks the types of all values at runtime and flags code that does not make sense as it runs.

First Python Program

Most programmers start their programming journey by printing “Hello, World!” in the console. It is so much popular that now it became a tradition. So, we will also start by running the hello world program.

>>> print("Hello, World!")
Hello, World!

Here print() is a function and “Hello, World!” . We are passing the string through the print()

function and the function is printing the given string in the display.

Python Syntax

Python’s syntax is so much more readable. It was actually designed for readability and has some similarities to the English language with influence from mathematics.

Python syntax can be executed by writing directly in the Command Line:

>>> print("Hello, World!")
Hello, World!

Or by creating a python file on the server, using the .py file extension, and running it in the Command Line:

C:\Users\Your Name>python myfile.py

Python Indentation

Unlike some other programming languages, python uses indentation to indicate a block of code.

If you write this code, you will get an error:

if 5 > 2:
print("Five is greater than two!")

Because this code is not properly indented. The number of spaces that you want to give is totally up to you. Giving 4 spaces is a good practice. You also make sure that you are not doing unnecessary indentation otherwise again you will get an error.

if 5 > 2:
 print("Five is greater than two!")
        print("Five is greater than two!")

Comments

Sometimes you need to add some text to your code to describe how your code is working. In that case, you have to use the proper commenting rule. Comments start with a #, and Python will render the rest of the line as a comment:

#This is an example of a comment
#This is a comment
print("Like and share this post")

Comments can also be placed at the end of a line, and Python will ignore the rest of the line:

print("Like and share this post") #This is an example of a comment

You can also comment out even multiple lines of code to prevent Python from executing:

#print("Follow Me")
print("Hi there!")

you can add a multi-line string (triple quotes) in your code, and place your comment inside it:

"""
This is a multiline
comment.
"""
print("Hello, World!")

C++ STL in a Nutshell

Debjoty Mitra — Wed, 14 Sep 2022 09:35:25 +0000

I had written these codes as a note when I was learning STL for competitive programming. For better understanding, try to read the comments written with codes.

Pair

pair <int,string> pr;
pr = make_pair(2,"string"); // Initializing Method 1
pr = {2,"Hello"}; // Initializing Method 2 
pair <int,string> &pr2 = pr; // Used Reference // Not copy
pr.first = 10; // Initializing Method 3

pii pairArray[3]; // Array of Pairs
fo(i,3) cin>>pairArray[i].first>>pairArray[i].second;
swap(pairArray[0],pairArray[2]);
fo(i,3) cout<<pairArray[i].first<<" "<<pairArray[i].second<<endl;

Vector

vector <int> v(5,3); // 3 3 3 3 3
v.push_back(1); // O(1) // 3 3 3 3 3 1
v.pop_back(); // O(1) // 3 3 3 3 3

vector <int> v1 = v; // O(n) // Try to pass by ref in fuction call
vector <int> &v1 = v; // Used Reference // Not copy
v[0] = 200;
cout<<v1[0]; // 200

vector <pair<int,int>> vp = {{1,2},{3,4},{5,6}};
fo(i,3) cout<<vp[i].first<<" "<<vp[i].second<<endl;

vector<vector<int>> vec(n, vector<int> (m, 0));

Set

// Stores in sorted order
set <string> st;
s.insert("A") // Initializing
auto it = s.find("A") // Returns an iterator
if(it!=s.end()) s.erase(it); // Erase takes an iterator
s.erase("A");

// unordered_set
// Not sorted
unordered_set <int> st;
st.insert(100); // O(1)
auto it = st.find(100); // O(1)

Map

// Map - Sorted acording to key
// Unordered map - Not sorted
// Uses Red–black tree to store data
// Map is vector of pairs

map <int, string> mis;
mis[3] = "a"; // O(log(n)) // Insertion method 1
mis.insert({2,"b"}); // Insertion method 2
for(auto it:mis) cout<<it.first<<" "<<it.second<<endl;

auto it = mis.find(3); // O(log(n))
if(it == mis.end()) cout<<"Not available";
else cout<<(*it).second;

map <string,string> mss;
mss["abc"] = "abc" // O(s.size()*log(n))

// Unordered Map - Not Sorted
// Uses hash table
// Any that can be compared, can be used in map
// Pair can't be used in unordered_map
unordered_map <int,int> mp;
mp[3] = 3;
mp.insert({1,1});
mp[2] = 2;
for(auto x:mp){
    cout<<x.first<<" "<<x.second<<endl;
}
cout<<mp[4]<<endl;
//Output
// 2 2
// 1 1
// 3 3
// 0

Stack

// LIFO - Last in Fast out
// Accessable - Size and Top Element
// Operation - Push, Pop, See

stack <int> stk;
stk.push(1);
while(!stk.empty()){
        cout<<stk.top()<<endl;
        stk.pop();
}

Queue

// FIFO - First in First out
// Operation - Push, Pop, See

Bitwise Cheat Sheet (C++)

Debjoty Mitra — Wed, 14 Sep 2022 07:35:52 +0000

Operators

&      (and)     - (1&0)  = 0       // 0 when one of them 0
|       (or)     - (1|0)  = 1       // 0 when both 0
^      (xor)     - (1^0)  = 1       // 0 when both same
<< (left shift)  - (1<<n) = 2^n     // Multiply by 2
>> (Right shift) - (1>>n) = 1/(2^n) // divided by 2

Basics of Bit

// 32 bit - 2^32-1 Numbers
// a 1 2 3 4 5 6 b - a:Most significant bit, b:Least significant bit
// Set bit - 1
// Unset bit - 0

//     10011101
//   & 00010000   1 << 4
//  -------------------
//     00010000

Toggle bits

void printBinary(int n){
    for(int i=9;i>=0;i--){
        cout<<((n>>i)&1);
    }
    cout<<endl;
}
void solve(){
    int a = 9;
    printBinary(a);
    int i = 3;
    if((a&(1<<i))!=0){
        cout<<"Set bit"<<endl;
        printBinary((a&(~(1<<i))));
        printBinary((a^(1<<i)));
    }else{
        cout<<"Unset bit"<<endl;
        printBinary((a|(1<<i)));
    }
}

Set bit counter

int cnt = 0;
for(int i=20;i>=0;--i){
    cnt+=((a>>i)&1);
}
cout<<cnt;
cout<<__builtin_popcount(a)<<endl;
cout<<__builtin_popcountl((1LL<<50)-1)<<endl;

Remove LSB’s

printBinary((a&(~((1<<(i+1))-1))));

//    1101011001
//  & 1111100000 - 0000011111 - 0000100000 - 1<<5
// ---------------
//    1101000000

Remove MSB’s

printBinary((a&(((1<<(i+1))-1))));

//    1101011001
//  & 0000011111 - 0000100000 - 1<<5
// ---------------
//    0000011001

Power of two

//   000100000 - Power of two
// & 000011111 - Power fo two-1
// -------------
//   000000000

if(n&(n-1)) cout<<"Not power of two.";
else cout<<"Power of two";

XOR Basics

// 0^0 = 0
// 0^1 = 1
// 1^0 = 1
// 1^1 = 0
// x^x = 0
// x^0 = x

Swap

a = a ^ b;
b = a ^ b;
a = a ^ b;

Head Recursion

Debjoty Mitra — Wed, 14 Sep 2022 06:18:29 +0000

When a recursion doesn’t need to do anything in the calling times, it only needs to do things in the returning time, then it is called a head recursion.

void fun(int n){
    if(n>0){
        fun(n-1);
        cout<<n<<endl;
    }
}

Same code using a loop:

void fun(int n){
    int i=1;
    while(i<=n){
        cout<<i<<endl;
        i++;
    }
}

As your can see from here, it is difficult to implement a head recursion using a loop. So, it is better not to write it in loops.

Tail Recursion

Debjoty Mitra — Wed, 14 Sep 2022 05:50:21 +0000

If in a recursive function, the recursive call is the last statement of the function, then it is called a Tail Recursion. In returning time, it doesn’t have to perform anything at all.

void fun(int n){
    if(n>0){
        cout<<n<<endl;
        fun(n-1);
    }
}

Same code using a loop:

void fun(int n){
    while(n>0){
        cout<<n<<endl;
        n--;
    }
}

To conclude, the time complexity of both codes is the same. But in recursive calls, as it uses stacks, it is actually taking extra space. So, the space complexity for the loop is O(1), but for the tail recursion, it is O(n). So, it is better to use a loop if it is a tail recursion.

Forem: Debjoty Mitra

Seaborn - Unlock the Power of Data Visualization

What is Seaborn?

Installation

Importing

Data

1. displot

2. jointplot

3. pairplot

4. kdeplot

Categorical Data Plots

5. B*arplot and Countplot*

6. B*oxplot and Violinplot*

Machine Learning Process

Introduction

Data Pre-Processing

Modeling

Evaluation

Introduction to Machine Learning

Introduction

Examples

Virtual Assistants

Self Driving Car

Spam or Fraud Detection

How Machines Learn?

Supervised Learning

Unsupervised Learning

Why Machine Learning?

Graph and Trees - Basic

Graph

Vertices and Edges

Tree

Matplotlib - Visualization with Python

Introduction

Installation

Importing

Basic Example

Creating Multi plots on the Same Canvas

Matplotlib Object-Oriented Method

subplots()

Figure size, aspect ratio, and DPI

Saving figures

Legends

Setting colors, linewidths, linetypes

Control over axis appearance

Further reading

Pandas - Data Manipulation and Analysis

Introduction

How to Install Pandas

Write your first code using Pandas

Series

DataFrames

NumPy - Numerical Python

Introduction

Installation Instructions

How to code using NumPy?

Convert a 1D list to a 1D array using NumPy:

Convert a 2D list to a 2D array:

numpy.arrange()

Zeros and Ones

numpy.linspace()

numpy.eye()

Create an array with random numbers

Change the shape of an array

Find the maximum and minimum of an array and their index

Find the shape and data type of an array

Array Indexing (1D Array)

Array Indexing (2D Array)

NumPy Operations

Introduction to Python

What is python?

First Python Program

Python Syntax

Python Indentation

Comments

C++ STL in a Nutshell

Bitwise Cheat Sheet (C++)

Head Recursion

Tail Recursion

5. Barplot and Countplot

6. Boxplot and Violinplot