DEV Community: Abhijit Tripathy

Anyone looking for graphics and content related work ? We can help

Abhijit Tripathy — Fri, 10 Dec 2021 10:46:30 +0000

Studies say a good graphic illustration along with catchy content can increase your client base by 13%.

We provide a one-stop destination to help you scale up your content needs. We also help corporates with illustrative graphic works & faster content delivery. Here are a few on-demand services that we provide,

Content Strategy
Content Management
Graphic Designing
Illustrative Graphic Designing
Blog Writing (Regular Posts)
Video Editing

We would be glad enough to be a partner in your goal to improve your business growth and sales.

Eagerly waiting for your responses.

A snapshot on ML & DL

Abhijit Tripathy — Wed, 03 Mar 2021 02:30:02 +0000

The following blog contains brief notes on “Machine learning and Deep Learning” as a part of AI (Augmented Intelligence)

We came to know that Computers can have the vision to watch/sense and learn from humans, then try to mimic the action with utmost accuracy. So we have three queries now,

a) How computer watch/sense
b) How computer learn
c) How computer mimic

The first question can be answered by the “Computer Vision and Robotics”, we use different sensors and hardware along with support precision making programs/software to correctly input data to the computer/system.

The second question starts with two things available as a parameter - The first one is the “data” that we have collected (From the solution of the first question) and the second one is “patterns and inference*”.

Now coming to the definition,

Machine Learning is the study of algorithms and mathematical/statistical models, to find out some pattern and perform a certain task without being explicitly instructed”

I have underlined four important terms, I am not going to explain them step by step, but I will explain what exactly happens and the mechanism we generally follow. (Please search for the terminology if you are unable to understand)

So we have a set of data, and we choose a random sample(most preferable Stratified Random Sample) of data as “Training Data”, now comes the actual work of designing an algorithm and feeding it to the system as some sort of “Code”. Our training data is the input of the algorithm and we get a mathematical/statistical model as output(say P). Over this core layer of data, Algorithm and output, we have a second layer of decision making and task performing programs designed for a specific work, that takes P as input and performs the task. Then comes the answer for the third question, how computers mimic, “Robotics and Expert System”

Well, arguably, an expert system is a cover layer for “Machine Learning and Deep Learning”, because that includes programs to choose between better ML Algorithm to perform the task, briefly, it emulates the decision-making ability of human expert.

So basically, we have the following outcome till this part of the text,

Before explaining that, we have a new terminology - “Neural Networks”. Most of you might know about what a neuron is, well that’s a group of cells responsible for the transfer, modification and response of information inside the human body from the human brain to another part of the organs. In a similar manner, neural networks are programs designed in such a way that the system can learn and further improve its performance like a human body does. As this is the first assignment, I am not discussing the technicalities involved in details.

Deep Learning is a subset of machine learning, focused on developing the ML Algorithm into layers of data and extract a broader sense of details(technically known as features and attributes) for a more precise and accurate prediction or learning depending upon the target attribute/feature

Forget the definition, lets make that simpler,
We are giving the system this input as an image. Let's see what ML and DL algorithms will predict.

ML Algorithm - 4 leg, 1 tail, 2 horns, 2 ears, size - X
DL Algorithm - 4 leg, 1 tail, 2 horns, 2 ears, size - X, head size: body size = P:Q, 20% black spot, 80% white , cluster of black spot near the neck is more, legs have less amount of black spot

You must be thinking, how does that even matter? ML Algorithm output is sufficient to identify it’s a cow, isn’t it?
Let's have two images to compare,

Your ML Algorithm may fail to distinguish and categorize these two as different(provided the size is the same) but the DL will definitely predict the correct answer because each of the pictures has cows with different ratio of black spot and white spot in their body.

[ Arguably and Technically this is a wrong example, it is meant to just give an idea that DL is nothing but just an extension and enhancement of ML]

Approximation Algorithms (Introduction)

