codesankalp / dsalgo Goto Github PK

Add these algorithms

• 1. Linear Search
• 2. Binary Search
• 3. Jump Search
• 4. Interpolation Search
• 5. Exponential Search
• 6. Fibonacci Search
• 7. Recursive program to linearly search an element in a given array
• 8. Recursive function to do a substring search

Also write test cases for the same. Tests and code can be divided in two commits though.

Description

After reviewing some pull requests, I realised that we don't have strict guidelines in contributing files. Here are some changes I would suggest:

• We should use conventional commit guidelines. This link may help https://www.conventionalcommits.org/en/v1.0.0/

We can add a commit template later for this

• Before working on an issue, you should get it assigned.

• If an issue is assigned to you, be sure to post updates. Otherwise, the assignee would be removed after 3 days of inactivity

• You should make a branch other than the default branch for the pull request.

In linked list python file add a representation method so that it will display linked list and not the object of class LinkedList at Node location.

implement the linked list using class with all the methods of linked list.

Now we are ready to release a starting version of this package. So to make it understandable to other users it is required to have a good readme.

• While writing readme it is required to think like you have never used this code and you are a complete beginner.
• readme extension must be .rst because it will also be available on PyPI.

The basic idea of this repository is to create reusable functions for ds and algo so that users don't need to rewrite the same piece of code again and again.

As the Module is constantly upgrading, a list of implemented algorithms needs to be present at the cover ReadMe of the repository. It will help Users to find and select algorithms they need and will help contributors to decide to write a new algorithm for the module.

• 1. Create root
• 2. Insertion into a tree
• 3. Transversing a tree
• 4. Search for a value in a B-tree

Currently there is a doubly_linked_list.py file in dsalgo (not merged yet) folder but there is no way to count the number of items of a given doubly linked list for example, if items = doubly_linked_list()

then:

• code for which items.count will show up the number of item
• make a pull request for queue branch not for master branch.
• update the queue branch with the master.

P.S : Refer this commit for doubly_linked_list.py file.
or the issue #56

required submission protocols for pull request.
type: google doc, word , ppt
must include: format for pull request, test,quality assurance and other neccessary checks

At present, we don't have general rules and guidelines for commits, issues and pull requests. We can create basic guidelines and templates for that.

• Add templates

• Add basic guidelines

• Make changes in documentation

You can use this link for conventional commits: - https://www.conventionalcommits.org/en/v1.0.0/

Currently there is a doubly_linked_list.py file in dsalgo (not merged yet) folder but there is no way to insert an item in front of a given doubly linked list for example, if function name is insert_start() (this is preferred name)

then:

• code for which items.insert_start([this contains required object]) will show up the new object added in front of the doubly linked list created previously in continuation with issue #67
• make a pull request for queue branch not for master branch.
• update the queue branch with the master.

P.S : Refer this commit for doubly_linked_list.py file.
or the issue #56 in continuation with issue #67

• Using unittest framework, write test cases for linked_list.py

May be adding this would be beneficial

• 1. Depth First Traversal (DFS)
• 2. Breadth First Traversal (BFS)

using class and with all methods

Is your request related to a problem? Please describe.
When we try to print list in backwards way, for that a function is required.

Describe the solution you'd like
To create a doubly linked list and print nodes from current position to first node.

Describe alternatives you've considered
Using a print_backward() function

Additional context
No additional context

For example:
is_balanced()
is_subtree()
is_symmetric()
longest_consecutive()
lowest_common_ancestor()
max_height()
max_path_sum()
min_height()

DS Algo file now contains problems based on BIT Manipulation and Project Euler site.

• 1. In-order Traversal
• 2. Pre-order Traversal
• 3. Post-order Traversal

create a doubly linked list, append some items and iterate through the list (print forward)

Hint: You may use divide and conquer to solve this issue

Like:
bitonic_sort.
bogo_sort.py
bucket_sort.py
comb_sort.py.... & many more

Currently Module is available for python 3 to 3.7 only while python 3.9 is in frequent use currently.

Solution - Setup.py file needs to be updated for the module.

Related to #4

Write test cases(using python unittest framework) for this issue in existing file dsalgo/tests/sort _tests.py (This mandatory for the issue to be merged)

to solve this issue you must include some of the programs to make string algorithms easy usable
like: -
fizz buzz
delete_reoccurring_characters
strip_url_params
validate_coordinates
domain_extractor
merge_string_checker
add_binary
breaking_bad
decode_string
encode_decode
group_anagrams
int_to_roman
is_palindrome
license_number
make_sentence
multiply_strings
one_edit_distance
rabin_karp
reverse_string
reverse_vowel
reverse_words
roman_to_int
word_squares
and much more
note:- not needed to implement every above-mentioned idea
you can create your own if it's good.

merge_sorted_k_lists
skyline
sliding_window_max binary_heap
or any other method related to heap.

I was going through issue #23 and here one required algo is string subsequence matching, while looking through the code structure, it seems it is not a great idea to implement something related to strings in the same section. I suggest creating a separate code segment for string manipulation algorithms.

NAME:
address visualization support for individual nodes

ABOUT:
while exporting nodes of linked-list in a list format (to_list()),addressing address of each node for debugging.

SOLUTION
append address to the node values while calling to_list() function.

ALTERNATIVE
address can be printed while itterating of node manually but it will be a time consuming task, hence not preferred

Implement all the sorting algorithms using class in one python file. For more details about implementation contact @KapilBansal320

About algo:
The Floyd Warshall Algorithm is for solving the All Pairs Shortest Path problem. The problem is to find the shortest distances between every pair of vertices in a given edge-weighted directed Graph.

Is your request related to a problem? Please describe.

New Feature: Implementing Heap data structure to the Library

Describe the solution you'd like

Use class and define all operations as methods

Additional context

• Add a parameter min or max to identify min heap or max heap
• Define all possible operations on Heap

Some examples :

• 1. To generate the path from one node to the other node

• 2. Program to generate all the possible paths from one node to the other.

• 3. Program to generate the shortest path.

- NOTE: Write test cases(using python unittest framework) for this issue and create a separate file named as graphs_test.py in dsalgo/test(This mandatory for the issue to be merged)

Currently, python provides basic math operations but they are not that flexible. Like you can calculate H.C.F. of two numbers but what if we want to calculate H.C.F. of a list.
Also, we can implement other algorithms like for prime, next prime, last prime etc.

implement stack using class with all the methods

Currently there is a pr for queue implementation but there are no test cases so you have to add the test for this in the queue branch.

what to do:

• Write tests for pyqueue in tests/
• make a pull request for queue branch not for master branch.
• update the queue branch with the master.

Some PRs add algorithms to the repo but the Readme file is not updated sometimes, this may cause misunderstandings on what algorithms still need to be implemented. Hence the list of algorithms in readme must be revised after every successful merged PR.

You may create functions like:
is_cyclic()
is_palindrome()
is_sorted()
kth_to_last()
reverse()
rotate_list()
swap_in_pairs()

Merge() two sorted linked lists and return it as a new list. The new list should
be made by splicing together the nodes of the first two lists.
For example:
Input: 1->2->4, 1->3->4
Output: 1->1->2->3->4->4

Also, create a separate test file linked_list_test.py in dsalgo/tests for this issue using python unittest (testing framework) Which contain tests for existing linked_list.py included merge().

Things need to be done for this issue:

• Add a merge() in existing linked_list.py

• Write tests using Unittest framework for complete file i.e linked_list.py