https://github.com/tanaytoshniwal/data-structures-algorithms

:pushpin: :books: Solution of competitive programming problems and challenges, Project Euler Solutions, Data Structures, Data Structure implementations, Algorithms and Interview Questions.
https://github.com/tanaytoshniwal/data-structures-algorithms

algorithms bit-manipulation coding-challenges competitive-coding competitive-programming data-structures datastructures dsa dynamic-programming hacktoberfest hacktoberfest2021 interview-questions mathematics

Last synced: about 1 month ago
JSON representation

:pushpin: :books: Solution of competitive programming problems and challenges, Project Euler Solutions, Data Structures, Data Structure implementations, Algorithms and Interview Questions.

• Host: GitHub
• URL: https://github.com/tanaytoshniwal/data-structures-algorithms
• Owner: tanaytoshniwal
• License: mit
• Created: 2018-03-27T17:28:44.000Z (almost 7 years ago)
• Default Branch: master
• Last Pushed: 2021-12-06T04:48:46.000Z (about 3 years ago)
• Last Synced: 2023-03-03T18:12:25.329Z (almost 2 years ago)
• Topics: algorithms, bit-manipulation, coding-challenges, competitive-coding, competitive-programming, data-structures, datastructures, dsa, dynamic-programming, hacktoberfest, hacktoberfest2021, interview-questions, mathematics
• Language: C++
• Homepage:
• Size: 2.26 MB
• Stars: 30
• Watchers: 1
• Forks: 20
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • Contributing: CONTRIBUTING.md
  • License: LICENSE

Awesome Lists containing this project

README

        
# Competitive Programming

:pushpin: :books: Solution of competitive programming problems and challenges, Project Euler Solutions, Data Structures, Data Structure implementations, Algorithms and Interview Questions.

## How to Contribute:

- Fork this repo