Abhijit Tripathy — Tue, 23 Feb 2021 02:28:43 +0000

In this article, we will be exploring an interesting as well as a deep overview of Approximation Algorithms, but before that, we will be discussing some important terms.

Optimization Problems

In computer science many a time we come across optimization problems, where we have to optimize a certain variable in accordance with some other variables. Optimization means finding a maximum or minimum.
For example,

Finding the shortest path between two vertices in a graph.
Finding the minimum number of colours needed to colour a graph, etc.

Decision Problems

These are a little bit different from the Optimization problems. In this type of problems, the main target is to find whether a solution exists or not, just like a typical yes or no question.
For example,

Checking if a graph is Hamiltonian
Checking whether a cycle exists in a Linked List, etc.
Programming and mathematical problems that we have observed in daily life can be categorized into two classes problems,
P class
NP class

P class

The class P consists of those problems that are solvable in polynomial time by the turing machine, i.e. these problems can be solved in time O(n^k) in worst-case, where k is constant.These problems are also known as tractable.

An algorithm A is a polynomial time algorithm, if there exists a polynomial p(n) such that the algorithm can solve any instance of size n in a time O(p(n)).
Algorithms such as Matrix Chain Multiplication, Single Source Shortest Path, All Pair Shortest Path, Minimum Spanning Tree, etc. run in polynomial time.

NP class

NP is the class of decision problems for which it is easy to check the correctness of a claimed answer, with the aid of a little extra information. NP consists of those problems that are verifiable in polynomial time. Hence, we aren’t asking for a way to find a solution, but only to verify that an alleged solution really is correct.

Every problem in this class can be solved in exponential time using exhaustive search.
Problems such as travelling salesperson, optimal graph colouring, Hamiltonian cycles etc for which no polynomial-time algorithms is known, are classified as NP-complete problems.

Approximation Algorithms

The formal definition says,

Given an optimization problem P, an algorithm A is said to be an approximate algorithm for P, if for any given instance I, it returns an approximate solution i.e. a feasible solution.

An Approximation Algorithm is a way of approach NP-completeness for any optimization problem. This does not guarantee the best solution. The main purpose of an approximation algorithm is to come as close as possible to the optimum value at the most polynomial time. Such algorithms are called approximation algorithms.

For example -For the travelling salesperson problem, the optimization problem is to find the shortest cycle, and the approximation problem is to find a short cycle.

Some famous problems of Approximation Algorithms

Let's discuss some famous Approximation Algorithms with their problem statements,

The Vertex Cover Problem

Problem Statement
Given an undirected graph, the vertex cover problem is to find a minimum size vertex cover.
As the name suggests, A vertex cover of an undirected graph is a subset of its vertices such that for every edge (x, y) of the graph, either x or y is in the vertex cover.
This problem is an NP-complete problem and can be solved approximately i.e. no polynomial time solution(unless P = NP).

1) Initialize the result as an empty list {}
2) Consider a set of all edges in a given graph.  Let the set be E.
3) while E is not empty
    a) Pick an arbitrary edge (x, y) from set E and add x and y to result
    b) Remove all edges from E which are either incident on x or y.
4) Return result

The time complexity of the above algorithm is O(V+E) where V is the number of vertices in the graph and E is the number of edges.

The Travelling Salesman Problem

Problem Statement
Given a set of cities and the distance between every pair of cities, the problem is to find the shortest possible route that visits every city exactly once and returns to the starting point.

This problem can be converted into a graph problem, which has V nodes(i.e. number of cities) and the cost matrix will hold the edge weights(i.e. the distance between any two cities).
The problem is a famous NP-hard problem. There is no polynomial-time to know a solution to this problem.

A naive approach to solve the problem can be,

1) Consider city 1 as the starting and ending point.
2) Generate all (V-1)! Permutations of cities.
3) Calculate cost of every permutation and keep track of minimum cost permutation.
4) Return the permutation with minimum cost.

