var-solutions / algorithms

A repository of different Algorithms and Data Structures implemented in many programming languages.

Data Structures and Algorithms

Clean example implementations of data structures and algorithms written in different languages.

List of implementations

Algorithms list(not updated)

Contribution!

• Contributions are always welcome. Language doesn't matter. Just make sure you're implementing an algorithm.

• PRs are welcome. To begin developing, follow the structure:

  Algorithm-Type/algorithm-name/language-name/file-name.extension

  e.g

  Sorting/bubble-sort/python/bubble-sort.py

• If there is an implementation of the same algorithm in your language, do not give a PR for that.

• Please include a description for the algorithm that you are implementing. It doesn't matter if it's copied from somewhere as long as it helps people that are learning new algorithm.

• Graphical examples would be very helpful too.

• You can include tests as well.

• Don't remove previous implementations of algorithms. You can help in improving the current implementation by adding explanations and examples.

• Beautify and clean up your code for easier reading

Note:

• Do not make a new issue unless required.
• If your PR is closed without any comment, it means that your PR does not meet the above criteria. Make sure your PR is not Duplicate and it should be well-documented.

Resources

The curated list of resources dealing with algorithms.

• Sites
  • Algorithms - Tutorials point
  • Algorithms - Princetone edu
  • Data structures and algorithms - Hackr
  • Data science - Topcoder
  • Fundamentals Of Algorithms- Geeks For Geeks
  • Visual Algorithm - visualising data structures and algorithms through animation
  • Rosetta Code
  • GeeksforGeeks
  • CP-Algorithms
• Online classes (Free)
  • Coursera
    • Introduction to algorithms Part 1
    • Algorithms specialization 4 courses
  • Khan Academy
    • Algorithms
  • Udacity
    • Computability, Complexity & Algorithms
    • Intro to algorithms
  • EdX

    • Algorithms

    • Algorithms and data structures

    • Algorithm Design and Analysis

    • Graph Algorithms

    • Data Structures

    • Algorithmic Design and Techniques

    • String Processing and Pattern Matching Algorithms

    • Graph Algorithms in Genome Sequencing

    • Algorithms and Data Structures Capstone

    • Data Structures

    • Algorithms and Data Structures Capstone

    • Data Structures and Algorithms

  • GeeksForGeeks
    • Algorithms
• Coding Practice Sites
  • HackerRank
  • HackerEarth
  • SPOJ
  • TopCoder
  • CodeChef
  • Codeforces
  • Project Euler
  • LeetCode
  • CodinGame
  • CodeWars
  • Coderbyte
  • HireVue
  • FreeCodeCamp
  • CodeSignal
  • AtCoder

Project Maintainers.

• Vishal Gaur 🎉
  
• Ravi Varshney 🎉
  
• Ananya Tewari 🎉
  

algorithms's Issues

Efficient Random number generator in any language

implement algorithms in Ruby

Implement Algorithms using Ruby Language

Centroid of a given Tree | C++

Algorithm to find centroid of a given tree.
Centroid of a Tree is a node which if removed from the tree would split it into a ‘forest’, such that any tree in the forest would have at most half the number of vertices in the original tree.
Language - C++

folders for separate languages

making separate folders for separate languages will help in maintaining a lot

add game theory algorithms

implement all type of game theory algorithms

implement graph algorithms

• minimum spanning tree

• single source shortest path

• all pair shortest path

• maximum flow

• any other type of graph algorithms

LCSP

write a program to find the strings that make lcsp length in any language

need proper folders

Boruvka's algorithm to find MST | C++

Boruvka's algorithm to find Minimum Spanning Tree.
Language: C++

add description file for every algorithm in Markdown language

• Add description file for every algorithm in the repository.
• The file must be written in Markdown language.
• Name of file should be: algorithm_name.md.
• Description file should be inside the algorithm's folder as: ALGORITHM_NAME/algorithm_name.md.
• The file should contain the basic information about the algorithm, i.e., where, why and how it is used.
• It should also contain the pseudocode of the algorithm.

Add Segment Tree in Java

I will add segment tree implementation in java.

Add Dynamic Programming Algorithms

Rosetta Code

