Skip to content

Latest commit

 

History

History
76 lines (49 loc) · 4.55 KB

README.md

File metadata and controls

76 lines (49 loc) · 4.55 KB
Raw

Just-DSA

Welcome to just-dsa containing a collection of data structure and algorithm problems. This repository is organized into different directories, each focusing on a specific category of problems. Here's a brief overview of what you'll find:

Problem Categories:

  • arrays-and-strings: Problems related to arrays and strings.
  • binary-search: Problems that involve binary search algorithms.
  • concurrency: Problems related to concurrent programming.
  • graph: Problems involving graphs and graph algorithms.
  • intervals: Problems dealing with intervals and ranges.
  • math: Problems related to mathematical algorithms and concepts.
  • queue: Problems involving queues.
  • sliding-window: Problems that can be solved using the sliding window technique.
  • stack: Problems involving stacks.
  • two-pointers: Problems that can be solved using the two pointers technique.
  • back-tracking: Problems that can be solved using backtracking algorithms.
  • bit-ops: Problems related to bitwise operations.
  • dynamic-programming: Problems that can be solved using dynamic programming techniques.
  • greedy: Problems that can be solved using greedy algorithms.
  • linked-list: Problems involving linked lists.
  • prefix-sums: Problems that can be solved using prefix sums.
  • sort: Problems related to sorting algorithms.
  • time-series: Problems related to time series data.

Problem Categories Descriptions:

  1. Arrays and Strings: Fundamental data structures used to store and manipulate collections of elements and sequences of characters, respectively.

  2. Binary Search: An efficient search algorithm used to find the position of a target value within a sorted array.

  3. Concurrency: The ability of a system to handle multiple tasks simultaneously, often achieved through techniques such as multithreading and multiprocessing.

  4. Graphs: Abstract data structures consisting of nodes (vertices) and edges that connect them, used to represent relationships between objects.

  5. Intervals: Representations of continuous ranges of values or time periods.

  6. Math: Various mathematical algorithms and concepts, including arithmetic operations, number theory, geometry, and more.

  7. Queue: A data structure that follows the First-In-First-Out (FIFO) principle, where elements are added to the back and removed from the front.

  8. Sliding Window: A technique used to solve problems involving arrays or strings by maintaining a subset of elements within a fixed window size.

  9. Stack: A data structure that follows the Last-In-First-Out (LIFO) principle, where elements are added and removed from the same end.

  10. Two Pointers: A technique used to solve problems by iterating through an array or list using two pointers, often to find a certain pattern or sum.

  11. Backtracking: A recursive algorithmic technique that involves systematically exploring all possible solutions to a problem by making choices at each step.

  12. Bitwise Operations: Operations performed on individual bits of binary numbers, commonly used in low-level programming and optimization.

  13. Dynamic Programming: A technique used to solve problems by breaking them down into simpler subproblems and solving each subproblem only once, storing the solutions to avoid redundant computations.

  14. Greedy Algorithms: Algorithms that make locally optimal choices at each step with the hope of finding a global optimum solution.

  15. Linked List: A linear data structure consisting of a sequence of elements where each element points to the next one in the sequence.

  16. Prefix Sums: A technique used to efficiently calculate cumulative sums of elements in an array.

  17. Sort: Algorithms used to arrange elements of a list or array in a particular order, such as numerical or lexicographical order.

  18. Time Series: Data organized in chronological order, often used in statistics, finance, and other fields to analyze trends over time.

Each directory contains its own README.md file with a list of problems specific to that category. Feel free to explore, solve, and contribute to this repository!

How to Contribute:

Contributions are welcome! If you have a new problem to add or have found a bug in an existing one, please follow these steps:

  1. Fork this repository.
  2. Create a new branch for your changes.
  3. Make your modifications.
  4. Test your changes if applicable.
  5. Submit a pull request with a descriptive title and detailed explanation of your changes.

Thank you for contributing to this repository and happy problem-solving.