The above algorithm works in O(V!) time complexity, where V is the number of vertices in the graph.

There are other approaches using Bitmasking and Dynamic Programming to solve in O(V^2 * 2^V) time complexity.
Branch and Bound can be one approach in finding a solution for this NP-Hard problem.

This problem can be easier to approximate if the edge weights of the graph follow a triangle inequality, which means w(u,v) <= w(u,x) + w(x,v), i.e. distance of city u to city v is less than the sum of the distance of city u to city x and city x to city v. This problem is also known as Metric TSP, which is an approximate version of the problem. This is still NP-Hard, but we can approximate the solution.

The Bin Packing Problem

Problem Statement
Given n items of different weights and bins each of capacity c, assign each item to a bin such that number of total used bins is minimized. It may be assumed that all items have weights smaller than bin capacity.
In computational mathematics, this problem is a NP Hard problem and the decision problem version of the same is NP Complete.

This problem has been studied widely and can be solved in many approximation techniques like - Next-Fit (NF), Next-k-Fit (NkF), First-Fit (FF), Best-Fit (BF), Worst-Fit (WF), First Fit Decreasing (FFD) etc.

The best time complexity can be O(NlogN) for this.

Examples of Approximation Algorithms

The approximation algorithms return us a legal solution that may not be optimized, let's have a look at the below examples,

The vertex cover problem -

Given an undirected graph, the vertex cover problem is to find minimum size vertex cover, this is an optimized return type, i.e. we need to minimize the size of the vertex cover.
But the approximation version can be compiled as,Given an undirected graph, the vertex cover problem is to find the vertex cover, you may notice that there is no optimization(min/max requirement).

The Travelling Salesman Problem

Given a set of cities and distance between every pair of cities, the problem is to find the possible route that visits every city exactly once and returns to the starting point.
Notice that we don't need to find the shortest(i.e. minimum) possible root, instead we just need to find a legal route for our salesman.

Conclusion

The above problems are some of the examples to deliver the idea of what an Approximation Problem looks like. There are several other problems as well which are NP-hard and NP-complete.
The best thing about approximation algorithms is that, you can cross proof your approach in order to know if that's a feasible one.
And the probable worst thing is, these are approximations not exact.
Algorithms rule the world even if that is approximate or exact. Hence let's utilize these rules to build a better world for everyone.

Original Article Source - https://iq.opengenus.org/approximation-algorithms-intro/

Data Manipulation in Python using Pandas

Abhijit Tripathy — Sat, 13 Feb 2021 13:04:03 +0000

In Machine Learning, the model requires a dataset to operate, i.e. to train and test. But data doesn’t come fully prepared and ready to use. There are discrepancies like “Nan”/ “Null” / “NA” values in many rows and columns. Sometimes the data set also contains some of the row and columns which are not even required in the operation of our model. In such conditions, it requires proper cleaning and modification of the data set to make it an efficient input for our model. We achieve that by practicing “Data Wrangling” before giving data input to the model.

Ok, So let’s dive into the programming part. Our first aim is to create a Pandas dataframe in Python, as you may know, pandas is one of the most used libraries of Python.

Example:

# importing the pandas library 
import pandas as pd 


# creating a dataframe object 
student_register = pd.DataFrame() 

# assigning values to the  
# rows and columns of the 
# dataframe 
student_register['Name'] = ['Abhijit',  
                            'Smriti', 
                            'Akash', 
                            'Roshni'] 

student_register['Age'] = [20, 19, 20, 14] 
student_register['Student'] = [False, True, 
                               True, False] 

student_register

As you can see, the dataframe object has four rows [0, 1, 2, 3] and three columns[“Name”, “Age”, “Student”] respectively. The column which contains the index values i.e. [0, 1, 2, 3] is known as the index column, which is a default part in pandas datagram. We can change that as per our requirement too because Python is powerful.
Next, for some reason we want to add a new student in the datagram, i.e you want to add a new row to your existing data frame, that can be achieved by the following code snippet.