This website has lots of algorithms in different languages, almost like an algorithm wiki.

Could be a good addition to this list!

http://rosettacode.org/wiki/Rosetta_Code

Diagonal Traversal Of Binary Tree in C++

I would like to contribute to the repository by writing the program for diagonal traversal of a binary tree. Kindly assign the issue to me :)

Edit /data structures/linkedlist.cpp such it work on all IDE's

currently it works on CodeBlocks. Edit it such that it work on G++

add stack and queues

add stacks and queues functionality to data structures folder

implement Algorithms in Swift or ADA

Implement Algorithms using Swift Language or ADA Language

Add Unbounded Knapsack in Python

I would like to contribute on this !
Will add Clean and Commented code for easy understanding. Thanks!

Reverse a number algorithm

The Java version of Heapsort is just an empty file

There is no actual Java implementation of Heapsort here, it's just an empty file.

https://github.com/VAR-solutions/Algorithms/blob/master/Sorting/Heapsort/java/heapSort.java

Adding Hangman Game using python in Game theory

@i-vishi @ravivarshney01 Please assign me this issue as a part of Hactoberfest2020,

Wrong folder

The files euclidean_algo_GCD_basic.py and euclidean_algo_GCD_extended.py are placed in wrong folder. They should be place in Algorithms/Mathematics/GCD/ and removed from Algorithms/Mathematics/euclidean distance/.

Add Staircase Problem in DP

I'll add clean code with comments. Thanks!

add efficient algorithms

#1 add cpp, python, java or any language program, also try to save that program in respective algorithm folder

Linear Search & Bubble Sort

Hello,
I have contributed code for Linear Search in C++ and Bubble Sort in C Language.
Hope you'll accept it.

implement algorithms in python

Implement any algorithm in Python Language that are not in repository

add algorithms and data structures in any language

Dated: Oct-07-2020
Regarding Delay in reviewing PR
Hello, everyone, I am one of the maintainer of this repository. I know most of the PRs are the part of hacktoberfest and most of you are worried will your PRs will be eligible for Hacktoberfest 2020 or not. Since, all the maintainers are busy, it will take some time to review all the PRs. We have to review each PR and it may take some time.
Also, the rules of Hacktoberfest have been changed to reduce spam PRs. There are many SPAM PRs with invalid code or no code. So, we have to review each PR one by one. Due to the changes in rules, the burden has been shifted to maintainers.

About adding and then removing hacktoberfest-accepted label, it was just to check and verify the eligibility of the label. Do not consider it as making your PR invalid.

All the PRs will be checked and reviewed

Thanks and Happy coding 💻 👨‍💻 👩‍💻 💻

Binary search for 2d array in C++

It searches for a value in a 2d m*n matrix.
Properties of matrix:

1. Integers in each row are sorted from left to right.
2. The first integer of each row is greater than the last integer of the previous row.

Issue with fork ?

I am trying to clone this repo after forking but its giving me errors.

PR is not getting merged

Why is PR is not getting merged to the main branch?. The last change that is merged is around 3 months old. is the repo not active?

implement Tree algorithms

Subset Sum Problem in C++

I would like to contribute to the repository by writing the program for the famous subset sum problem for hacktoberfest. Kindly assign the issue to me :)

Add a function checking Anagram using python

I would like to contribute on this issue. Please assign it to me.

implement algorithms in c

implement algorithms in golang

Mathematics/LCM/python/lcm.py is not efficient

Mathematics/LCM/python/lcm.py is not an efficient algo . It is taking O(n) time whereas this time can be reduced to O(log(n))

implement algorithms in JavaScript

Longest Increasing Subsequence in O(N log N)

I would like to implement the Longest Increasing Subsequence problem using Binary Search and Dynamic Programming in worst-case complexity of N log N as a part of Hacktober Fest 2020.

Maximize expression | Dynamic Programming | Python

Add an algorithm to maximize an expression by computing and maximizing subexpressions and placing parentheses.
Files that would change after the PR: Dynamic Programming/Maximize Expression/maximize_expression.py

Convert Number to words

I would like to add a algorithm which converts number entered by user into words.
example:
Input 100
Output One Hundred
This will be useful when implementing a feature like automatically making a dummy cheque for user with amount filled.