- Open an [Github Issue](https://github.com/tanaytoshniwal/Data-Structures-Algorithms/issues) regarding the changes you're going to make

- Make the changes in the Forked repo

- **MAKE SURE TO ADD YOUR CHANGES IN README.md FILE!!!**

- Raise a PR against this Repo!

That's all you need to know about the process now it's your turn to help us improve the repository, thank you again!

## Contribution Guidelines

Please read our [Contribution Guidelines](https://github.com/tanaytoshniwal/Data-Structures-Algorithms/blob/master/CONTRIBUTING.md) before you contribute to this project.

------------------------------------------------------------------------------

## Index

+ [Data Structures and Algorithms](#Data-Structures-and-Algorithms)

    + [Ad-hoc Problems](#Ad-hoc-Problems)

    + [Algorithms](#Algorithms)

    + [Competitions-Challenges](#Competitions-Challenges)

    + [Compiler Design](#Compiler-Design)

    + [Data Structures](#Data-Structures)

    + [Fast IO](#Fast-IO)

    + [Interview Preparation](#Interview-Preparation)

    + [Patterns](#Patterns)

    + [Project Euler](#Project-Euler)

------------------------------------------------------------------------------

## Content

### Ad-hoc-Problems:

Contains some popular **Ad-hoc Problems**.

|   Topic/Question  |   C |   C++ |   Java    |   Python  |

|---------|:---------:|:---------:|:---------:|:---------:|

|   Circular List of Students   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

|   Equalize|  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

|   Interesting Sequences|  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

|   Light up the Bulbs|  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

|   Rectangular Area|  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

|   Winning Strategy|  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

------------------------------------------------------------------------------


### Algorithms:

Contains some popular **Algorithms** and related problems.

#### Topics

+ **Algorithms-Problems**

    + **Binary Search**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Agressive Cows   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Bishu and Soilders   |  
 [ ] 
  |   
 [x] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   BooBoo and Upsolving   |  
 [ ] 
  |   
 [x] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Compare Strings   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    ------------------------------------------------------------------------------


    + **Greedy**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Activity Selection   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Lopov   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Minimum Absolute Difference   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Nikunj and Donuts   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Perimeter with Conditions   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Problem Discussion   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Save Energy   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Weighted Job Scheduling   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Winning Lottery   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    ------------------------------------------------------------------------------


    + **Linear Search**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Breakup App   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Holiday Season   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Manna's First Name   |  
 [ ] 
  |   
 [x] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Min-Max   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Monk Takes a Walk   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Policemen and thieves   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Repeated K Times   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Rest in peace-21-1   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Simple Search   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Square Transaction   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   The Normal Type   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    ------------------------------------------------------------------------------


    + **Merge Sort**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Inversion Count   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Murder   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    ------------------------------------------------------------------------------


+ **BackTracking**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Crossword   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Graph Coloring   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   N-Queens   |  
 [ ] 
  |   
 [x] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Permutations of a String   |  
 [ ] 
  |   
 [x] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Rat in a Maze   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Sudoku   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    ------------------------------------------------------------------------------


+ **Bit Manipulation**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Check ith bit   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Check Odd or Even   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [x] 
  |

    |   Check Power of 2   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Clear all bits from MSB   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Convert Number to Binary   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Flip ith bit   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Return First Set Bit   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Turn Off First Set Bit   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Turn Off ith Bit   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Turn On ith Bit   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |


    ------------------------------------------------------------------------------

+ **Dynamic Programming**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   01 Knapsack Problem   |  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

    |   Alpha Code   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Boredom   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Catalan Number   |  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

    |   Coin Change   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [x] 
  |

    |   Construct the Array   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Count BSTs   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Edit Distance   |  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

    |   Egg Dropping Puzzle   |  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

    |   Fibonacci Numbers   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [x] 
  |

    |   K-Divisibility of Array   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Kadane's Algorithm   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Longest Bitonic Subarray   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Longest Common Subsequence   |  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

    |   Longest Consecutive Subsequence   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Longest Increasing Subsequence   |  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

    |   Loot Houses   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Magic Grid   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Maximum Non-Negative Subarray   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Maximum Non-Negative Subarray Sum   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Maximum Product Subarray   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Maximum Square with all Zeros   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Maximum Sum Contiguous Subarray   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Maximum Sum Rectangle   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Min Cost Path   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [x] 
  |

    |   Mindbending Product   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Minimum Number of Chocolates   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Right Down the Grid   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Sam and Substrings   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Staircase Problem   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Ugly Numbers   |  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

    ------------------------------------------------------------------------------


+ **Greedy**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Fractional Knapsack   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Kruskal's Algorithm   |  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

    |   Prims Algorithm   |  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

    ------------------------------------------------------------------------------


+ **Searching**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Binary Search   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Linear Search   |  
 [ ] 
  |   
 [x] 
 |  
 [x] 
  |  
 [ ] 
  |

    ------------------------------------------------------------------------------


+ **Sorting**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Bubble Sort   |  
 [ ] 
  |   
 [x] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Counting Sort   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Heap Sort   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Insertion Sort   |  
 [x] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [x] 
  |

    |   Merge Sort   |  
 [x] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Quick Sort   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Selection Sort   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    ------------------------------------------------------------------------------


+ **Strings**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Funny String   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [x] 
  |

    |   Gemstones   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Print Keypad   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Print Subsequences   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Return Subsequences   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    ------------------------------------------------------------------------------

------------------------------------------------------------------------------


### Competitions-Challenges:

Contains some Questions from Online **Competitions and Challenges**.

+ **CodeChef**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   BST Operations   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Chef Restaurant   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   CNOTE   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   CodeChef-OCT17 : A Balanced Contest   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Compiler   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Discrepancies in the Voters List   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Hussain Set   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   K-Concatenation   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Permutation and Palindrome   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Sudoku   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Variation   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Video Game   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [x] 
  |

    ------------------------------------------------------------------------------


+ **Codezen**

    **Programming Fundamentals**

    **Conditionals and loops**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Alpha Pattern   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Find power of a number   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Number Pattern   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Number Pattern 1   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Number Pattern 2   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Number Pattern 3   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Sum of even and odd   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Total Salary   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    ------------------------------------------------------------------------------


    **Patterns**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Alpha Pattern   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Binary Pattern   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Galaxy of Stars   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Give me Triangle   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Interesting Alphabets   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Number Pattern   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Pattern_ify   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Repeat Triangle   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Repeating Numbers   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Reversing Series Pattern   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    ------------------------------------------------------------------------------


+ **Google Code Jam**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   You Can Go Your Own Way   |  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

    |   Foregone Solution   |  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

    ------------------------------------------------------------------------------


+ **HackerEarth**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Fate of the Mormont   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   MaxMul   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Network Overflow   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    ------------------------------------------------------------------------------


+ **HackerEarth-CodeArena**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Competition 1   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    ------------------------------------------------------------------------------


+ **HackerEarth-CodeEnigma**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Anushka   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Chug   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Number Pattern   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Star   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   String Manipulation   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Stuck In A Maze   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   SubSequence   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Sum It Up   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   TTT   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    ------------------------------------------------------------------------------


+ **HackerEarth-DecemberCircuits17**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Left Or Right   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    ------------------------------------------------------------------------------


+ **HackerEarth-ThinkAThonV2**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Paper Planes   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    ------------------------------------------------------------------------------


+ **HackerRank**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Grading Students   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Operations In Heap   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Jesse And Cookies   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    ------------------------------------------------------------------------------

------------------------------------------------------------------------------


### Compiler Design

Contains some **Compiler Design** Course Programs.

|   Topic/Question  |   C |   C++ |   Java    |   Python  |

|---------|:---------:|:---------:|:---------:|:---------:|

|   Elimination of Left Factoring   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

|   Elimination of Left Recursion|  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

|   Find First and Follow|  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

|   Find Lead and Trail|  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

|   Infix to Postfix|  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

|   Lexical Analyzer|  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

------------------------------------------------------------------------------


### Data-Structures

Contains implementation of some popular **Data Structures** and related problems.

+ **Binary Search Tree**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Binary Search Tree Implementation   |  
 [ ] 
  |   
 [x] 
 |  
 [x] 
  |  
 [ ] 
  |

    ------------------------------------------------------------------------------


+ **Binary Tree**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Binary Tree Implementation   |  
 [ ] 
  |   
 [x] 
 |  
 [x] 
  |  
 [x] 
  |

    ------------------------------------------------------------------------------


+ **Circular Linked List**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Circular Linked List Implementation   |  
 [x] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [ ] 
  |

    ------------------------------------------------------------------------------


+ **Data Structures Problems**

    + **Arrays**

        |   Topic/Question  |   C |   C++ |   Java    |   Python  |

        |---------|:---------:|:---------:|:---------:|:---------:|

        |   Add Alternate Elements of 2D Array   |  
 [ ] 
  |   
 [x] 
 |  
 [x] 
  |  
 [ ] 
  |

        |   Akash and the Assignment   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        |   Converting a Sequence to Another   |  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

        |   Find the String   |  
 [ ] 
  |   
 [x] 
 |  
 [x] 
  |  
 [ ] 
  |

        |   Fredo and Large Numbers   |  
 [ ] 
  |   
 [x] 
 |  
 [x] 
  |  
 [x] 
  |

        |   Honey Bees   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        |   Left or Right   |  
 [ ] 
  |   
 [x] 
 |  
 [x] 
  |  
 [ ] 
  |

        |   Little Jhool and World Tour   |  
 [ ] 
  |   
 [x] 
 |  
 [x] 
  |  
 [x] 
  |

        |   Micro and Array Update   |  
 [ ] 
  |   
 [x] 
 |  
 [x] 
  |  
 [x] 
  |

        |   Micro and Sweet Distribution   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        |   Professor and his Operations   |  
 [ ] 
  |   
 [x] 
 |  
 [x] 
  |  
 [x] 
  |

        |   Remove Duplicates   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Roy and Symmetric Logos   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        |   Saul Goodman's Problem Statement   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        |   Sorting the Skills   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Submatrix Updates   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        |   Symmetric Matrix   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        |   The Wealthy Landlord   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        |   Unique Subarrays   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        ------------------------------------------------------------------------------


    + **Graphs**

        |   Topic/Question  |   C |   C++ |   Java    |   Python  |

        |---------|:---------:|:---------:|:---------:|:---------:|

        |   Monk at the Graph Factory   |  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

        ------------------------------------------------------------------------------


    + **Linked List**

        |   Topic/Question  |   C |   C++ |   Java    |   Python  |

        |---------|:---------:|:---------:|:---------:|:---------:|

        |   Add Two Numbers Represented by a Linked List   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Add K Nodes   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Check Palindrome   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Delete From End   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Delete From Start   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Delete Node with Key   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Delete Node without Head   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Detect Loop   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Find Mid Element   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Flatten a Linked List   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Get Nth Node From Last   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Implement Queue Using Linked List   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Intersection Point in Y Shaped Linked List   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Make Maximum Number   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Merge Reverse   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Merge Two Sorted Linked List   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Merge Sort   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [x] 
  |

        |   Merge Two List   |  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

        |   Pairwise Swap Elements   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Remove Loop   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Reverse a Linked List   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Reverse in group of given size   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Rotate Counter Clockwise   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Stack Implementation   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        ------------------------------------------------------------------------------


    + **Matrices**

        |   Topic/Question  |   C |   C++ |   Java    |   Python  |

        |---------|:---------:|:---------:|:---------:|:---------:|

        |   Print Elements in Spiral   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        |   Print Elements in ZigZag   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        ------------------------------------------------------------------------------


    + **Stack**

        |   Topic/Question  |   C |   C++ |   Java    |   Python  |

        |---------|:---------:|:---------:|:---------:|:---------:|

        |   Facitoo and Bridge   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        ------------------------------------------------------------------------------


    + **Strings**

        |   Topic/Question  |   C |   C++ |   Java    |   Python  |

        |---------|:---------:|:---------:|:---------:|:---------:|

        |   Different Names   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [x] 
  |

        |   Find the String   |  
 [ ] 
  |   
 [x] 
 |  
 [x] 
  |  
 [ ] 
  |

        |   Love of Characters   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Non Repeating Character   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   String Occurence   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        ------------------------------------------------------------------------------


    + **Trees**

        |   Topic/Question  |   C |   C++ |   Java    |   Python  |

        |---------|:---------:|:---------:|:---------:|:---------:|

        |   Bottom View of Binary Tree   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   BST to Tree with sum of all Keys   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        |   Check if 2 trees are identical   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Check if tree is BST   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Check if tree is symmetric   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Correct a Binary Tree   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        |   Diameter of a Binary Tree   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        |   Distinct Count   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        |   Find Max Subtree Sum   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        |   Kth Latgest Element   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        |   Kth Smallest Element   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        |   Lowest Common Ancestor in BST   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Maximum path Sum   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        |   Merge 2 BST with Limited Extra Space   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        |   Monk and his Friends   |  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

        |   Monk watching Fight   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        |   Number of Balanced BST   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Print Left View of Binary Tree   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Print Level Order in Spiral Form   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Print Path with given Sum   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        |   Print Tree in Vertical Order   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

        |   Yatin plays PUBG   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        ------------------------------------------------------------------------------


    + **Tree Traversal**

        |   Topic/Question  |   C |   C++ |   Java    |   Python  |

        |---------|:---------:|:---------:|:---------:|:---------:|

        |   InOrder Traversal   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        |   Level Order Traversal   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        |   Post Order Traversal   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        |   Pre Order Traversal   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

        ------------------------------------------------------------------------------


    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Facitoo and College   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Facitoo and Bridge   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Facitoo and Melon   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    ------------------------------------------------------------------------------


+ **Doubly Linked List**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Doubly Linked List Implementation   |  
 [x] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [ ] 
  |

    ------------------------------------------------------------------------------


+ **Heaps**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Max Heap Implementation   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Min Heap Implementation   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    ------------------------------------------------------------------------------


+ **Linked List**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Linked List Implementation   |  
 [x] 
  |   
 [x] 
 |  
 [x] 
  |  
 [x] 
  |

    ------------------------------------------------------------------------------


+ **Queues**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Queue Implementation   |  
 [ ] 
  |   
 [x] 
 |  
 [x] 
  |  
 [ ] 
  |

    ------------------------------------------------------------------------------


+ **Stacks**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Stack Implementation   |  
 [ ] 
  |   
 [x] 
 |  
 [x] 
  |  
 [x] 
  |

    ------------------------------------------------------------------------------

------------------------------------------------------------------------------


### Fast IO

Contains some **Competitive Programming** tips for faster Input/Output.

|   Topic/Question  |   C |   C++ |   Java    |   Python  |

|---------|:---------:|:---------:|:---------:|:---------:|

|   C++   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

|   Java|  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

------------------------------------------------------------------------------


### Interview Preparation

Contains some **Interview Preparation** related programs.

+ **HackerRank-Interview Preparation Kit**

    + **Arrays**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   2D Arrays-DS   |  
 [x] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Left Rotation|  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

    |   Minimum Swaps 2|  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    ------------------------------------------------------------------------------


    + **String Manipulation**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Alternating Characters   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Making Anagrams|  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Sherlock and the Valid String|  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

    ------------------------------------------------------------------------------


    + **Warm-up Challenges**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Counting Valleys   |  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

    |   Jumping on the Clouds|  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Repeated String|  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

    |   Sock Merchant|  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

    ------------------------------------------------------------------------------


+ **Practice-Questions**

    |   Topic/Question  |   C |   C++ |   Java    |   Python  |

    |---------|:---------:|:---------:|:---------:|:---------:|

    |   Count Distinct Array Elements   |  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Euler Circuit in a graph|  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Jason Fights Monsters|  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Lucky Four   |  
 [x] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [ ] 
  |

    |   Migratory Birds|  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Order of a String|  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Pattern Freq   |  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

    |   Permutations Of a String|  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

    |   Triangle of Stars|  
 [x] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [ ] 
  |

    ------------------------------------------------------------------------------


------------------------------------------------------------------------------

### Patterns

Contains some popular **Patterns** related programs.

|   Topic/Question  |   C |   C++ |   Java    |   Python  |

|---------|:---------:|:---------:|:---------:|:---------:|

|   Pattern 1   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

|   Pattern 2|  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

|   Pattern 3|  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [ ] 
  |

------------------------------------------------------------------------------


### Project Euler

Contains some **Project Euler** programs.

|   Topic/Question  |   C |   C++ |   Java    |   Python  |

|---------|:---------:|:---------:|:---------:|:---------:|

|   Problem 1   |  
 [ ] 
  |   
 [x] 
 |  
 [x] 
  |  
 [x] 
  |

|   Problem 2|  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [x] 
  |

|   Problem 3|  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [x] 
  |

|   Problem 4   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [x] 
  |

|   Problem 5|  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [x] 
  |

|   Problem 6|  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

|   Problem 7   |  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

|   Problem 8|  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

|   Problem 9|  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

|   Problem 10   |  
 [ ] 
  |   
 [x] 
 |  
 [ ] 
  |  
 [x] 
  |

|   Problem 11|  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

|   Problem 12|  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

|   Problem 13   |  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

|   Problem 14|  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

|   Problem 15|  
 [ ] 
  |   
 [ ] 
 |  
 [ ] 
  |  
 [x] 
  |

|   Problem 16|  
 [ ] 
  |   
 [ ] 
 |  
 [x] 
  |  
 [ ] 
  |

------------------------------------------------------------------------------


< /> with ♥ by Tanay Toshniwal©