One important concept is that the “dataframe” object of Python, consists of rows which are “series” objects instead, stack together to form a table. Hence adding a new row means creating a new series object and appending it to the dataframe.

Example:

# creating a new pandas 
# series object 
new_person = pd.Series(['Mansi', 19, True],  
                       index = ['Name', 'Age',  
                                'Student']) 

# using the .append() function 
# to add that row to the dataframe 
student_register.append(new_person, ignore_index = True)

Before processing and wrangling any data you need to get the total overview of it, which includes statistical conclusions like standard deviation(std), mean and it’s quartile distributions. Also, you need to know the exact information of each column, i.e. what type of value it stores and how many of them are unique. There are three support functions, .shape, .info() and .describe(), which outputs the shape of the table, information on rows and columns, and statistical information of the data frame (numerical column only) respectively.

# for showing the dimension  
# of the dataframe 
print('Shape') 
print(student_register.shape) 

# showing info about the data  
print("\n\nInfo\n") 
student_register.info() 

# for showing the statistical  
# info of the dataframe 
print("\n\nDescribe") 
student_register.describe()

In the above example, the .shape function gives an output (4, 3) as that is the size of the created dataframe.

The description of the output given by .info() method is as follows:

“RangeIndex” describes about the index column, i.e. [0, 1, 2, 3] in our datagram. Which is the number of rows in our dataframe. As the name suggests “Data columns” give the total number of columns as output.
“Name”, “Age”, “Student” are the name of the columns in our data, “non-null ” tells us that in the corresponding column, there is no NA/ Nan/ None value exists. “object”, “int64″ and “bool” are the datatypes each column have.
“dtype” gives you an overview of how many data types present in the datagram, which in term simplifies the data cleaning process. Also, in high-end machine learning models, “memory usage” is an important term, we can’t neglect that.

The description of the output given by .describe() method is as follows:

count is the number of rows in the dataframe.
mean is the mean value of all the entries in the “Age” column.
std is the standard deviation of the corresponding column.
min and max are the minimum and maximum entry in the column respectively.
25%, 50% and 75% are the First Quartiles, Second Quartile(Median) and Third Quartile respectively, which gives us important info on the distribution of the dataset and makes it simpler to apply an ML model.

Construct the Cypher string based on the given conditions

Abhijit Tripathy — Sat, 13 Feb 2021 12:46:51 +0000

Given a number N, the task is to convert the given number into a Cypher string on the basis of below conditions:

If N is a semiprime, then change every digit at even places of N to it’s corresponding matched alphabet as shown below.
If N can be written as a sum of two primes, then change every digit at odd places of N to it’s corresponding matched alphabet as shown below.
If both the condition satisfy the concatenate the above two strings formed.
If N can’t satisfy the above three criteria, then print “-1”. Below is the list of matched character:

Examples:

Input: N = 61
Output: 6B
Explanation:
Since 61 can be expressed as a sum of two primes: 61 = 2 + 59
Therefore, the resultant string after changing the character at even index is “6B”.
Input: N = 1011243
Output: B0B1C4D
Explanation:
Since 1011243 is Semiprime number: 1011243 = 3 * 337081
Therefore, the resultant string after change the character at even index is “B0B1C4D”.

Approach:

Check if the given number N is semi prime or not by using the approach discussed in this article. If yes, then do the following:
- Convert the given number N to string(say str) using to_string() function.
- Traverse the above string formed and changed the characters at even index as:

str[i] = char((str[i] - '0') + 65)

Print the new string formed.
Check if the given number N can be expressed as a sum of two prime numbers or not using the approach discussed in this article. If yes, then do the following:
- Convert the given number N to string(say str) using to_string() function.
- Traverse the above string formed and changed the characters at odd index as:

str[i] = char((str[i] - '0') + 65)

Print the new string formed.
If the above two condition doesn’t satisfy then we can’t form Cypher String. Print “-1”.

Below is the implementation of the above approach:

// C++ program for the above approach

#include "bits/stdc++.h"
using namespace std;

// Function to check whether a number
// is prime or not
bool isPrime(int n)
{
    if (n <= 1)
        return false;

    for (int i = 2; i <= sqrt(n); i++) {
        if (n % i == 0)
            return false;
    }

    return true;
}

// Function to check if a prime number
// can be expressed as sum of
// two Prime Numbers
bool isPossibleSum(int N)
{
    // If the N && (N-2) is Prime
    if (isPrime(N)
        && isPrime(N - 2)) {
        return true;
    }
    else {
        return false;
    }
}

// Function to check semiPrime
bool checkSemiprime(int num)
{
    int cnt = 0;

    // Loop from 2 to sqrt(num)
    for (int i = 2; cnt < 2
                    && i * i <= num;
         ++i) {
        while (num % i == 0) {
            num /= i,

                // Increment the count of
                // prime numbers
                ++cnt;
        }
    }

    // If num is greater than 1, then
    // add 1 to it
    if (num > 1) {
        ++cnt;
    }

    // Return '1' if count is 2 else
    // return '0'
    return cnt == 2;
}

// Function to make the Cypher string
void makeCypherString(int N)
{

    // Resultant string
    string semiPrime = "";
    string sumOfPrime = "";

    // Make string for the number N
    string str = to_string(N);

    // Check for semiPrime
    if (checkSemiprime(N)) {

        // Traverse to make Cypher string
        for (int i = 0; str[i]; i++) {

            // If index is odd add the
            // current character
            if (i & 1) {
                semiPrime += str[i];
            }

            // Else current character is
            // changed
            else {
                semiPrime
                    += char(
                        str[i] - '0' + 65);
            }
        }
    }

    // Check for sum of two primes
    if (isPossibleSum(N)) {

        // Traverse to make Cypher string
        for (int i = 0; str[i]; i++) {

            // If index is odd then
            // current character is
            // changed
            if (i & 1) {
                sumOfPrime
                    += char(
                        str[i] - '0' + 65);
            }

            // Else add the current
            // character
            else {
                sumOfPrime += str[i];
            }
        }
    }

    // If the resultant string is ""
    // then print -1
    if (semiPrime + sumOfPrime == "") {
        cout << "-1";
    }

    // Else print the resultant string
    else {
        cout << semiPrime + sumOfPrime;
    }
}

// Driver Code
int main()
{

    // Given Number
    int N = 1011243;

    // Function Call
    makeCypherString(N);

    return 0;
}

Output:

B0B1C4D

Caesar Concatenation

Abhijit Tripathy — Sat, 13 Feb 2021 12:33:11 +0000

Given two strings str1 and str2 containing alphanumeric characters and a number N. The task is to form a new encrypted string which contains the string str1 with a Ceaser Encryption of N characters and the string str2 with a Ceaser Encryption of N characters at odd indices.

Example:

Input: str1 = “GeekforGeeks”, str2 = “Geeks123”, N = 4
Output: KiiojsvKiiowKeikw163
Explanation:
Caesar Text for string str1 with a shift of 4 is “KiiojsvKiiow”
Caesar Text for string str2 with a shift of 4 at all even indexes is “Keikw163”
Resultant string is “KiiojsvKiiow” + “Keikw163” = “KiiojsvKiiowKeikw163”

Input: str1 = “ABcdE23”, str2 = “efda2w”, N = 9
Output: JKlmN12nfma1w
Explanation:
Caesar Text for string str1 with a shift of 9 is “JKlmN12”
Caesar Text for string str2 with a shift of 9 at all even indexes is “nfma1w”
Resultant string is “JKlmN12” + “nfma1w” = “JKlmN12nfma1w”