add README to Searching Directory

Add a README.md file inside the Searching Directory. The file should contain a table that has

• Columns of searching algorithms and programming languages(C, CPP, Python, Java, etc.)
• Add a row of each searching algorithm and mark a ✔️ with a LINK to code if it is currently implemented in the corresponding programming language, else leave the cell blank.
• Do it for each searching algorithm.
• You can also change file names as per the algorithm to simplify the task. But do not forget to follow the nomenclature as:
  algorithm-name/ProgrammingLanguage/algorithm_code.extension

Refer to Sorting README and implement in the same manner.Refer to Markdown Cheatsheet or Makrdown Guide to get help with writing Markdown.

Example Scrrenshot is given below:

edit /data structures/menu driven stack and queue/ to work on g++

Adding TicTac-Toe using Java in Game theory.

@ravivarshney01 @i-vishi I would like to add tic-tac-toe game using Java in Game theory

Add minimum vertex cover for a binary tree problem in c++

I want to a DP based problem. Please assign so that I may get started.

Add algorithms in Ruby, C#, Golang and Rust

Implement Data structures and algorithms in Ruby, Go, C# and Rust

nth term of fibonacci using Binet's Theorem

I would like to add a rare algorithm to find the nth term of a fibonacci @i-vishi

Add Vertical order Tree Traversal algorithms in c++

I would like to add vertical order tree traversal in c++. Kindly assign this issue to me

Create 8_Puzzle_Problem.py

mport copy
from prettytable import PrettyTable

inputMatrix = [[1, 2, 3], [4, 6, 0], [7, 5, 8]]
outputMatrix = [[1, 2, 3], [4, 5, 6], [7, 8, 0]]

class Astar:

def init(self): # Object containing matrix, flag(loc of swap), and elements
self.grid = [] # of the exp f = g + h initialized to zero
self.flag = ""
self.gCost = 0
self.hCost = 0
self.fCost = 0
def generateNeighbours(inMatrix): # Generating neighbours
slot = () # 1. Finding the void place of the current matrix
neighbours = [] # 2. Checking and swapping values to generate neighbours
for i in range(0, len(inMatrix.grid)):
for j in range(0, len(inMatrix.grid)):
if inMatrix.grid[i][j] == 0:
slot = (i, j)
break

x, y = slot

if inMatrix.flag == "":
if x + 1 <= len(inMatrix.grid) - 1:
tobj = Astar()
tobj.grid = copy.deepcopy(inMatrix.grid)
tobj.grid[x][y], tobj.grid[x + 1][y] = tobj.grid[x + 1][y], tobj.grid[x][y]
tobj.flag = "up"
tobj.gCost = inMatrix.gCost + 1
tobj.hCost = findHeuristicValue(tobj.grid)
tobj.fCost = tobj.gCost + tobj.hCost
neighbours.append(tobj)

if x - 1 >= 0:
	tobj = Astar()
	tobj.grid = copy.deepcopy(inMatrix.grid)
	tobj.grid[x][y], tobj.grid[x - 1][y] = tobj.grid[x - 1][y], tobj.grid[x][y]
	tobj.flag = "down"
	tobj.gCost = inMatrix.gCost + 1
	tobj.hCost = findHeuristicValue(tobj.grid)
	tobj.fCost = tobj.gCost + tobj.hCost
	neighbours.append(tobj)

if y - 1 >= 0:
	tobj = Astar()
	tobj.grid = copy.deepcopy(inMatrix.grid)
	tobj.grid[x][y], tobj.grid[x][y - 1] = tobj.grid[x][y - 1], tobj.grid[x][y]
	tobj.flag = "left"
	tobj.gCost = inMatrix.gCost + 1
	tobj.hCost = findHeuristicValue(tobj.grid)
	tobj.fCost = tobj.gCost + tobj.hCost
	neighbours.append(tobj)