Approach:
This problem is an application of Caesar Cipher in Cryptography. Below are the steps:
The idea is to traverse the given string str1 and str2 and convert all the characters at every index of str1 and at even indexes of str2 by a shift of N on the basis of below 3 cases:

Case 1: If characters lies between ‘A’ and ‘Z’ then the current character is encrypted as:

new_character = ( (current_character - 65 + N) % 26 ) + 65;

Case 2: If characters lies between ‘a’ and ‘z’ then the current character is encrypted as:

new_character = ( (current_character - 97 + N) % 26 ) + 97;

Case 3: If characters lies between ‘A’ and ‘Z’ then the current character is encrypted as:

new_character = ( (current_character - 48 + N) % 10 ) + 48;

Below is the implementation of the above approach:

// C++ implementation of the above 
// approach 
#include <bits/stdc++.h> 
using namespace std; 

void printCaesarText(string str1, 
                     string str2, int N) 
{ 

    // Traverse the string str1 
    for (int i = 0; str1[i]; i++) { 

        // Current character 
        char ch = str1[i]; 

        // Case 1: 
        if (ch >= 'A' && ch <= 'Z') { 
            str1[i] = (ch - 65 + N) % 26 + 65; 
        } 

        // Case 2: 
        else if (ch >= 'a' && ch <= 'z') { 
            str1[i] = (ch - 97 + N) % 26 + 97; 
        } 

        // Case 3: 
        else if (ch >= '0' && ch <= '9') { 
            str1[i] = (ch - 48 + N) % 10 + 48; 
        } 
    } 

    for (int i = 0; str2[i]; i++) { 

        // If current index is odd, then 
        // do nothing 
        if (i & 1) 
            continue; 

        // Current character 
        char ch = str2[i]; 

        // Case 1: 
        if (ch >= 'A' && ch <= 'Z') { 
            str2[i] = (ch - 65 + N) % 26 + 65; 
        } 

        // Case 2: 
        else if (ch >= 'a' && ch <= 'z') { 
            str2[i] = (ch - 97 + N) % 26 + 97; 
        } 

        // Case 3: 
        else if (ch >= '0' && ch <= '9') { 
            str2[i] = (ch - 48 + N) % 10 + 48; 
        } 
    } 

    // Print the concatenated strings 
    // str1 + str2 
    cout << str1 + str2; 
} 

// Driver Code 
int main() 
{ 

    string str1 = "GeekforGeeks"; 
    string str2 = "Geeks123"; 
    int N = 4; 

    printCaesarText(str1, str2, N); 

    return 0; 
}

Output:

KiiojsvKiiowKeikw163

Time Complexity: O(N + M), where N and M are the lengths of the two given string.

eduAlgo: Awating contributors

Abhijit Tripathy — Sun, 22 Nov 2020 15:19:17 +0000

What is eduAlgo?

We are an open-source organization named eduAlgo focused on making algorithm learning easier for python developers especially for the beginners by creating modules in the python package eduAlgo PyPI. Other than this, we are having a few opensource projects, which are participating in numerous of opensource programs as organization projects. Not only this, we are in a process to design courses and modules for beginners to learn DSA in python.

Why Python?

Python is easy to use, powerful, and versatile, making it a great choice for beginners and experts alike. Python’s readability makes it a great first programming language, it allows you to think like a programmer and not waste time with confusing syntax.

Why OpenSource?

Open-source licensing encourages innovation through collaboration. Without it, many of the technologies we take for granted today would never have developed or would be locked away behind patent law. The open-source movement is the reason that technology has developed at such a breakneck pace for the past few decades.

How to use the package?

A short demonstration of the package in action can be seen below,

This python package is open-sourced and published publically on python packaging Index(PyPI).

Repositories

1 - Python Package

edualgo / eduAlgo

A simple python package having modules of different algorithms to use in educational purposes.

2 - eduAlgo App