if y + 1 <= len(inMatrix.grid) - 1:
	tobj = Astar()
	tobj.grid = copy.deepcopy(inMatrix.grid)
	tobj.grid[x][y], tobj.grid[x][y + 1] = tobj.grid[x][y + 1], tobj.grid[x][y]
	tobj.flag = "right"
	tobj.gCost = inMatrix.gCost + 1
	tobj.hCost = findHeuristicValue(tobj.grid)
	tobj.fCost = tobj.gCost + tobj.hCost
	neighbours.append(tobj)

if inMatrix.flag == "up":
if x + 1 <= len(inMatrix.grid) - 1:
tobj = Astar()
tobj.grid = copy.deepcopy(inMatrix.grid)
tobj.grid[x][y], tobj.grid[x + 1][y] = tobj.grid[x + 1][y], tobj.grid[x][y]
tobj.flag = "up"
tobj.gCost = inMatrix.gCost + 1
tobj.hCost = findHeuristicValue(tobj.grid)
tobj.fCost = tobj.gCost + tobj.hCost
neighbours.append(tobj)

if y - 1 >= 0:
	tobj = Astar()
	tobj.grid = copy.deepcopy(inMatrix.grid)
	tobj.grid[x][y], tobj.grid[x][y - 1] = tobj.grid[x][y - 1], tobj.grid[x][y]
	tobj.flag = "left"
	tobj.gCost = inMatrix.gCost + 1
	tobj.hCost = findHeuristicValue(tobj.grid)
	tobj.fCost = tobj.gCost + tobj.hCost
	neighbours.append(tobj)

if y + 1 <= len(inMatrix.grid) - 1:
	tobj = Astar()
	tobj.grid = copy.deepcopy(inMatrix.grid)
	tobj.grid[x][y], tobj.grid[x][y + 1] = tobj.grid[x][y + 1], tobj.grid[x][y]
	tobj.flag = "right"
	tobj.gCost = inMatrix.gCost + 1
	tobj.hCost = findHeuristicValue(tobj.grid)
	tobj.fCost = tobj.gCost + tobj.hCost
	neighbours.append(tobj)

if inMatrix.flag == "down":
if x - 1 >= 0:
tobj = Astar()
tobj.grid = copy.deepcopy(inMatrix.grid)
tobj.grid[x][y], tobj.grid[x - 1][y] = tobj.grid[x - 1][y], tobj.grid[x][y]
tobj.flag = "down"
tobj.gCost = inMatrix.gCost + 1
tobj.hCost = findHeuristicValue(tobj.grid)
tobj.fCost = tobj.gCost + tobj.hCost
neighbours.append(tobj)

if y - 1 >= 0:
	tobj = Astar()
	tobj.grid = copy.deepcopy(inMatrix.grid)
	tobj.grid[x][y], tobj.grid[x][y - 1] = tobj.grid[x][y - 1], tobj.grid[x][y]
	tobj.flag = "left"
	tobj.gCost = inMatrix.gCost + 1
	tobj.hCost = findHeuristicValue(tobj.grid)
	tobj.fCost = tobj.gCost + tobj.hCost
	neighbours.append(tobj)

if y + 1 <= len(inMatrix.grid) - 1:
	tobj = Astar()
	tobj.grid = copy.deepcopy(inMatrix.grid)
	tobj.grid[x][y], tobj.grid[x][y + 1] = tobj.grid[x][y + 1], tobj.grid[x][y]
	tobj.flag = "right"
	tobj.gCost = inMatrix.gCost + 1
	tobj.hCost = findHeuristicValue(tobj.grid)
	tobj.fCost = tobj.gCost + tobj.hCost
	neighbours.append(tobj)

if inMatrix.flag == "left":
if x + 1 <= len(inMatrix.grid) - 1:
tobj = Astar()
tobj.grid = copy.deepcopy(inMatrix.grid)
tobj.grid[x][y], tobj.grid[x + 1][y] = tobj.grid[x + 1][y], tobj.grid[x][y]
tobj.flag = "up"
tobj.gCost = inMatrix.gCost + 1
tobj.hCost = findHeuristicValue(tobj.grid)
tobj.fCost = tobj.gCost + tobj.hCost
neighbours.append(tobj)

if x - 1 >= 0:
	tobj = Astar()
	tobj.grid = copy.deepcopy(inMatrix.grid)
	tobj.grid[x][y], tobj.grid[x - 1][y] = tobj.grid[x - 1][y], tobj.grid[x][y]
	tobj.flag = "down"
	tobj.gCost = inMatrix.gCost + 1
	tobj.hCost = findHeuristicValue(tobj.grid)
	tobj.fCost = tobj.gCost + tobj.hCost
	neighbours.append(tobj)

if y - 1 >= 0:
	tobj = Astar()
	tobj.grid = copy.deepcopy(inMatrix.grid)
	tobj.grid[x][y], tobj.grid[x][y - 1] = tobj.grid[x][y - 1], tobj.grid[x][y]
	tobj.flag = "left"
	tobj.gCost = inMatrix.gCost + 1
	tobj.hCost = findHeuristicValue(tobj.grid)
	tobj.fCost = tobj.gCost + tobj.hCost
	neighbours.append(tobj)

if inMatrix.flag == "right":
if x + 1 <= len(inMatrix.grid) - 1:
tobj = Astar()
tobj.grid = copy.deepcopy(inMatrix.grid)
tobj.grid[x][y], tobj.grid[x + 1][y] = tobj.grid[x + 1][y], tobj.grid[x][y]
tobj.flag = "up"
tobj.gCost = inMatrix.gCost + 1
tobj.hCost = findHeuristicValue(tobj.grid)
tobj.fCost = tobj.gCost + tobj.hCost
neighbours.append(tobj)

if x - 1 >= 0:
	tobj = Astar()
	tobj.grid = copy.deepcopy(inMatrix.grid)
	tobj.grid[x][y], tobj.grid[x - 1][y] = tobj.grid[x - 1][y], tobj.grid[x][y]
	tobj.flag = "down"
	tobj.gCost = inMatrix.gCost + 1
	tobj.hCost = findHeuristicValue(tobj.grid)
	tobj.fCost = tobj.gCost + tobj.hCost
	neighbours.append(tobj)

if y + 1 <= len(inMatrix.grid) - 1:
	tobj = Astar()
	tobj.grid = copy.deepcopy(inMatrix.grid)
	tobj.grid[x][y], tobj.grid[x][y + 1] = tobj.grid[x][y + 1], tobj.grid[x][y]
	tobj.flag = "right"
	tobj.gCost = inMatrix.gCost + 1
	tobj.hCost = findHeuristicValue(tobj.grid)
	tobj.fCost = tobj.gCost + tobj.hCost
	neighbours.append(tobj)

return neighbours
def findHeuristicValue(inMatrix): # Comparing position of values of current matrix to the ones of desired matrix
h = 0
for i in range(0, len(inMatrix)):
for j in range(0, len(inMatrix)):
if inMatrix[i][j] != outputMatrix[i][j]:
h += 1
return h

def findBestMatrix(openList): # Select best matrix from open list and return it
bestmatrix = Astar()
mincost = float("inf")
for matrix in openList:
if matrix.fCost <= mincost:
mincost = matrix.fCost
bestmatrix = matrix
return bestmatrix

def printMatrix(matrix): # Formatting matrices
p = PrettyTable()
for row in matrix:
p.add_row(row)
return p.get_string(header=False, border=False)

def pathFinder():
openList = []
closedList = []
current = Astar()
current.grid = inputMatrix
openList.append(current)
steps = 0

print("Input Matrix -->") # Printing Input Matrix
print(printMatrix(current.grid))
print("Output Matrix -->") # Printing Output Matrix
print(printMatrix(outputMatrix))
print()
print()

while True:
current = findBestMatrix(openList)
openList.remove(current)
closedList.append(current)

print("Step {0}:".format(str(steps)))  # Printing steps
print(printMatrix(current.grid))       # Printing matrices
print()

if findHeuristicValue(current.grid) == 0:
	exit(0)

neighbourList = generateNeighbours(current)     # Generating neighbours from the selected matrix
for neighbour in neighbourList:
	if neighbour not in openList:
		openList.append(neighbour)              # Appending neighbours in the open list
steps += 1                                      # Incrementing steps

pathFinder()

Add Combinatorial Game Theory Algorithms

Add different game theory algorithms in any language

add Greedy Algorithms