edualgo / edualgo-app-demo

This repository contains the demo application of the package edualgo in flutter and dart.

3 - Documentation

edualgo / documentation

The documentation website for the python package "eduAlgo"

How to contribute ?

We are very fond of developers out there, we want them to contribute and grow along with us. The contributions that our developers have made previously are precious and we are glad to have them here.

To contribute in our projects get in touch at - founder.edualgo@gmail.com

A better demonstration

The journey of Open Source and my first Hacktoberfest

Abhijit Tripathy — Sat, 17 Oct 2020 07:01:44 +0000

In open source, we feel strongly that to really do something well, you have to get a lot of people involved.
Linus Torvalds

Heya Amigos !!
Hope everyone is building something great.

This is Abhijit Tripathy, a sophomore of Computer Science and Engineering from India. I am a python lover and an aspiring Machine Learning Engineer.

Most importantly, I am active Open Source Contributor 😍

Everything related to me can be found here - My Portfolio

Today I will be sharing my journey of Open Source and as I have completed the hacktoberfest 2020 challenge, I will be telling about some of my open-source projects in which you may contribute.

My open-source journey

SCI - 2020 (Studentcode In)

My open-source journey started with the three-month-long open-source competition organized by SCI. I was a part of the project named "Survival Analysis", which is a statistical model used for analyzing and predicting survivals in business, churning of customers, the survival of patients in clinical trials and much more. I have worked on the EDA(Exploratory Data Analysis) part of the model as well as managed to write a python script for the Nelson Aaelan Estimator, that's used for the hazard function in survival analysis. Also, I have worked in building some scripts with the dash module of python for the deployment of the project.
This was my first involvement as a contributor to any open-source project in a group and I was selected as the top 25 winners of the competition as well.
The project can be viewed here - Survival Analysis

BWLU 2020(Build With Letsupgrad)

This was 2.5 months-long open-source project competition organized by Letsupgrad, where I was able to ideate a project named "Algorithmic Treasure", and contributed as a Project Manager & Mentor for the same. The project is a long term association of developers in order to prepare a website having good resources for the interview preparing candidates. A group of 10-12 developers came together in order to build the primary version of this website.
The project can be viewed here - Algorithmic Treasure

Contributor's Hack 2020(Hakincodes)

I have got an opportunity to be a mentor for this open-source program, where I have contributed to one of the participating projects. Mentoring is a great opportunity to refine the skills and help others getting started with open-source. In this program, I have been chosen as the top 5 mentors.
The project can be viewed here - neoAlgo

Hacktoberfest 2020(Digitalocean, DEV, Intel)

This October 2020, I have got a chance to be the part of Hacktoberfest 2020, as an organizer, maintainer and participant. As I am a part of three global communities namely Developer Student Clubs,GGV,Codecademy Campus Chapter &Mozilla Student Developers,GGV, I have got a chance to organize two speaker sessions from industry professionals and achievers in explaining the basics of git & GitHub to my college people as well as giving them a chance to dive into opensource.
I have my python software package named eduAlgo participating in the hacktoberfest 2020 as an open-source project. Also, I have completed the challenge by submitting 4 PRs (three to DSC repositories, that included two Django beginner projects and a flask implemented car price, prediction model). Cheers !!!

Autumn Of Opensource 2020 (sanscript.tech)

Recently I have got a chance to be a contributor for AOS20 organized by sanscript. This is an ongoing open-source project competition.

My Open-source Projects

I have only one project opted for the Hacktoberfest2020.

eduAlgo - This is a very simple python package made up with python script to study different algorithms for educational purposes. This package is currently under planning version and previously this project has been a part of FOSS Hack 2020 & PyCon 2020 Devsprint. PyPI link - eduAlgo

Thanks to Hacktoberfest organizers for coming up with this idea every year and supporting the real open-source 😊

In real open source, you have the right to control your own destiny.
Linus Torvalds