├── .vscode ├── c_cpp_properties.json └── settings.json ├── 01-introduction-to-c++ ├── README.md └── modules │ ├── 001-basics │ ├── README.md │ ├── assets │ │ ├── Basics-Variables-IO.pdf │ │ ├── Conditionals-Loops.pdf │ │ ├── FlowCharts.pdf │ │ └── Functions.pdf │ └── code │ │ ├── 001-C++-Intro.cpp │ │ ├── 002-Datatype.cpp │ │ ├── 003-IO.cpp │ │ ├── 004-Oper-Arithmatic-Relational-Logical.cpp │ │ ├── 005-Oper-Bitwise.cpp │ │ ├── 006-Conditions.cpp │ │ └── 007-Functions.cpp │ ├── 002-loops │ ├── README.md │ ├── assets │ │ ├── Conditionals-And-Loops.pdf │ │ ├── Operators-And-For-Loop.pdf │ │ └── Patterns.pdf │ ├── code-part-1 │ │ ├── 001-Check-Number-If-Prime.cpp │ │ ├── 002-Sum-Of-Even-Numbers-Till-N.cpp │ │ ├── 003-Farenheit-To-Celcius-Table.cpp │ │ ├── 004-Number-Pattern-1.cpp │ │ ├── 005-Number-Pattern-2.cpp │ │ ├── 006-Star-Pattern.cpp │ │ ├── 007-Total-Salary.cpp │ │ ├── 008-Sum-Of-Even-Odd.cpp │ │ └── 009-Find-Power-Of-Number.cpp │ ├── code-part-2 │ │ ├── 001-Square-Pattern.cpp │ │ ├── 002-Triangular-Star-Pattern.cpp │ │ ├── 003-Triangle-Number-Pattern.cpp │ │ ├── 004-Reverse-Number-Pattern.cpp │ │ ├── 005-Character-Pattern-Basic.cpp │ │ ├── 006-Alpha-Pattern.cpp │ │ ├── 007-Character-Pattern.cpp │ │ └── 008-Interesting-Pattern.cpp │ ├── code-part-3 │ │ ├── 001-Reverse-Triangle.cpp │ │ ├── 002-Mirror-Number-Pattern.cpp │ │ ├── 003-Inverted-Triangle.cpp │ │ ├── 004-Inverted-Number-Pattern.cpp │ │ ├── 005-Isoceles-Triangle.cpp │ │ ├── 006-Star-Pattern.cpp │ │ ├── 007-Triangle-Of-Numbers.cpp │ │ ├── 008-Diamond-Of-Stars.cpp │ │ ├── 009-Pattern-Medium-1.cpp │ │ ├── 010-Pattern-Medium-2.cpp │ │ └── 011-Pattern-Medium-3.cpp │ └── code-part-4 │ │ ├── 001-Nth-Fibonicci-Number.cpp │ │ ├── 002-All-Prime-Numers.cpp │ │ ├── 003-Count-Characters.cpp │ │ ├── 004-Sum-Or-Product.cpp │ │ ├── 005-Terms-Of-AP.cpp │ │ ├── 006-Reverse-Of-Number.cpp │ │ ├── 007-Binary-To-Decimal.cpp │ │ ├── 008-Decimal-To-Binary.cpp │ │ ├── 009-Square-Root-Integral.cpp │ │ └── 010-Check-Number-Sequence.cpp │ ├── 003-test-1 │ ├── README.md │ └── code │ │ ├── 001-Guess-Output.cpp │ │ ├── 002-Pyramid-Star-Pattern.cpp │ │ ├── 003-Number-Star-Pattern.cpp │ │ └── 004-Second-Largest.cpp │ ├── 004-arrays │ ├── README.md │ ├── assets │ │ ├── Arrays.pdf │ │ └── Character-And-2D-Arrays.pdf │ ├── code-part-1 │ │ ├── 001-Array-Sum.cpp │ │ ├── 002-Linear-Search.cpp │ │ ├── 003-Arrange-Numbers-In-Array.cpp │ │ ├── 004-Swap-Alternate.cpp │ │ ├── 005-Find-Unique.cpp │ │ ├── 006-Find-Duplicate.cpp │ │ ├── 007-Array-Intersection.cpp │ │ ├── 008-Pair-Sum.cpp │ │ ├── 009-Triplet-Sum.cpp │ │ └── 010-Sort-01.cpp │ ├── code-part-2 │ │ ├── 001-1D-Char-Array.cpp │ │ ├── 002-Check-Palindrome.cpp │ │ ├── 003-Replace-Character.cpp │ │ ├── 004-Trim-Spaces.cpp │ │ └── 005-Reverse-Word.cpp │ ├── code-part-3 │ │ ├── 001-Basic-2D-Arrays.cpp │ │ ├── 002-Column-Wise-Sum.cpp │ │ ├── 003-Largest-Row-Or-Column.cpp │ │ ├── 004-Wave-Print.cpp │ │ └── 005-Spiral-Print.cpp │ └── code-part-4 │ │ ├── 001-Check-Permutation.cpp │ │ ├── 002-Remove-Consecutive-Duplicates.cpp │ │ ├── 003-Reverse-Each-Word.cpp │ │ ├── 004-Remove-Character.cpp │ │ ├── 005-Highest-Occuring-Character.cpp │ │ └── 006-Compress-The-String.cpp │ ├── 005-searching-sorting │ ├── README.md │ ├── assets │ │ └── Searching-And-Sorting.pdf │ └── code │ │ ├── 001-Binary-Search.cpp │ │ ├── 002-Selection-Sort.cpp │ │ ├── 003-Bubble-Sort.cpp │ │ ├── 004-Insertion-Sort.cpp │ │ ├── 005-Merge-Two-Sorted-Arrays.cpp │ │ ├── 006-Push-Zeros-To-End.cpp │ │ ├── 007-Rotate-Array.cpp │ │ ├── 008-Second-Largest-Element.cpp │ │ ├── 009-Check-Array-Rotation.cpp │ │ ├── 010-Sort-012.cpp │ │ └── 011-Sum-Of-Two-Arrays.cpp │ ├── 006-string │ ├── README.md │ └── code │ │ ├── 001-Basics.cpp │ │ └── 002-Print-All-Substrings.cpp │ └── 007-test-2 │ ├── README.md │ └── code │ ├── 001-Print-2D-Array.cpp │ ├── 002-Minimum-Length-Word.cpp │ └── 003-Leaders-In-Array.cpp ├── 02-data-structure-algorithms ├── README.md └── modules │ ├── 001-basics │ ├── README.md │ ├── assets │ │ └── pointers.pdf │ └── code │ │ ├── 001-Basics-Pointers.cpp │ │ ├── 002-Assignments-Pointers.cpp │ │ ├── 003-Type-Casting.cpp │ │ ├── 004-Dynamic-Memory.cpp │ │ ├── 005-Pass-By-Reference.cpp │ │ ├── 006-GlobalVariables-Constant.cpp │ │ └── 007-Vector-Usage.cpp │ ├── 002-recursion │ ├── README.md │ ├── assets │ │ └── Recursion.pdf │ ├── code-part-1 │ │ ├── 001-Factorial.cpp │ │ ├── 002-Power.cpp │ │ ├── 003-Print-Numbers.cpp │ │ ├── 004-Number-Of-Digits.cpp │ │ ├── 005-Nth-Number.cpp │ │ ├── 006-Check-If-Array-Is-Sorted.cpp │ │ ├── 007-Sum-Of-Array.cpp │ │ ├── 008-Check-Number.cpp │ │ ├── 009-First-Index-Of-Number.cpp │ │ ├── 010-Last-Index-Of-Number.cpp │ │ ├── 011-All-Indices-Of-Number.cpp │ │ ├── 012-Multiplication-Recursive.cpp │ │ ├── 013-Count-Zeros.cpp │ │ ├── 014-Geometric-Sum.cpp │ │ ├── 015-Check-Palindrome.cpp │ │ └── 016-Sum-Of-Digits.cpp │ ├── code-part-2 │ │ ├── 001-Replace-Pi.cpp │ │ ├── 002-Remove-X.cpp │ │ ├── 003-String-To-Integer.cpp │ │ ├── 004-Pair-Star.cpp │ │ ├── 005-Tower-Of-Hanoi.cpp │ │ ├── 006-Replace-Character-recursive.cpp │ │ ├── 007-Remove-Duplicates-Recursive.cpp │ │ ├── 008-Merge-Sort.cpp │ │ └── 009-Quick-Sort.cpp │ └── code-part-3 │ │ ├── 001-Strings.cpp │ │ ├── 002-All-SubSequences.cpp │ │ ├── 003-Return-Keypad-Codes.cpp │ │ ├── 004-Print-Keypad-Code.cpp │ │ ├── 005-Check-AB.cpp │ │ ├── 006-StairCase.cpp │ │ ├── 007-Binary-Search-Recursive.cpp │ │ ├── 008-Return-Subsets-Of-Array.cpp │ │ ├── 009-Print-Subsets-Of-Array.cpp │ │ ├── 010-Return-Subsets-Sum-To-K.cpp │ │ ├── 011-Print-Subsets-Sum-To-K.cpp │ │ ├── 012-Return-All-Codes.cpp │ │ ├── 013-Print-All-Codes.cpp │ │ ├── 014-Return-Permutations.cpp │ │ └── 015-Print-Permutations.cpp │ ├── 003-complexity │ ├── README.md │ ├── assets │ │ └── Time-Complexity.pdf │ └── code │ │ ├── 001-Basic-Guess-Output.cpp │ │ ├── 002-Find-Unique-Element.cpp │ │ ├── 003-Duplicate-In-An-Array.cpp │ │ ├── 004-Array-Intersection.cpp │ │ ├── 005-Pair-Sum-In-Array.cpp │ │ ├── 006-Triplet-Sum.cpp │ │ ├── 007-Rotate-Array.cpp │ │ └── 008-Check-Array-Rotation.cpp │ ├── 004-test-1 │ ├── README.md │ └── code │ │ ├── 001-MCQ.cpp │ │ ├── 002-Does-S-Contains-T.cpp │ │ ├── 003-Maximum-Profit-App.cpp │ │ └── 004-Split-Array.cpp │ ├── 005-oops │ ├── README.md │ ├── assets │ │ ├── OOPS-1-Classes-Members-Constructor-this.pdf │ │ ├── OOPS-3-Exception-Handling.pdf │ │ └── inheritance-1.png │ ├── code-part-1 │ │ ├── 001-Play-With-Classes-Assignments.cpp │ │ ├── 002-Fraction-Class.cpp │ │ └── 003-Complex-Number.cpp │ ├── code-part-2 │ │ ├── 001-Play-With-Constructors.cpp │ │ ├── 002-Deep-Shallow-Copy.cpp │ │ ├── 003-Const-Static-Members.cpp │ │ ├── 004-Assignments-Constructor-Static-Const.cpp │ │ ├── 005-Operator-Overloading-Fraction-Class.cpp │ │ └── 006-Polynomial-Class.cpp │ └── code-part-3 │ │ ├── 001-Inheritance.cpp │ │ ├── 002-Polymorphism.cpp │ │ └── 003-Virtual-Abstract-Friend.cpp │ ├── 006-linkedlist │ ├── README.md │ ├── code-part-1 │ │ ├── 001-SinglyLinkedList-Impl.cpp │ │ ├── 002-Guess-Output.cpp │ │ ├── 003-Print-ith-Node.cpp │ │ ├── 004-Delete-Node.cpp │ │ ├── 005-Length-LinkedList-Recursive.cpp │ │ ├── 006-Insert-Node-Recursive.cpp │ │ ├── 007-Delete-Node-Recursive.cpp │ │ ├── 008-Find-Node.cpp │ │ ├── 009-Append-Last-N-To-First.cpp │ │ ├── 010-Eliminate-Duplicates-From-LL.cpp │ │ ├── 011-Print-Reverse-LinkedList.cpp │ │ └── 012-Palindrome-LinkedList.cpp │ └── code-part-2 │ │ ├── 001-Mid-Point-LinkedList.cpp │ │ ├── 002-Merge-Two-Sorted-LinkedList.cpp │ │ ├── 003-Merge-Sort.cpp │ │ ├── 004-Reverse-LinkedList-Recursive.cpp │ │ ├── 005-Find-Node-In-LinkedList-Recursive.cpp │ │ ├── 006-Even-After-Odd-LinkedList.cpp │ │ ├── 007-Delete-Every-N-Nodes.cpp │ │ ├── 008-Swap-Two-Nodes-LinkedList.cpp │ │ ├── 009-kReverse.cpp │ │ └── 010-Bubble-Sort-Iterative.cpp │ ├── 007-stack │ ├── README.md │ └── code │ │ ├── 001-Stack-Impl-Arrays.cpp │ │ ├── 002-Stack-Impl-LinkedList.cpp │ │ ├── 003-Balanced-Parenthesis.cpp │ │ ├── 004-Reverse-Stack.cpp │ │ ├── 005-Check-Redundant-Brackets.cpp │ │ ├── 006-Stock-Span.cpp │ │ └── 007-Minimum-Brackets-Reversal.cpp │ ├── 008-queue │ ├── README.md │ └── code │ │ ├── 001-Queue-Impl-Array.cpp │ │ ├── 002-Queue-Impl-LinkedList.cpp │ │ └── 003-Reverse-Queue.cpp │ ├── 009-test-2 │ ├── README.md │ └── code │ │ ├── 001-Next-Number.cpp │ │ ├── 002-Deque.cpp │ │ └── 003-Delete-Alternate-Nodes.cpp │ ├── 010-trees │ ├── README.md │ └── code │ │ ├── 001-Print-Tree-Recursive.cpp │ │ ├── 002-Print-Tree-Level-Order-Traversal.cpp │ │ ├── 003-Count-Number-Of-Nodes.cpp │ │ ├── 004-Find-Sum-Of-Nodes.cpp │ │ ├── 005-Max-Data-Node.cpp │ │ ├── 006-Find-Height.cpp │ │ ├── 007-Count-Leaf-Nodes.cpp │ │ ├── 008-Print-Pre-Post-Traversal.cpp │ │ ├── 009-Contains-X.cpp │ │ ├── 010-Count-Nodes.cpp │ │ ├── 011-Node-With-Max-Child-Sum.cpp │ │ ├── 012-Structurally-Identical.cpp │ │ ├── 013-Next-Larger.cpp │ │ ├── 014-SecondLargest-Element.cpp │ │ └── 015-Replace-With-Depth.cpp │ ├── 011-binary-trees │ ├── README.md │ └── code │ │ ├── 001-Print-BinaryTree-Recursive.cpp │ │ ├── 002-Print-Level-Order-Traversal.cpp │ │ ├── 003-Count-Nodes.cpp │ │ ├── 004-Find-Node.cpp │ │ ├── 005-Height-Of-Binary-Tree.cpp │ │ ├── 006-Mirror.cpp │ │ ├── 007-Pre-Post-In-Order-Traversal.cpp │ │ ├── 008-Construct-Tree-From-PreOrder-InOrder.cpp │ │ ├── 009-Construct-Tree-From-PostOrder-InOrder.cpp │ │ ├── 010-Diameter-Of-Binary-Tree.cpp │ │ ├── 011-Min-Max-In-Binary-Tree.cpp │ │ ├── 012-Sum-Of-Nodes.cpp │ │ ├── 013-Check-Balanced.cpp │ │ ├── 014-Level-Order-Traversal.cpp │ │ ├── 015-Remove-Leaf-Nodes.cpp │ │ ├── 016-Level-Wise-LinkedList.cpp │ │ ├── 017-ZigZag-Tree.cpp │ │ └── 018-Nodes-Without-Siblings.cpp │ ├── 012-binary-search-trees │ ├── README.md │ └── code │ │ ├── 001-BST-Impl.cpp │ │ ├── 002-Search-Node-BST.cpp │ │ ├── 003-Print-Elements-In-Range.cpp │ │ ├── 004-Check-BST.cpp │ │ ├── 005-Construct-BST-From-Sorted-Array.cpp │ │ ├── 006-BST-To-Sorted-Linked-List.cpp │ │ ├── 007-Root-To-Node-Path.cpp │ │ ├── 008-Find-Path-In-BST.cpp │ │ ├── 009-Create-And-Insert-Duplicate-Node.cpp │ │ ├── 010-Pair-Sum-Binary-Tree.cpp │ │ ├── 011-LCA-Of-Binary-Tree.cpp │ │ ├── 012-LCA-Of-BST.cpp │ │ ├── 013-Largest-BST.cpp │ │ ├── 014-Replace-With-Sum-Of-Greater-Nodes.cpp │ │ ├── 015-Path-Sum-To-Root.cpp │ │ ├── 016-Print-Nodes-At-Distance-K.cpp │ │ └── 017-Pair-Sum-In-BST.cpp │ ├── 013-test-3 │ ├── README.md │ └── code │ │ ├── 001-Check-Cousin.cpp │ │ ├── 002-Longest-Leaf-To-Root-Path.cpp │ │ ├── 003-Remove-Leaf-Node.cpp │ │ └── BinaryTreeNode.h │ ├── 014-priority-queue │ ├── README.md │ └── code │ │ ├── 001-Min-Priority-Queue-Impl.cpp │ │ ├── 002-Max-Priority-Queue-Impl.cpp │ │ ├── 003-Heap-Sort.cpp │ │ ├── 004-InBuilt-PQ-Usage.cpp │ │ ├── 005-K-Sorted-Array.cpp │ │ ├── 006-K-Smallest-Elements.cpp │ │ ├── 007-K-Largest-Elements.cpp │ │ ├── 008-Check-Max-Heap.cpp │ │ ├── 009-Kth-Largest-Element.cpp │ │ ├── 010-Merge-K-Sorted-Arrays.cpp │ │ ├── 011-Running-Median.cpp │ │ └── 012-Buy-The-Ticket.cpp │ ├── 015-hashmap │ ├── README.md │ └── code │ │ ├── 001-HashMap-Impl.cpp │ │ ├── 002-Basic-Usage.cpp │ │ ├── 003-Remove-Duplicates.cpp │ │ ├── 004-Maximum-Frequency-Number.cpp │ │ ├── 005-Print-Intersection.cpp │ │ ├── 006-Pair-Sum.cpp │ │ ├── 007-Extract-Unique-Characters.cpp │ │ ├── 008-Longest-Consecutive-Sequence.cpp │ │ ├── 009-Pairs-With-Diff-K.cpp │ │ └── 010-Largest-Subset-Zero-Sum.cpp │ ├── 016-tries │ ├── README.md │ ├── code │ │ ├── 001-Trie-Implementation.cpp │ │ ├── 002-Pattern-Matching.cpp │ │ ├── 003-Palindrome-Pair.cpp │ │ └── 004-Auto-Complete.cpp │ └── images │ │ └── trie-1.png │ ├── 017-dynamic-programming │ ├── README.md │ ├── code-part-1 │ │ ├── 001-Fibonicci.cpp │ │ ├── 002-Count-Setps-To-One.cpp │ │ ├── 003-StairCase.cpp │ │ ├── 004-Minimum-Count.cpp │ │ └── 005-Num-Balanced-BTs.cpp │ └── code-part-2 │ │ ├── 001-Min-Cost-Path.cpp │ │ ├── 002-lcs.cpp │ │ ├── 003-Edit-Distance.cpp │ │ ├── 004-knapsack.cpp │ │ ├── 005-Loot-Houses.cpp │ │ ├── 006-longest-incresing-subsequence.cpp │ │ ├── 007-All-Possible-Ways.cpp │ │ ├── 008-Ways-To-Make-Coin-Change.cpp │ │ ├── 009-Matrix-Chain-Multiplication.cpp │ │ ├── 010-Coin-Tower.cpp │ │ ├── 011-Max-Square-Matrix-With-Zeros.cpp │ │ └── 012-Shortest-Subsequence.cpp │ ├── 018-graphs │ ├── README.md │ ├── code-part-1 │ │ ├── 001-Print-Nodes-DFS.cpp │ │ ├── 002-Print-Nodes-BFS.cpp │ │ ├── 003-Has-Path.cpp │ │ ├── 004-Get-Path-DFS.cpp │ │ ├── 005-Get-Path-BFS.cpp │ │ ├── 006-Is-Connected.cpp │ │ ├── 007-All-Connected-Components.cpp │ │ ├── 008-Islands.cpp │ │ ├── 009-CodingNinjas.cpp │ │ ├── 010-Connecting-Dots.cpp │ │ ├── 011-Largest-Piece.cpp │ │ └── 012-3-Cycle.cpp │ └── code-part-2 │ │ ├── 001-Kruskals-Algo.cpp │ │ ├── 002-Prims-Algo.cpp │ │ └── 003-Dijkstra-Algo.cpp │ ├── 019-backtracking │ ├── README.md │ └── code │ │ ├── 001-N-Queen.cpp │ │ ├── 002-Rat-In-A-Maze.cpp │ │ ├── 003-Crossword.cpp │ │ ├── 004-Sudoku.cpp │ │ └── 005-Subsets-Sum.cpp │ └── 020-misc-skill-tests │ ├── README.md │ ├── code-skill-test-1 │ ├── 001-Number-Star-Patter.cpp │ ├── 002-Donuts.cpp │ ├── 003-Maximum-Subarray-Sum.cpp │ └── 004-One-Strings.cpp │ ├── code-skill-test-2 │ ├── 001-Power.cpp │ ├── 002-All-Possible-Ways.cpp │ ├── 003-Binary-Play.cpp │ └── 004-Quadruplet-Sum.cpp │ ├── code-skill-test-3 │ ├── 002-Symmetric-Binary-Tree.cpp │ ├── 003-War-On-NinjaLand.cpp │ ├── 004-Find-The-Celebrity.cpp │ └── InBetweenLinkedList_1.java │ └── code-skill-test-4 │ ├── 002-White-SubTree.cpp │ ├── 003-Jumping-Ninja.cpp │ ├── 004-Help-Pradyumana.cpp │ └── SpyAmongUs.java ├── 03-competitive-programming ├── README.md └── modules │ ├── 001-prerequisite │ ├── README.md │ ├── code │ │ ├── 001-Add-Numbers-Out-In-File.cpp │ │ ├── 002-Calculate-Area-Of-Intersection.cpp │ │ ├── 003-Print-Zig-Zag-Array.cpp │ │ ├── 004-Even-And-Odd-Indexes.cpp │ │ ├── 005-Total-Sum-Boundaries-Diagonals.cpp │ │ ├── 006-PRE4.cpp │ │ ├── 007-Target-Marbles.cpp │ │ └── 008-Oscillating-Prices-Of-Chakri.cpp │ └── io │ │ ├── addin.txt │ │ ├── addout.txt │ │ ├── areain.txt │ │ ├── areaout.txt │ │ ├── zigzag_array_in.txt │ │ └── zigzag_array_out.txt │ ├── 002-pointers │ ├── README.md │ ├── assets │ │ └── pointers.pdf │ └── code │ │ ├── 001-Pointers.cpp │ │ ├── 002-Pointer-Arithmetic.cpp │ │ ├── 003-Arrays-And-Pointers.cpp │ │ ├── 004-Character-Pointers.cpp │ │ ├── 005-Pointers-And-Functions.cpp │ │ └── 006-Double-Pointers.cpp │ ├── 003-dynamic-allocation │ ├── README.md │ └── code │ │ ├── 001-Address-Typecasting.cpp │ │ ├── 002-Pass-By-Reference.cpp │ │ ├── 003-Dynamic-Memory-Allocation.cpp │ │ ├── 004-Macros-Global-Vars.cpp │ │ ├── 005-Inline-Default-Arguments.cpp │ │ └── 006-Constant-Vars.cpp │ ├── 004-recursion │ ├── README.md │ ├── assets │ │ └── recursion.pdf │ └── code │ │ ├── 001-Factorial.cpp │ │ ├── 002-Power.cpp │ │ ├── 003-Print-Numbers.cpp │ │ ├── 004-Number-Of-Digits.cpp │ │ ├── 005-Fibonicci.cpp │ │ ├── 006-Guess-Output.cpp │ │ ├── 007-Check-If-Array-Sorted.cpp │ │ ├── 008-Sum-Of-Array.cpp │ │ ├── 009-Check-Number.cpp │ │ ├── 010-First-Index-Of-Number.cpp │ │ ├── 011-Last-Index-Of-Number.cpp │ │ └── 012-All-indices-Of-Number.cpp │ ├── 005-Complexity-And-Language-Tools │ ├── README.md │ ├── assets │ │ ├── CP-Notes-Language-Tools.pdf │ │ ├── Language-Tools-C++.pdf │ │ ├── Language-Tools-Java.pdf │ │ ├── Language-Tools-Python.pdf │ │ └── Time-Space-Complexity.pdf │ ├── code-part-1 │ │ ├── 001-Guess-Output.cpp │ │ ├── 002-Kadane-Algorithm.cpp │ │ ├── 003-K-Concatenation.cpp │ │ ├── 004-Maximum-Product-Subarray.cpp │ │ └── 005-Mindbending-Product.cpp │ ├── code-part-2 │ │ ├── 001-Hussain-Set.cpp │ │ ├── 002-Voters-List.cpp │ │ ├── 003-Permutation-And-Palindrome.cpp │ │ ├── 004-Love-For-Characters.cpp │ │ ├── 005-Different-Names.cpp │ │ ├── 006-Extract-Unique-Characters.cpp │ │ ├── 007-Warm-Reception.cpp │ │ └── 008-Tell-The-Positions.cpp │ └── code-part-3 │ │ ├── 001-Duplicate-In-Array.cpp │ │ ├── 002-Triplet-Sum.cpp │ │ ├── 003-Rotate-Array.cpp │ │ ├── 004-Find-Unique-Element.cpp │ │ ├── 005-Sum-Me-Up.cpp │ │ ├── 006-Pair-Sum-To-Zero.cpp │ │ └── 007-Longest-Consecutive-Sequence.cpp │ ├── 006-searching-sorting │ ├── README.md │ ├── assets │ │ └── Searching-And-Sorting-Applications.pdf │ └── code │ │ ├── 001-Aggressive-Cows.cpp │ │ ├── 002-Inversion-Count.cpp │ │ ├── 003-Chef-Restaurant.cpp │ │ ├── 004-Variation-Pairs.cpp │ │ ├── 005-Murder.cpp │ │ ├── 006-Distribute-Candies.cpp │ │ ├── 007-Momos-Market.cpp │ │ └── 008-Taj-Mahal-Entry.cpp │ ├── 007-Advance-Recursion │ ├── README.md │ ├── assets │ │ └── Advanced-Recursion.pdf │ └── code │ │ ├── 001-Length.cpp │ │ ├── 002-Replace-Character-Recursive.cpp │ │ ├── 003-Remove-Duplicates-Recursive.cpp │ │ ├── 004-Merge-Sort.cpp │ │ ├── 005-Quick-Sort.cpp │ │ ├── 006-Return-Subsequences.cpp │ │ ├── 007-Return-Keypad-Code.cpp │ │ ├── 008-Print-SubSequences.cpp │ │ └── 009-Print-Keypad-Combination.cpp │ ├── 008-Backtracking │ ├── README.md │ ├── assets │ │ └── Backtracking.pdf │ ├── code-part-1 │ │ ├── 001-nQueens.cpp │ │ ├── 002-RatInAMaze.cpp │ │ └── 003-Crossword.cpp │ └── code-part-2 │ │ ├── 001-Find-Power.cpp │ │ ├── 002-Sorting-Skills.cpp │ │ ├── 003-Collecting-Balls.cpp │ │ └── 004-Sudoku-Solver.cpp │ ├── 009-Bit-Manipulation │ ├── README.md │ ├── assets │ │ └── Bit-Manipulation.pdf │ └── code │ │ ├── 001-Bitwise-Operators.cpp │ │ ├── 002-Set-ith-Bit.cpp │ │ ├── 003-Unset-ith-Bit.cpp │ │ ├── 004-Flip-the-ith-Bit.cpp │ │ ├── 005-Check-If-Number-Even-Odd.cpp │ │ ├── 006-Check-Power-Of-Two.cpp │ │ ├── 007-Find-First-Set-Bit.cpp │ │ ├── 008-Turn-Off-The-First-Bit.cpp │ │ ├── 009-Clear-All-Bit-From-LSB.cpp │ │ └── 010-Clear-All-Bits-From-MSB.cpp │ ├── 010-Adhoc-Problems │ ├── README.md │ ├── assets │ │ └── Adhoc-Problems.pdf │ └── code │ │ ├── 001-Equalize.cpp │ │ ├── 002-Rectangular-Area.cpp │ │ ├── 003-Light-Up-The-Bulb.cpp │ │ ├── 004-Circular-List-Of-Students.cpp │ │ ├── 005-Interesting-Sequence.cpp │ │ └── 006-Winning-Strategy.cpp │ ├── 011-Modulo-Arithmetic │ ├── README.md │ ├── assets │ │ └── Modulo-Arithmetic.pdf │ └── code │ │ └── 001-Number-Of-Balanced-Trees.cpp │ ├── 012-Dynamic-Programming │ ├── README.md │ ├── assets │ │ ├── Dynamic-Programming-1.pdf │ │ └── Dynamic-Programming-2.pdf │ ├── code-part-1 │ │ ├── 001-Fibonicci.cpp │ │ ├── 002-AlphaCode.cpp │ │ ├── 003-longest-incresing-subsequence.cpp │ │ ├── 004-Longest-Bitionic-Subarray.cpp │ │ ├── 005-StairCase.cpp │ │ ├── 006-Coin-Change-Problem.cpp │ │ ├── 007-Min-Cost-Dp.cpp │ │ ├── 008-Get-Minimum-Strength.cpp │ │ ├── 009-Max-Sum-Rectangle.cpp │ │ ├── 010-Construct-Array.cpp │ │ └── 011-Sam-And-Substring.cpp │ ├── code-part-2 │ │ ├── 001-Loot-Houses.cpp │ │ ├── 002-Max-squares-with-all-zeros.cpp │ │ ├── 003-Cont-BSTs.cpp │ │ ├── 004-Boredom.cpp │ │ ├── 005-Min-Number-Of-Choclates.cpp │ │ ├── 006-Minimum-Count.cpp │ │ ├── 007-Hasan-And-Trip.cpp │ │ ├── 008-Vanya-And-GCD.cpp │ │ ├── 009-Adjacent-Bit-Counts.cpp │ │ ├── 010-Roy-And-Coin-Boxes.cpp │ │ ├── 011-Jon-Snow-And-Fav-Number.cpp │ │ ├── 012-Alyona-And-Spreadsheet.cpp │ │ └── 013-Angry-Children.cpp │ └── code-part-3 │ │ ├── 001-LCS.cpp │ │ ├── 002-Edit-Distance.cpp │ │ ├── 003-Balika-Vadhu.cpp │ │ ├── 004-knapsack.cpp │ │ ├── 005-Party.cpp │ │ ├── 006-Subset-Sum.cpp │ │ ├── 007-Miser-Man.cpp │ │ ├── 008-Trader-Profit.cpp │ │ ├── 009-Charlie-And-Pilots.cpp │ │ ├── 010-Square-Brackets.cpp │ │ ├── 011-Distinct-Subsequence.cpp │ │ ├── 012-Smallest-Super-Sequence.cpp │ │ └── 013-Shortest-Subsequence.cpp │ ├── 013-Greedy-Problems │ ├── README.md │ ├── assets │ │ └── Greedy-Problems.pdf │ └── code │ │ ├── 001-Min-Absolute-Diff-In-An-Array.cpp │ │ ├── 002-Nikunj-And-Donuts.cpp │ │ ├── 003-Activity-Selection.cpp │ │ ├── 004-Fractional-Knapsack.cpp │ │ ├── 005-Weighted-Job-Scheduling.cpp │ │ ├── 006-Perimeter-With-Conditions.cpp │ │ ├── 007-Problem-Discussion.cpp │ │ └── 008-Winning-Lottery.cpp │ ├── 014-Segment-Trees │ ├── README.md │ ├── assets │ │ └── Segment-Trees.pdf │ └── code │ │ ├── 001-Segment-Tree-Operations.cpp │ │ ├── 002-Minimum-In-Subarray.cpp │ │ ├── 003-Maximum-Pair-Sum.cpp │ │ ├── 004-Maximum-Sum-In-Subarray.cpp │ │ ├── 005-Lazy-Propagation.cpp │ │ ├── 006-Sum-Of-Squares.cpp │ │ ├── 007-Counting-Even-Odd.cpp │ │ ├── 008-Vasya-vs-Rhezo.cpp │ │ ├── 009-2-vs-3.cpp │ │ └── 010-Horrible-Queries.cpp │ ├── 015-Graphs │ ├── README.md │ ├── assets │ │ ├── Advance-Graphs.pdf │ │ ├── Graphs-1.pdf │ │ └── Graphs-2.pdf │ ├── code-part-1 │ │ ├── 001-Print-Nodes-DFS.cpp │ │ ├── 002-Print-Nodes-BFS.cpp │ │ ├── 003-Has-Path.cpp │ │ ├── 004-Get-Path-DFS.cpp │ │ ├── 005-Get-Path-BFS.cpp │ │ ├── 006-Is-Connected.cpp │ │ ├── 007-All-Connected-Components.cpp │ │ ├── 008-Islands.cpp │ │ ├── 009-CodingNinjas.cpp │ │ ├── 010-Connecting-Dots.cpp │ │ ├── 011-Largest-Piece.cpp │ │ └── 012-3-Cycle.cpp │ ├── code-part-2 │ │ ├── 001-Kruskals-Algo.cpp │ │ ├── 002-Prims-Algo.cpp │ │ └── 003-Dijkstra-Algo.cpp │ └── code-part-3 │ │ ├── 001-Connected-Components.cpp │ │ ├── 002-Permutation-Swaps.cpp │ │ ├── 003-Connected-Horses.cpp │ │ ├── 004-Strongly-Connected-Components.cpp │ │ ├── 005-Dominos.cpp │ │ ├── 006-BOTTOM.cpp │ │ ├── 007-Bipartite-Graph.cpp │ │ ├── 008-FILLMTR-Fill-Matrix.cpp │ │ ├── 009-Monk-and-the-Islands.cpp │ │ ├── 010-Kingdom-Of-Monkeys.cpp │ │ ├── 011-New-Year-Transportation.cpp │ │ ├── 012-AIRPORTS.cpp │ │ └── 013-Edges-In-MST.cpp │ ├── 016-String-Algorithms │ ├── README.md │ ├── assets │ │ └── String-Algorithms.pdf │ └── code │ │ ├── 001-Pattern-Matching-Naive.cpp │ │ ├── 002-Longest-Prefix-Suffix.cpp │ │ ├── 003-KMP-Algorithm.cpp │ │ ├── 004-String-Search.cpp │ │ ├── 005-Z-Algorithm.cpp │ │ ├── 006-Longest-Palindromic-Substring.cpp │ │ └── 007-Palindromic-Substrings.cpp │ ├── 017-Tries │ ├── README.md │ ├── assets │ │ └── Tries.pdf │ └── code │ │ ├── 001-XOR-Maximum-Pair.cpp │ │ ├── 002-Maximum-XOR-subarray.cpp │ │ ├── 003-SUBXOR.cpp │ │ ├── 004-Search-Engine.cpp │ │ └── 005-Help-Me-Pradyumana.cpp │ ├── 018-Fenwick-Tree │ ├── README.md │ ├── assets │ │ └── Fenwick-Tree.pdf │ └── code │ │ ├── 001-Fenwick-Tree-Oper.cpp │ │ ├── 002-Coders-Rating.cpp │ │ ├── 003-Distinct-Elements.cpp │ │ ├── 004-Order-Set.cpp │ │ ├── 005-KQUERY.cpp │ │ ├── 006-Shil-And-Wave-Sequence.cpp │ │ └── 007-INCSEQ.cpp │ ├── 019-DP-And-Bitmasking │ ├── README.md │ ├── assets │ │ └── DP-And-Bitmasking.pdf │ └── code │ │ ├── 001-Minimum-Job-Cost.cpp │ │ ├── 002-Candy.cpp │ │ ├── 003-Ghost-Type.cpp │ │ ├── 004-Dilemma.cpp │ │ ├── 005-Mehta-And-Bank-Robbery.cpp │ │ ├── 006-String-Maker.cpp │ │ ├── 007-Counting-Strings.cpp │ │ └── 008-Number-Of-APs.cpp │ ├── 020-Number-Theory-1 │ ├── README.md │ ├── assets │ │ ├── Number-Theory-1.pdf │ │ └── Number-Theory-2.pdf │ ├── code-part-1 │ │ ├── 001-Find-Prime-Numbers-1-to-N.cpp │ │ ├── 002-Sieve-Of-Eratosthenes.cpp │ │ ├── 003-GCD-Euclid-Algorithm.cpp │ │ ├── 004-Extended-Euclid-Algorithm.cpp │ │ └── 005-Multiplicative-Modulo-Inverse.cpp │ └── code-part-2 │ │ ├── 001-Sachin-And-Varun-Problem.cpp │ │ ├── 002-Advanced-GCD.cpp │ │ ├── 003-Divisors-Of-Factorial.cpp │ │ ├── 004-Find-The-Cube-Free-Number.cpp │ │ ├── 005-Number-Of-Factors.cpp │ │ ├── 006-Find-the-good-sets.cpp │ │ ├── 007-Card-Game.cpp │ │ └── 008-Strange-Order.cpp │ ├── 021-Number-Theory-2 │ ├── README.md │ ├── assets │ │ └── Number-Theory-3.pdf │ └── code │ │ ├── 001-Euler-Totient-Function.cpp │ │ ├── 002-LCM-SUM.cpp │ │ └── 003-Segment-Sieve.cpp │ ├── 022-Number-Theory-3 │ ├── README.md │ ├── assets │ │ └── Number-Theory-4.pdf │ └── code │ │ ├── 001-Modular-Exponentiation.cpp │ │ ├── 002-Nth-Fibonaaci-Number.cpp │ │ ├── 003-Fibonacci-Sum.cpp │ │ ├── 004-Fermats-Little-Theorem.cpp │ │ ├── 005-Wilson-Theorem.cpp │ │ ├── 006-Boring-Factorials.cpp │ │ ├── 007-Income-On-Nth-Day.cpp │ │ ├── 008-Cubic-Square.cpp │ │ ├── 009-GCD-Extreme.cpp │ │ ├── 010-Sanchit-And-Nuclear-Reactor.cpp │ │ ├── 011-Innocent-Swaps-and-His-Emotions.cpp │ │ └── 012-Sehwag-And-ETF.cpp │ ├── 023-Game-Theory │ ├── README.md │ ├── assets │ │ └── Game-Theory.pdf │ └── code │ │ ├── 001-Calculate-Grundy-Number.cpp │ │ ├── 002-Othello.cpp │ │ └── 003-Optimal-Move-In-Tic-Tac-Toe.cpp │ ├── 024-Computational-Geometry │ ├── README.md │ ├── assets │ │ └── Computational-Geometry.pdf │ └── code │ │ ├── 001-Area-Of-A-Polygon.cpp │ │ ├── 002-Area-Of-Convex-Polygon.cpp │ │ ├── 003-Surveyor.cpp │ │ ├── 004-Warehouse.cpp │ │ └── 005-Convex-Hull.cpp │ └── 025-FFT │ ├── README.md │ └── code │ └── 001-FFT.cpp ├── 04-aptitude ├── README.md └── modules │ ├── 001-HCF-and-LCM.cpp │ ├── 002-Averages.cpp │ ├── 003-Alligations.cpp │ ├── 004-Percentages.cpp │ ├── 005-Ratio-Proportaion-Variation-1.cpp │ ├── 006-Profit-And-Loss.cpp │ ├── 007-Ratio-Proportaion-Variation-2.cpp │ ├── 008-Time-Ans-Work.cpp │ ├── 009-Reasoning-1.cpp │ ├── 010-Permutation-Combination.cpp │ ├── 011-Probability.cpp │ ├── 012-Time-Speed-Distance.cpp │ ├── 013-Blood-Relation-Calenders.cpp │ ├── 014-Applications-Of-Time-Speed-Distance.cpp │ ├── 015-Set-Theory-Mensuration-Log.cpp │ └── 016-Important-Topics.cpp ├── 05-introduction-to-os ├── README.md └── assets │ ├── 01-Introduction-of-OS.pdf │ ├── 02-Installation-Of-Ubuntu-In-Virtual-Machine.pdf │ ├── 03-Introduction-to-Linux-Terminal.pdf │ ├── 04-Summary-Document-Introduction-of-OS.pdf │ ├── 05-Introduction-to-Process.pdf │ ├── 06-Process-Scheduling-Algorithms-1.pdf │ ├── 07-Preemptive-SJF-And-RR-Scheduling-Algorithms.pdf │ ├── 08-Process-Scheduling-Algorithms-2.pdf │ ├── 09-Memory-Management-1.pdf │ ├── 10-Functions-in-C-for-Memory-Management.pdf │ ├── 11-Memory-Management-2.pdf │ ├── 12-Non-Contiguous-Memory-Allocation-and-Virtual-Memory.pdf │ ├── 13-Concurrency-Introduction.pdf │ ├── 14-Concurrency-Key-Notes.pdf │ ├── 15-Failed-Attempt-To-Solve-Race-Condition.pdf │ ├── 16-Petersons-Solution.pdf │ ├── 17-Hardware-And-OS-Support.pdf │ ├── 18-Producer-And-Consumer-Problem.pdf │ ├── 19-Mutexes-Vs-Semaphores.pdf │ ├── 20-Summary-Concurrency.pdf │ ├── 21-Introduction-to-Storage-Management.pdf │ ├── 22-Introduction-to-Files-and-Directories.pdf │ ├── 23-Introduction-to-Disk-Space-Allocation-Methods.pdf │ └── 24-Summary-Storage-Management.pdf ├── 06-system-design ├── README.md ├── assets │ ├── 001-Introduction-to-system-design.pdf │ ├── 002-HLD-And-LLD.pdf │ ├── 003-Monolithic-Architecture.pdf │ ├── 004-Distributed-System.pdf │ ├── 005-Latency.pdf │ ├── 006-Throughput.pdf │ ├── 007-Availability.pdf │ ├── 008-Consistency.pdf │ ├── 009-CAP-Theorem.pdf │ ├── 010-Time.pdf │ ├── 011-Redundancy-And-Replication.pdf │ ├── 012-Load-Balancers.pdf │ ├── 013-Load-Balancing-Algorithms.pdf │ ├── 014-Caching.pdf │ ├── 015-Caching-Strategies.pdf │ ├── 016-Databases.pdf │ ├── 017-Indexing.pdf │ ├── 018-Partitioning.pdf │ ├── 019-Synchronous-Communication.pdf │ ├── 020-Asynchronous-Communication.pdf │ ├── 021-Message-Based-Communication.pdf │ ├── 022-Web-Application.pdf │ ├── 023-REST-API.pdf │ ├── 024-Service-Oriented-Architecture.pdf │ ├── 025-Microservice-Architecture.pdf │ ├── 026-Tier-Architecture.pdf │ ├── 027-Web-Servers.pdf │ ├── 028-Communication-Protocols.pdf │ ├── 029-Proxies.pdf │ └── 030-Application-Security.pdf └── code │ ├── 001-Introduction.cpp │ ├── 002-Architecture-Patterns.cpp │ ├── 003-Application-Characteristics-1.cpp │ ├── 004-Application-Characteristics-2.cpp │ ├── 005-Scaling-Techniques.cpp │ ├── 006-Databases.cpp │ ├── 007-Database-Optimization.cpp │ ├── 008-Communication.cpp │ ├── 009-Web-Applications.cpp │ ├── 010-Servers-And-Security.cpp │ ├── 011-Additional-Practice-Questions-I.cpp │ └── 012-Additional-Practice-Questions-II.cpp ├── 07-Introduction-to-DBMS ├── README.md ├── assets │ ├── 001-Introduction-to-DBMS.pdf │ ├── 002-Need-for-DBMS.pdf │ ├── 003-Data-Models.pdf │ ├── 004-Schemas.pdf │ ├── 005-Schema-Architecture.pdf │ ├── 006-Advanced-Concepts.pdf │ ├── 007-Relational-Model.pdf │ ├── 008-Keys.pdf │ ├── 009-Integrity-Rules-And-Constraints.pdf │ ├── 010-Relational-Algebra.pdf │ ├── 011-MySQL-Install-Linux.pdf │ ├── 011-MySQL-Install-MacOS.pdf │ ├── 011-MySQL-Install-Windows.pdf │ ├── 012-SQL-Quick-Summary.pdf │ ├── 013-SQL-Datatypes-Summary.pdf │ ├── 014-SQL-Commands-Summary.pdf │ ├── 015-Filtering-And-Sorting-Data.pdf │ ├── 016-Grouping-Data-Summary.pdf │ ├── 017-Queries-Tables-Constraints.pdf │ ├── 018-Modifying-Data.pdf │ ├── 019-Joining-Tables.pdf │ ├── 020-Set-Operations.pdf │ ├── 021-SubQuery-And-Types.pdf │ ├── 022-SubQuery-Examples.pdf │ ├── 023-Joins-Vs-Subqueries.pdf │ ├── 024-Transaction-Statement.pdf │ ├── 025-Import-Export.pdf │ ├── 026-Functional-Dependency.pdf │ ├── 027-Anomalies.pdf │ ├── 028-Normalisation-1.pdf │ ├── 028-Normalisation-2.pdf │ ├── 029-Transaction-ACID-Properties.pdf │ ├── 030-Transaction-States.pdf │ ├── 031-Indexing-1.pdf │ ├── 031-Indexing-2.pdf │ ├── 032-Advantages-Disadvantages-NoSQL.pdf │ ├── 033-Key-Value-NoSQL-DB.pdf │ ├── 034-Columnar-NoSQL-DB.pdf │ ├── 035-Document-NoSQL-DB.pdf │ ├── 036-Graph-Based-NoSQL-DB.pdf │ ├── 037-Relational-Database.pdf │ ├── 038-Object-Oriented-Database.pdf │ ├── 039-Hierarchical-Database.pdf │ ├── 040-Network-Database.pdf │ ├── 041-Concurrency-Control.pdf │ ├── 042-Clustering.pdf │ ├── 043-Partitioning-Sharding.pdf │ └── 044-Imp-Functions-And-Commands.pdf └── code │ ├── 001-Introduction-to-dbms.cpp │ ├── 002-Data-Models.cpp │ ├── 003-ER-Model.cpp │ ├── 004-Relational-Models.cpp │ ├── 005-Intro-To-SQL.cpp │ ├── 006-SQL-Datatypes.cpp │ ├── 007-SQL-Commands.cpp │ ├── 008-Filtering-And-Sorting-Data.cpp │ ├── 009-Grouping-Data.cpp │ ├── 010-Query-Table-And-Constraints.cpp │ ├── 011-Modifying-Data.cpp │ ├── 012-Joining-Tables.cpp │ ├── 013-Set-Operations.cpp │ ├── 014-Sub-Queries.cpp │ ├── 015-Managing-Databases.cpp │ ├── 016-Transaction-Statement.cpp │ ├── 017-Import-Export.cpp │ ├── 018-Normalization.cpp │ ├── 019-Transaction.cpp │ ├── 020-Indexing.cpp │ ├── 021-NOSQL.cpp │ ├── 022-Database-Types.cpp │ ├── 023-Database-Optimization.cpp │ └── 024-SQL-Query-Assessment.cpp ├── 08-curated-interview-dsa-problems-java ├── README.md └── modules │ └── 001-array │ ├── README.md │ └── code │ ├── P001_Rearrange_In_ZigZag_Order.java │ ├── P002_4th_Highest_element.java │ ├── P003_Max_Profit_Selling_Gulal.java │ ├── P004_Buying_And_Selling_Stocks.java │ ├── P005_Divide_In_Three_Way.java │ ├── P006_Non_Decreasing_Array_Convertible.java │ ├── P007_Trapped_Water_In_Bars.java │ ├── P008_Subarray_Sum_Of_Infinite_Array.java │ ├── P009_Ninja_Vs_Board.java │ └── P010_Design_Browser_History.java ├── Contributing.md ├── README.md └── pre-placement-checklist-questions.pdf /.vscode/c_cpp_properties.json: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/.vscode/c_cpp_properties.json -------------------------------------------------------------------------------- /.vscode/settings.json: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/.vscode/settings.json -------------------------------------------------------------------------------- /01-introduction-to-c++/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/README.md -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/001-basics/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/001-basics/README.md -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/001-basics/assets/Basics-Variables-IO.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/001-basics/assets/Basics-Variables-IO.pdf -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/001-basics/assets/Conditionals-Loops.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/001-basics/assets/Conditionals-Loops.pdf -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/001-basics/assets/FlowCharts.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/001-basics/assets/FlowCharts.pdf -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/001-basics/assets/Functions.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/001-basics/assets/Functions.pdf -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/001-basics/code/001-C++-Intro.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/001-basics/code/001-C++-Intro.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/001-basics/code/002-Datatype.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/001-basics/code/002-Datatype.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/001-basics/code/003-IO.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/001-basics/code/003-IO.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/001-basics/code/005-Oper-Bitwise.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/001-basics/code/005-Oper-Bitwise.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/001-basics/code/006-Conditions.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/001-basics/code/006-Conditions.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/001-basics/code/007-Functions.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/001-basics/code/007-Functions.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/README.md -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/assets/Conditionals-And-Loops.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/assets/Conditionals-And-Loops.pdf -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/assets/Operators-And-For-Loop.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/assets/Operators-And-For-Loop.pdf -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/assets/Patterns.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/assets/Patterns.pdf -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-1/001-Check-Number-If-Prime.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-1/001-Check-Number-If-Prime.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-1/002-Sum-Of-Even-Numbers-Till-N.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-1/002-Sum-Of-Even-Numbers-Till-N.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-1/003-Farenheit-To-Celcius-Table.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-1/003-Farenheit-To-Celcius-Table.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-1/004-Number-Pattern-1.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-1/004-Number-Pattern-1.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-1/005-Number-Pattern-2.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-1/005-Number-Pattern-2.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-1/006-Star-Pattern.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-1/006-Star-Pattern.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-1/007-Total-Salary.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-1/007-Total-Salary.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-1/008-Sum-Of-Even-Odd.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-1/008-Sum-Of-Even-Odd.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-1/009-Find-Power-Of-Number.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-1/009-Find-Power-Of-Number.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-2/001-Square-Pattern.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-2/001-Square-Pattern.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-2/002-Triangular-Star-Pattern.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-2/002-Triangular-Star-Pattern.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-2/003-Triangle-Number-Pattern.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-2/003-Triangle-Number-Pattern.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-2/004-Reverse-Number-Pattern.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-2/004-Reverse-Number-Pattern.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-2/005-Character-Pattern-Basic.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-2/005-Character-Pattern-Basic.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-2/006-Alpha-Pattern.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-2/006-Alpha-Pattern.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-2/007-Character-Pattern.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-2/007-Character-Pattern.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-2/008-Interesting-Pattern.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-2/008-Interesting-Pattern.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-3/001-Reverse-Triangle.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-3/001-Reverse-Triangle.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-3/002-Mirror-Number-Pattern.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-3/002-Mirror-Number-Pattern.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-3/003-Inverted-Triangle.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-3/003-Inverted-Triangle.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-3/004-Inverted-Number-Pattern.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-3/004-Inverted-Number-Pattern.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-3/005-Isoceles-Triangle.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-3/005-Isoceles-Triangle.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-3/006-Star-Pattern.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-3/006-Star-Pattern.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-3/007-Triangle-Of-Numbers.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-3/007-Triangle-Of-Numbers.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-3/008-Diamond-Of-Stars.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-3/008-Diamond-Of-Stars.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-3/009-Pattern-Medium-1.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-3/009-Pattern-Medium-1.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-3/010-Pattern-Medium-2.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-3/010-Pattern-Medium-2.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-3/011-Pattern-Medium-3.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-3/011-Pattern-Medium-3.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-4/001-Nth-Fibonicci-Number.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-4/001-Nth-Fibonicci-Number.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-4/002-All-Prime-Numers.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-4/002-All-Prime-Numers.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-4/003-Count-Characters.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-4/003-Count-Characters.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-4/004-Sum-Or-Product.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-4/004-Sum-Or-Product.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-4/005-Terms-Of-AP.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-4/005-Terms-Of-AP.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-4/006-Reverse-Of-Number.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-4/006-Reverse-Of-Number.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-4/007-Binary-To-Decimal.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-4/007-Binary-To-Decimal.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-4/008-Decimal-To-Binary.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-4/008-Decimal-To-Binary.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-4/009-Square-Root-Integral.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-4/009-Square-Root-Integral.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/002-loops/code-part-4/010-Check-Number-Sequence.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/002-loops/code-part-4/010-Check-Number-Sequence.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/003-test-1/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/003-test-1/README.md -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/003-test-1/code/001-Guess-Output.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/003-test-1/code/001-Guess-Output.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/003-test-1/code/002-Pyramid-Star-Pattern.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/003-test-1/code/002-Pyramid-Star-Pattern.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/003-test-1/code/003-Number-Star-Pattern.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/003-test-1/code/003-Number-Star-Pattern.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/003-test-1/code/004-Second-Largest.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/003-test-1/code/004-Second-Largest.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/004-arrays/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/004-arrays/README.md -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/004-arrays/assets/Arrays.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/004-arrays/assets/Arrays.pdf -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/004-arrays/assets/Character-And-2D-Arrays.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/004-arrays/assets/Character-And-2D-Arrays.pdf -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/004-arrays/code-part-1/001-Array-Sum.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/004-arrays/code-part-1/001-Array-Sum.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/004-arrays/code-part-1/002-Linear-Search.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/004-arrays/code-part-1/002-Linear-Search.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/004-arrays/code-part-1/003-Arrange-Numbers-In-Array.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/004-arrays/code-part-1/003-Arrange-Numbers-In-Array.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/004-arrays/code-part-1/004-Swap-Alternate.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/004-arrays/code-part-1/004-Swap-Alternate.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/004-arrays/code-part-1/005-Find-Unique.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/004-arrays/code-part-1/005-Find-Unique.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/004-arrays/code-part-1/006-Find-Duplicate.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/004-arrays/code-part-1/006-Find-Duplicate.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/004-arrays/code-part-1/007-Array-Intersection.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/004-arrays/code-part-1/007-Array-Intersection.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/004-arrays/code-part-1/008-Pair-Sum.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/004-arrays/code-part-1/008-Pair-Sum.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/004-arrays/code-part-1/009-Triplet-Sum.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/004-arrays/code-part-1/009-Triplet-Sum.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/004-arrays/code-part-1/010-Sort-01.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/004-arrays/code-part-1/010-Sort-01.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/004-arrays/code-part-2/001-1D-Char-Array.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/004-arrays/code-part-2/001-1D-Char-Array.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/004-arrays/code-part-2/002-Check-Palindrome.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/004-arrays/code-part-2/002-Check-Palindrome.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/004-arrays/code-part-2/003-Replace-Character.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/004-arrays/code-part-2/003-Replace-Character.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/004-arrays/code-part-2/004-Trim-Spaces.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/004-arrays/code-part-2/004-Trim-Spaces.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/004-arrays/code-part-2/005-Reverse-Word.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/004-arrays/code-part-2/005-Reverse-Word.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/004-arrays/code-part-3/001-Basic-2D-Arrays.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/004-arrays/code-part-3/001-Basic-2D-Arrays.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/004-arrays/code-part-3/002-Column-Wise-Sum.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/004-arrays/code-part-3/002-Column-Wise-Sum.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/004-arrays/code-part-3/003-Largest-Row-Or-Column.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/004-arrays/code-part-3/003-Largest-Row-Or-Column.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/004-arrays/code-part-3/004-Wave-Print.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/004-arrays/code-part-3/004-Wave-Print.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/004-arrays/code-part-3/005-Spiral-Print.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/004-arrays/code-part-3/005-Spiral-Print.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/004-arrays/code-part-4/001-Check-Permutation.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/004-arrays/code-part-4/001-Check-Permutation.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/004-arrays/code-part-4/003-Reverse-Each-Word.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/004-arrays/code-part-4/003-Reverse-Each-Word.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/004-arrays/code-part-4/004-Remove-Character.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/004-arrays/code-part-4/004-Remove-Character.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/004-arrays/code-part-4/005-Highest-Occuring-Character.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/004-arrays/code-part-4/005-Highest-Occuring-Character.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/004-arrays/code-part-4/006-Compress-The-String.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/004-arrays/code-part-4/006-Compress-The-String.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/005-searching-sorting/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/005-searching-sorting/README.md -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/005-searching-sorting/assets/Searching-And-Sorting.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/005-searching-sorting/assets/Searching-And-Sorting.pdf -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/005-searching-sorting/code/001-Binary-Search.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/005-searching-sorting/code/001-Binary-Search.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/005-searching-sorting/code/002-Selection-Sort.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/005-searching-sorting/code/002-Selection-Sort.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/005-searching-sorting/code/003-Bubble-Sort.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/005-searching-sorting/code/003-Bubble-Sort.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/005-searching-sorting/code/004-Insertion-Sort.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/005-searching-sorting/code/004-Insertion-Sort.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/005-searching-sorting/code/006-Push-Zeros-To-End.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/005-searching-sorting/code/006-Push-Zeros-To-End.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/005-searching-sorting/code/007-Rotate-Array.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/005-searching-sorting/code/007-Rotate-Array.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/005-searching-sorting/code/008-Second-Largest-Element.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/005-searching-sorting/code/008-Second-Largest-Element.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/005-searching-sorting/code/009-Check-Array-Rotation.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/005-searching-sorting/code/009-Check-Array-Rotation.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/005-searching-sorting/code/010-Sort-012.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/005-searching-sorting/code/010-Sort-012.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/005-searching-sorting/code/011-Sum-Of-Two-Arrays.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/005-searching-sorting/code/011-Sum-Of-Two-Arrays.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/006-string/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/006-string/README.md -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/006-string/code/001-Basics.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/006-string/code/001-Basics.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/006-string/code/002-Print-All-Substrings.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/006-string/code/002-Print-All-Substrings.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/007-test-2/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/007-test-2/README.md -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/007-test-2/code/001-Print-2D-Array.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/007-test-2/code/001-Print-2D-Array.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/007-test-2/code/002-Minimum-Length-Word.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/007-test-2/code/002-Minimum-Length-Word.cpp -------------------------------------------------------------------------------- /01-introduction-to-c++/modules/007-test-2/code/003-Leaders-In-Array.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/01-introduction-to-c++/modules/007-test-2/code/003-Leaders-In-Array.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/README.md -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/001-basics/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/001-basics/README.md -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/001-basics/assets/pointers.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/001-basics/assets/pointers.pdf -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/001-basics/code/001-Basics-Pointers.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/001-basics/code/001-Basics-Pointers.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/001-basics/code/002-Assignments-Pointers.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/001-basics/code/002-Assignments-Pointers.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/001-basics/code/003-Type-Casting.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/001-basics/code/003-Type-Casting.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/001-basics/code/004-Dynamic-Memory.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/001-basics/code/004-Dynamic-Memory.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/001-basics/code/005-Pass-By-Reference.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/001-basics/code/005-Pass-By-Reference.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/001-basics/code/006-GlobalVariables-Constant.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/001-basics/code/006-GlobalVariables-Constant.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/001-basics/code/007-Vector-Usage.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/001-basics/code/007-Vector-Usage.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/002-recursion/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/002-recursion/README.md -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/002-recursion/assets/Recursion.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/002-recursion/assets/Recursion.pdf -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/002-recursion/code-part-1/001-Factorial.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/002-recursion/code-part-1/001-Factorial.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/002-recursion/code-part-1/002-Power.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/002-recursion/code-part-1/002-Power.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/002-recursion/code-part-1/003-Print-Numbers.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/002-recursion/code-part-1/003-Print-Numbers.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/002-recursion/code-part-1/004-Number-Of-Digits.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/002-recursion/code-part-1/004-Number-Of-Digits.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/002-recursion/code-part-1/005-Nth-Number.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/002-recursion/code-part-1/005-Nth-Number.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/002-recursion/code-part-1/007-Sum-Of-Array.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/002-recursion/code-part-1/007-Sum-Of-Array.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/002-recursion/code-part-1/008-Check-Number.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/002-recursion/code-part-1/008-Check-Number.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/002-recursion/code-part-1/013-Count-Zeros.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/002-recursion/code-part-1/013-Count-Zeros.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/002-recursion/code-part-1/014-Geometric-Sum.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/002-recursion/code-part-1/014-Geometric-Sum.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/002-recursion/code-part-1/015-Check-Palindrome.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/002-recursion/code-part-1/015-Check-Palindrome.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/002-recursion/code-part-1/016-Sum-Of-Digits.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/002-recursion/code-part-1/016-Sum-Of-Digits.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/002-recursion/code-part-2/001-Replace-Pi.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/002-recursion/code-part-2/001-Replace-Pi.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/002-recursion/code-part-2/002-Remove-X.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/002-recursion/code-part-2/002-Remove-X.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/002-recursion/code-part-2/003-String-To-Integer.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/002-recursion/code-part-2/003-String-To-Integer.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/002-recursion/code-part-2/004-Pair-Star.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/002-recursion/code-part-2/004-Pair-Star.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/002-recursion/code-part-2/005-Tower-Of-Hanoi.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/002-recursion/code-part-2/005-Tower-Of-Hanoi.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/002-recursion/code-part-2/008-Merge-Sort.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/002-recursion/code-part-2/008-Merge-Sort.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/002-recursion/code-part-2/009-Quick-Sort.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/002-recursion/code-part-2/009-Quick-Sort.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/002-recursion/code-part-3/001-Strings.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/002-recursion/code-part-3/001-Strings.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/002-recursion/code-part-3/002-All-SubSequences.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/002-recursion/code-part-3/002-All-SubSequences.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/002-recursion/code-part-3/004-Print-Keypad-Code.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/002-recursion/code-part-3/004-Print-Keypad-Code.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/002-recursion/code-part-3/005-Check-AB.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/002-recursion/code-part-3/005-Check-AB.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/002-recursion/code-part-3/006-StairCase.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/002-recursion/code-part-3/006-StairCase.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/002-recursion/code-part-3/012-Return-All-Codes.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/002-recursion/code-part-3/012-Return-All-Codes.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/002-recursion/code-part-3/013-Print-All-Codes.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/002-recursion/code-part-3/013-Print-All-Codes.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/003-complexity/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/003-complexity/README.md -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/003-complexity/assets/Time-Complexity.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/003-complexity/assets/Time-Complexity.pdf -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/003-complexity/code/001-Basic-Guess-Output.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/003-complexity/code/001-Basic-Guess-Output.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/003-complexity/code/002-Find-Unique-Element.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/003-complexity/code/002-Find-Unique-Element.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/003-complexity/code/003-Duplicate-In-An-Array.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/003-complexity/code/003-Duplicate-In-An-Array.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/003-complexity/code/004-Array-Intersection.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/003-complexity/code/004-Array-Intersection.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/003-complexity/code/005-Pair-Sum-In-Array.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/003-complexity/code/005-Pair-Sum-In-Array.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/003-complexity/code/006-Triplet-Sum.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/003-complexity/code/006-Triplet-Sum.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/003-complexity/code/007-Rotate-Array.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/003-complexity/code/007-Rotate-Array.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/003-complexity/code/008-Check-Array-Rotation.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/003-complexity/code/008-Check-Array-Rotation.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/004-test-1/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/004-test-1/README.md -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/004-test-1/code/001-MCQ.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/004-test-1/code/001-MCQ.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/004-test-1/code/002-Does-S-Contains-T.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/004-test-1/code/002-Does-S-Contains-T.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/004-test-1/code/003-Maximum-Profit-App.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/004-test-1/code/003-Maximum-Profit-App.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/004-test-1/code/004-Split-Array.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/004-test-1/code/004-Split-Array.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/005-oops/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/005-oops/README.md -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/005-oops/assets/OOPS-3-Exception-Handling.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/005-oops/assets/OOPS-3-Exception-Handling.pdf -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/005-oops/assets/inheritance-1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/005-oops/assets/inheritance-1.png -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/005-oops/code-part-1/002-Fraction-Class.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/005-oops/code-part-1/002-Fraction-Class.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/005-oops/code-part-1/003-Complex-Number.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/005-oops/code-part-1/003-Complex-Number.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/005-oops/code-part-2/001-Play-With-Constructors.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/005-oops/code-part-2/001-Play-With-Constructors.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/005-oops/code-part-2/002-Deep-Shallow-Copy.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/005-oops/code-part-2/002-Deep-Shallow-Copy.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/005-oops/code-part-2/003-Const-Static-Members.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/005-oops/code-part-2/003-Const-Static-Members.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/005-oops/code-part-2/006-Polynomial-Class.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/005-oops/code-part-2/006-Polynomial-Class.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/005-oops/code-part-3/001-Inheritance.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/005-oops/code-part-3/001-Inheritance.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/005-oops/code-part-3/002-Polymorphism.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/005-oops/code-part-3/002-Polymorphism.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/006-linkedlist/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/006-linkedlist/README.md -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/006-linkedlist/code-part-1/002-Guess-Output.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/006-linkedlist/code-part-1/002-Guess-Output.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/006-linkedlist/code-part-1/003-Print-ith-Node.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/006-linkedlist/code-part-1/003-Print-ith-Node.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/006-linkedlist/code-part-1/004-Delete-Node.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/006-linkedlist/code-part-1/004-Delete-Node.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/006-linkedlist/code-part-1/008-Find-Node.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/006-linkedlist/code-part-1/008-Find-Node.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/006-linkedlist/code-part-2/003-Merge-Sort.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/006-linkedlist/code-part-2/003-Merge-Sort.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/006-linkedlist/code-part-2/009-kReverse.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/006-linkedlist/code-part-2/009-kReverse.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/007-stack/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/007-stack/README.md -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/007-stack/code/001-Stack-Impl-Arrays.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/007-stack/code/001-Stack-Impl-Arrays.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/007-stack/code/002-Stack-Impl-LinkedList.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/007-stack/code/002-Stack-Impl-LinkedList.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/007-stack/code/003-Balanced-Parenthesis.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/007-stack/code/003-Balanced-Parenthesis.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/007-stack/code/004-Reverse-Stack.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/007-stack/code/004-Reverse-Stack.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/007-stack/code/005-Check-Redundant-Brackets.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/007-stack/code/005-Check-Redundant-Brackets.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/007-stack/code/006-Stock-Span.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/007-stack/code/006-Stock-Span.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/007-stack/code/007-Minimum-Brackets-Reversal.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/007-stack/code/007-Minimum-Brackets-Reversal.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/008-queue/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/008-queue/README.md -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/008-queue/code/001-Queue-Impl-Array.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/008-queue/code/001-Queue-Impl-Array.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/008-queue/code/002-Queue-Impl-LinkedList.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/008-queue/code/002-Queue-Impl-LinkedList.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/008-queue/code/003-Reverse-Queue.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/008-queue/code/003-Reverse-Queue.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/009-test-2/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/009-test-2/README.md -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/009-test-2/code/001-Next-Number.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/009-test-2/code/001-Next-Number.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/009-test-2/code/002-Deque.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/009-test-2/code/002-Deque.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/009-test-2/code/003-Delete-Alternate-Nodes.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/009-test-2/code/003-Delete-Alternate-Nodes.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/010-trees/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/010-trees/README.md -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/010-trees/code/001-Print-Tree-Recursive.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/010-trees/code/001-Print-Tree-Recursive.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/010-trees/code/003-Count-Number-Of-Nodes.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/010-trees/code/003-Count-Number-Of-Nodes.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/010-trees/code/004-Find-Sum-Of-Nodes.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/010-trees/code/004-Find-Sum-Of-Nodes.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/010-trees/code/005-Max-Data-Node.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/010-trees/code/005-Max-Data-Node.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/010-trees/code/006-Find-Height.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/010-trees/code/006-Find-Height.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/010-trees/code/007-Count-Leaf-Nodes.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/010-trees/code/007-Count-Leaf-Nodes.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/010-trees/code/008-Print-Pre-Post-Traversal.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/010-trees/code/008-Print-Pre-Post-Traversal.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/010-trees/code/009-Contains-X.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/010-trees/code/009-Contains-X.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/010-trees/code/010-Count-Nodes.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/010-trees/code/010-Count-Nodes.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/010-trees/code/011-Node-With-Max-Child-Sum.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/010-trees/code/011-Node-With-Max-Child-Sum.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/010-trees/code/012-Structurally-Identical.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/010-trees/code/012-Structurally-Identical.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/010-trees/code/013-Next-Larger.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/010-trees/code/013-Next-Larger.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/010-trees/code/014-SecondLargest-Element.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/010-trees/code/014-SecondLargest-Element.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/010-trees/code/015-Replace-With-Depth.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/010-trees/code/015-Replace-With-Depth.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/011-binary-trees/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/011-binary-trees/README.md -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/011-binary-trees/code/003-Count-Nodes.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/011-binary-trees/code/003-Count-Nodes.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/011-binary-trees/code/004-Find-Node.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/011-binary-trees/code/004-Find-Node.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/011-binary-trees/code/005-Height-Of-Binary-Tree.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/011-binary-trees/code/005-Height-Of-Binary-Tree.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/011-binary-trees/code/006-Mirror.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/011-binary-trees/code/006-Mirror.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/011-binary-trees/code/012-Sum-Of-Nodes.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/011-binary-trees/code/012-Sum-Of-Nodes.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/011-binary-trees/code/013-Check-Balanced.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/011-binary-trees/code/013-Check-Balanced.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/011-binary-trees/code/014-Level-Order-Traversal.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/011-binary-trees/code/014-Level-Order-Traversal.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/011-binary-trees/code/015-Remove-Leaf-Nodes.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/011-binary-trees/code/015-Remove-Leaf-Nodes.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/011-binary-trees/code/016-Level-Wise-LinkedList.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/011-binary-trees/code/016-Level-Wise-LinkedList.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/011-binary-trees/code/017-ZigZag-Tree.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/011-binary-trees/code/017-ZigZag-Tree.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/012-binary-search-trees/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/012-binary-search-trees/README.md -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/012-binary-search-trees/code/001-BST-Impl.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/012-binary-search-trees/code/001-BST-Impl.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/012-binary-search-trees/code/004-Check-BST.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/012-binary-search-trees/code/004-Check-BST.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/012-binary-search-trees/code/012-LCA-Of-BST.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/012-binary-search-trees/code/012-LCA-Of-BST.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/012-binary-search-trees/code/013-Largest-BST.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/012-binary-search-trees/code/013-Largest-BST.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/013-test-3/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/013-test-3/README.md -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/013-test-3/code/001-Check-Cousin.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/013-test-3/code/001-Check-Cousin.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/013-test-3/code/002-Longest-Leaf-To-Root-Path.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/013-test-3/code/002-Longest-Leaf-To-Root-Path.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/013-test-3/code/003-Remove-Leaf-Node.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/013-test-3/code/003-Remove-Leaf-Node.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/013-test-3/code/BinaryTreeNode.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/013-test-3/code/BinaryTreeNode.h -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/014-priority-queue/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/014-priority-queue/README.md -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/014-priority-queue/code/003-Heap-Sort.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/014-priority-queue/code/003-Heap-Sort.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/014-priority-queue/code/004-InBuilt-PQ-Usage.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/014-priority-queue/code/004-InBuilt-PQ-Usage.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/014-priority-queue/code/005-K-Sorted-Array.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/014-priority-queue/code/005-K-Sorted-Array.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/014-priority-queue/code/006-K-Smallest-Elements.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/014-priority-queue/code/006-K-Smallest-Elements.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/014-priority-queue/code/007-K-Largest-Elements.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/014-priority-queue/code/007-K-Largest-Elements.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/014-priority-queue/code/008-Check-Max-Heap.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/014-priority-queue/code/008-Check-Max-Heap.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/014-priority-queue/code/009-Kth-Largest-Element.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/014-priority-queue/code/009-Kth-Largest-Element.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/014-priority-queue/code/011-Running-Median.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/014-priority-queue/code/011-Running-Median.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/014-priority-queue/code/012-Buy-The-Ticket.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/014-priority-queue/code/012-Buy-The-Ticket.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/015-hashmap/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/015-hashmap/README.md -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/015-hashmap/code/001-HashMap-Impl.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/015-hashmap/code/001-HashMap-Impl.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/015-hashmap/code/002-Basic-Usage.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/015-hashmap/code/002-Basic-Usage.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/015-hashmap/code/003-Remove-Duplicates.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/015-hashmap/code/003-Remove-Duplicates.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/015-hashmap/code/004-Maximum-Frequency-Number.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/015-hashmap/code/004-Maximum-Frequency-Number.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/015-hashmap/code/005-Print-Intersection.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/015-hashmap/code/005-Print-Intersection.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/015-hashmap/code/006-Pair-Sum.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/015-hashmap/code/006-Pair-Sum.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/015-hashmap/code/007-Extract-Unique-Characters.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/015-hashmap/code/007-Extract-Unique-Characters.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/015-hashmap/code/009-Pairs-With-Diff-K.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/015-hashmap/code/009-Pairs-With-Diff-K.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/015-hashmap/code/010-Largest-Subset-Zero-Sum.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/015-hashmap/code/010-Largest-Subset-Zero-Sum.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/016-tries/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/016-tries/README.md -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/016-tries/code/001-Trie-Implementation.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/016-tries/code/001-Trie-Implementation.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/016-tries/code/002-Pattern-Matching.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/016-tries/code/002-Pattern-Matching.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/016-tries/code/003-Palindrome-Pair.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/016-tries/code/003-Palindrome-Pair.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/016-tries/code/004-Auto-Complete.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/016-tries/code/004-Auto-Complete.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/016-tries/images/trie-1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/016-tries/images/trie-1.png -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/017-dynamic-programming/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/017-dynamic-programming/README.md -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/017-dynamic-programming/code-part-2/002-lcs.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/017-dynamic-programming/code-part-2/002-lcs.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/018-graphs/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/018-graphs/README.md -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/018-graphs/code-part-1/001-Print-Nodes-DFS.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/018-graphs/code-part-1/001-Print-Nodes-DFS.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/018-graphs/code-part-1/002-Print-Nodes-BFS.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/018-graphs/code-part-1/002-Print-Nodes-BFS.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/018-graphs/code-part-1/003-Has-Path.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/018-graphs/code-part-1/003-Has-Path.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/018-graphs/code-part-1/004-Get-Path-DFS.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/018-graphs/code-part-1/004-Get-Path-DFS.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/018-graphs/code-part-1/005-Get-Path-BFS.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/018-graphs/code-part-1/005-Get-Path-BFS.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/018-graphs/code-part-1/006-Is-Connected.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/018-graphs/code-part-1/006-Is-Connected.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/018-graphs/code-part-1/008-Islands.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/018-graphs/code-part-1/008-Islands.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/018-graphs/code-part-1/009-CodingNinjas.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/018-graphs/code-part-1/009-CodingNinjas.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/018-graphs/code-part-1/010-Connecting-Dots.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/018-graphs/code-part-1/010-Connecting-Dots.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/018-graphs/code-part-1/011-Largest-Piece.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/018-graphs/code-part-1/011-Largest-Piece.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/018-graphs/code-part-1/012-3-Cycle.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/018-graphs/code-part-1/012-3-Cycle.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/018-graphs/code-part-2/001-Kruskals-Algo.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/018-graphs/code-part-2/001-Kruskals-Algo.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/018-graphs/code-part-2/002-Prims-Algo.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/018-graphs/code-part-2/002-Prims-Algo.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/018-graphs/code-part-2/003-Dijkstra-Algo.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/018-graphs/code-part-2/003-Dijkstra-Algo.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/019-backtracking/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/019-backtracking/README.md -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/019-backtracking/code/001-N-Queen.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/019-backtracking/code/001-N-Queen.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/019-backtracking/code/002-Rat-In-A-Maze.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/019-backtracking/code/002-Rat-In-A-Maze.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/019-backtracking/code/003-Crossword.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/019-backtracking/code/003-Crossword.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/019-backtracking/code/004-Sudoku.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/019-backtracking/code/004-Sudoku.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/019-backtracking/code/005-Subsets-Sum.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/019-backtracking/code/005-Subsets-Sum.cpp -------------------------------------------------------------------------------- /02-data-structure-algorithms/modules/020-misc-skill-tests/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/02-data-structure-algorithms/modules/020-misc-skill-tests/README.md -------------------------------------------------------------------------------- /03-competitive-programming/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/README.md -------------------------------------------------------------------------------- /03-competitive-programming/modules/001-prerequisite/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/001-prerequisite/README.md -------------------------------------------------------------------------------- /03-competitive-programming/modules/001-prerequisite/code/001-Add-Numbers-Out-In-File.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/001-prerequisite/code/001-Add-Numbers-Out-In-File.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/001-prerequisite/code/003-Print-Zig-Zag-Array.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/001-prerequisite/code/003-Print-Zig-Zag-Array.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/001-prerequisite/code/004-Even-And-Odd-Indexes.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/001-prerequisite/code/004-Even-And-Odd-Indexes.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/001-prerequisite/code/006-PRE4.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/001-prerequisite/code/006-PRE4.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/001-prerequisite/code/007-Target-Marbles.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/001-prerequisite/code/007-Target-Marbles.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/001-prerequisite/io/addin.txt: -------------------------------------------------------------------------------- 1 | 2 3 -------------------------------------------------------------------------------- /03-competitive-programming/modules/001-prerequisite/io/addout.txt: -------------------------------------------------------------------------------- 1 | 5 2 | -------------------------------------------------------------------------------- /03-competitive-programming/modules/001-prerequisite/io/areain.txt: -------------------------------------------------------------------------------- 1 | 1 1 3 4 2 | 2 3 6 7 -------------------------------------------------------------------------------- /03-competitive-programming/modules/001-prerequisite/io/areaout.txt: -------------------------------------------------------------------------------- 1 | 21 2 | -------------------------------------------------------------------------------- /03-competitive-programming/modules/001-prerequisite/io/zigzag_array_in.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/001-prerequisite/io/zigzag_array_in.txt -------------------------------------------------------------------------------- /03-competitive-programming/modules/001-prerequisite/io/zigzag_array_out.txt: -------------------------------------------------------------------------------- 1 | 1 2 3 1 3 6 7 4 -------------------------------------------------------------------------------- /03-competitive-programming/modules/002-pointers/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/002-pointers/README.md -------------------------------------------------------------------------------- /03-competitive-programming/modules/002-pointers/assets/pointers.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/002-pointers/assets/pointers.pdf -------------------------------------------------------------------------------- /03-competitive-programming/modules/002-pointers/code/001-Pointers.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/002-pointers/code/001-Pointers.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/002-pointers/code/002-Pointer-Arithmetic.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/002-pointers/code/002-Pointer-Arithmetic.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/002-pointers/code/003-Arrays-And-Pointers.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/002-pointers/code/003-Arrays-And-Pointers.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/002-pointers/code/004-Character-Pointers.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/002-pointers/code/004-Character-Pointers.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/002-pointers/code/005-Pointers-And-Functions.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/002-pointers/code/005-Pointers-And-Functions.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/002-pointers/code/006-Double-Pointers.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/002-pointers/code/006-Double-Pointers.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/003-dynamic-allocation/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/003-dynamic-allocation/README.md -------------------------------------------------------------------------------- /03-competitive-programming/modules/003-dynamic-allocation/code/002-Pass-By-Reference.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/003-dynamic-allocation/code/002-Pass-By-Reference.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/003-dynamic-allocation/code/006-Constant-Vars.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/003-dynamic-allocation/code/006-Constant-Vars.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/004-recursion/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/004-recursion/README.md -------------------------------------------------------------------------------- /03-competitive-programming/modules/004-recursion/assets/recursion.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/004-recursion/assets/recursion.pdf -------------------------------------------------------------------------------- /03-competitive-programming/modules/004-recursion/code/001-Factorial.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/004-recursion/code/001-Factorial.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/004-recursion/code/002-Power.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/004-recursion/code/002-Power.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/004-recursion/code/003-Print-Numbers.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/004-recursion/code/003-Print-Numbers.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/004-recursion/code/004-Number-Of-Digits.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/004-recursion/code/004-Number-Of-Digits.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/004-recursion/code/005-Fibonicci.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/004-recursion/code/005-Fibonicci.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/004-recursion/code/006-Guess-Output.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/004-recursion/code/006-Guess-Output.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/004-recursion/code/007-Check-If-Array-Sorted.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/004-recursion/code/007-Check-If-Array-Sorted.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/004-recursion/code/008-Sum-Of-Array.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/004-recursion/code/008-Sum-Of-Array.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/004-recursion/code/009-Check-Number.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/004-recursion/code/009-Check-Number.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/004-recursion/code/010-First-Index-Of-Number.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/004-recursion/code/010-First-Index-Of-Number.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/004-recursion/code/011-Last-Index-Of-Number.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/004-recursion/code/011-Last-Index-Of-Number.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/004-recursion/code/012-All-indices-Of-Number.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/004-recursion/code/012-All-indices-Of-Number.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/005-Complexity-And-Language-Tools/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/005-Complexity-And-Language-Tools/README.md -------------------------------------------------------------------------------- /03-competitive-programming/modules/006-searching-sorting/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/006-searching-sorting/README.md -------------------------------------------------------------------------------- /03-competitive-programming/modules/006-searching-sorting/code/001-Aggressive-Cows.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/006-searching-sorting/code/001-Aggressive-Cows.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/006-searching-sorting/code/002-Inversion-Count.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/006-searching-sorting/code/002-Inversion-Count.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/006-searching-sorting/code/003-Chef-Restaurant.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/006-searching-sorting/code/003-Chef-Restaurant.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/006-searching-sorting/code/004-Variation-Pairs.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/006-searching-sorting/code/004-Variation-Pairs.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/006-searching-sorting/code/005-Murder.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/006-searching-sorting/code/005-Murder.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/006-searching-sorting/code/006-Distribute-Candies.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/006-searching-sorting/code/006-Distribute-Candies.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/006-searching-sorting/code/007-Momos-Market.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/006-searching-sorting/code/007-Momos-Market.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/006-searching-sorting/code/008-Taj-Mahal-Entry.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/006-searching-sorting/code/008-Taj-Mahal-Entry.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/007-Advance-Recursion/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/007-Advance-Recursion/README.md -------------------------------------------------------------------------------- /03-competitive-programming/modules/007-Advance-Recursion/assets/Advanced-Recursion.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/007-Advance-Recursion/assets/Advanced-Recursion.pdf -------------------------------------------------------------------------------- /03-competitive-programming/modules/007-Advance-Recursion/code/001-Length.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/007-Advance-Recursion/code/001-Length.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/007-Advance-Recursion/code/004-Merge-Sort.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/007-Advance-Recursion/code/004-Merge-Sort.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/007-Advance-Recursion/code/005-Quick-Sort.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/007-Advance-Recursion/code/005-Quick-Sort.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/008-Backtracking/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/008-Backtracking/README.md -------------------------------------------------------------------------------- /03-competitive-programming/modules/008-Backtracking/assets/Backtracking.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/008-Backtracking/assets/Backtracking.pdf -------------------------------------------------------------------------------- /03-competitive-programming/modules/008-Backtracking/code-part-1/001-nQueens.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/008-Backtracking/code-part-1/001-nQueens.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/008-Backtracking/code-part-1/002-RatInAMaze.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/008-Backtracking/code-part-1/002-RatInAMaze.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/008-Backtracking/code-part-1/003-Crossword.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/008-Backtracking/code-part-1/003-Crossword.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/008-Backtracking/code-part-2/001-Find-Power.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/008-Backtracking/code-part-2/001-Find-Power.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/008-Backtracking/code-part-2/004-Sudoku-Solver.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/008-Backtracking/code-part-2/004-Sudoku-Solver.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/009-Bit-Manipulation/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/009-Bit-Manipulation/README.md -------------------------------------------------------------------------------- /03-competitive-programming/modules/009-Bit-Manipulation/assets/Bit-Manipulation.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/009-Bit-Manipulation/assets/Bit-Manipulation.pdf -------------------------------------------------------------------------------- /03-competitive-programming/modules/009-Bit-Manipulation/code/002-Set-ith-Bit.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/009-Bit-Manipulation/code/002-Set-ith-Bit.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/009-Bit-Manipulation/code/003-Unset-ith-Bit.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/009-Bit-Manipulation/code/003-Unset-ith-Bit.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/009-Bit-Manipulation/code/004-Flip-the-ith-Bit.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/009-Bit-Manipulation/code/004-Flip-the-ith-Bit.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/010-Adhoc-Problems/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/010-Adhoc-Problems/README.md -------------------------------------------------------------------------------- /03-competitive-programming/modules/010-Adhoc-Problems/assets/Adhoc-Problems.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/010-Adhoc-Problems/assets/Adhoc-Problems.pdf -------------------------------------------------------------------------------- /03-competitive-programming/modules/010-Adhoc-Problems/code/001-Equalize.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/010-Adhoc-Problems/code/001-Equalize.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/010-Adhoc-Problems/code/002-Rectangular-Area.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/010-Adhoc-Problems/code/002-Rectangular-Area.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/010-Adhoc-Problems/code/003-Light-Up-The-Bulb.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/010-Adhoc-Problems/code/003-Light-Up-The-Bulb.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/010-Adhoc-Problems/code/006-Winning-Strategy.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/010-Adhoc-Problems/code/006-Winning-Strategy.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/011-Modulo-Arithmetic/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/011-Modulo-Arithmetic/README.md -------------------------------------------------------------------------------- /03-competitive-programming/modules/011-Modulo-Arithmetic/assets/Modulo-Arithmetic.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/011-Modulo-Arithmetic/assets/Modulo-Arithmetic.pdf -------------------------------------------------------------------------------- /03-competitive-programming/modules/012-Dynamic-Programming/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/012-Dynamic-Programming/README.md -------------------------------------------------------------------------------- /03-competitive-programming/modules/012-Dynamic-Programming/code-part-3/001-LCS.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/012-Dynamic-Programming/code-part-3/001-LCS.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/012-Dynamic-Programming/code-part-3/005-Party.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/012-Dynamic-Programming/code-part-3/005-Party.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/013-Greedy-Problems/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/013-Greedy-Problems/README.md -------------------------------------------------------------------------------- /03-competitive-programming/modules/013-Greedy-Problems/assets/Greedy-Problems.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/013-Greedy-Problems/assets/Greedy-Problems.pdf -------------------------------------------------------------------------------- /03-competitive-programming/modules/013-Greedy-Problems/code/002-Nikunj-And-Donuts.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/013-Greedy-Problems/code/002-Nikunj-And-Donuts.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/013-Greedy-Problems/code/008-Winning-Lottery.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/013-Greedy-Problems/code/008-Winning-Lottery.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/014-Segment-Trees/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/014-Segment-Trees/README.md -------------------------------------------------------------------------------- /03-competitive-programming/modules/014-Segment-Trees/assets/Segment-Trees.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/014-Segment-Trees/assets/Segment-Trees.pdf -------------------------------------------------------------------------------- /03-competitive-programming/modules/014-Segment-Trees/code/002-Minimum-In-Subarray.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/014-Segment-Trees/code/002-Minimum-In-Subarray.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/014-Segment-Trees/code/003-Maximum-Pair-Sum.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/014-Segment-Trees/code/003-Maximum-Pair-Sum.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/014-Segment-Trees/code/005-Lazy-Propagation.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/014-Segment-Trees/code/005-Lazy-Propagation.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/014-Segment-Trees/code/006-Sum-Of-Squares.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/014-Segment-Trees/code/006-Sum-Of-Squares.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/014-Segment-Trees/code/007-Counting-Even-Odd.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/014-Segment-Trees/code/007-Counting-Even-Odd.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/014-Segment-Trees/code/008-Vasya-vs-Rhezo.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/014-Segment-Trees/code/008-Vasya-vs-Rhezo.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/014-Segment-Trees/code/009-2-vs-3.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/014-Segment-Trees/code/009-2-vs-3.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/014-Segment-Trees/code/010-Horrible-Queries.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/014-Segment-Trees/code/010-Horrible-Queries.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/015-Graphs/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/015-Graphs/README.md -------------------------------------------------------------------------------- /03-competitive-programming/modules/015-Graphs/assets/Advance-Graphs.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/015-Graphs/assets/Advance-Graphs.pdf -------------------------------------------------------------------------------- /03-competitive-programming/modules/015-Graphs/assets/Graphs-1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/015-Graphs/assets/Graphs-1.pdf -------------------------------------------------------------------------------- /03-competitive-programming/modules/015-Graphs/assets/Graphs-2.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/015-Graphs/assets/Graphs-2.pdf -------------------------------------------------------------------------------- /03-competitive-programming/modules/015-Graphs/code-part-1/001-Print-Nodes-DFS.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/015-Graphs/code-part-1/001-Print-Nodes-DFS.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/015-Graphs/code-part-1/002-Print-Nodes-BFS.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/015-Graphs/code-part-1/002-Print-Nodes-BFS.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/015-Graphs/code-part-1/003-Has-Path.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/015-Graphs/code-part-1/003-Has-Path.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/015-Graphs/code-part-1/004-Get-Path-DFS.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/015-Graphs/code-part-1/004-Get-Path-DFS.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/015-Graphs/code-part-1/005-Get-Path-BFS.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/015-Graphs/code-part-1/005-Get-Path-BFS.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/015-Graphs/code-part-1/006-Is-Connected.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/015-Graphs/code-part-1/006-Is-Connected.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/015-Graphs/code-part-1/008-Islands.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/015-Graphs/code-part-1/008-Islands.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/015-Graphs/code-part-1/009-CodingNinjas.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/015-Graphs/code-part-1/009-CodingNinjas.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/015-Graphs/code-part-1/010-Connecting-Dots.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/015-Graphs/code-part-1/010-Connecting-Dots.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/015-Graphs/code-part-1/011-Largest-Piece.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/015-Graphs/code-part-1/011-Largest-Piece.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/015-Graphs/code-part-1/012-3-Cycle.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/015-Graphs/code-part-1/012-3-Cycle.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/015-Graphs/code-part-2/001-Kruskals-Algo.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/015-Graphs/code-part-2/001-Kruskals-Algo.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/015-Graphs/code-part-2/002-Prims-Algo.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/015-Graphs/code-part-2/002-Prims-Algo.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/015-Graphs/code-part-2/003-Dijkstra-Algo.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/015-Graphs/code-part-2/003-Dijkstra-Algo.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/015-Graphs/code-part-3/002-Permutation-Swaps.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/015-Graphs/code-part-3/002-Permutation-Swaps.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/015-Graphs/code-part-3/003-Connected-Horses.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/015-Graphs/code-part-3/003-Connected-Horses.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/015-Graphs/code-part-3/005-Dominos.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/015-Graphs/code-part-3/005-Dominos.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/015-Graphs/code-part-3/006-BOTTOM.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/015-Graphs/code-part-3/006-BOTTOM.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/015-Graphs/code-part-3/007-Bipartite-Graph.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/015-Graphs/code-part-3/007-Bipartite-Graph.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/015-Graphs/code-part-3/008-FILLMTR-Fill-Matrix.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/015-Graphs/code-part-3/008-FILLMTR-Fill-Matrix.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/015-Graphs/code-part-3/010-Kingdom-Of-Monkeys.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/015-Graphs/code-part-3/010-Kingdom-Of-Monkeys.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/015-Graphs/code-part-3/012-AIRPORTS.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/015-Graphs/code-part-3/012-AIRPORTS.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/015-Graphs/code-part-3/013-Edges-In-MST.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/015-Graphs/code-part-3/013-Edges-In-MST.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/016-String-Algorithms/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/016-String-Algorithms/README.md -------------------------------------------------------------------------------- /03-competitive-programming/modules/016-String-Algorithms/assets/String-Algorithms.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/016-String-Algorithms/assets/String-Algorithms.pdf -------------------------------------------------------------------------------- /03-competitive-programming/modules/016-String-Algorithms/code/003-KMP-Algorithm.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/016-String-Algorithms/code/003-KMP-Algorithm.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/016-String-Algorithms/code/004-String-Search.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/016-String-Algorithms/code/004-String-Search.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/016-String-Algorithms/code/005-Z-Algorithm.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/016-String-Algorithms/code/005-Z-Algorithm.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/017-Tries/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/017-Tries/README.md -------------------------------------------------------------------------------- /03-competitive-programming/modules/017-Tries/assets/Tries.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/017-Tries/assets/Tries.pdf -------------------------------------------------------------------------------- /03-competitive-programming/modules/017-Tries/code/001-XOR-Maximum-Pair.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/017-Tries/code/001-XOR-Maximum-Pair.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/017-Tries/code/002-Maximum-XOR-subarray.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/017-Tries/code/002-Maximum-XOR-subarray.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/017-Tries/code/003-SUBXOR.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/017-Tries/code/003-SUBXOR.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/017-Tries/code/004-Search-Engine.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/017-Tries/code/004-Search-Engine.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/017-Tries/code/005-Help-Me-Pradyumana.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/017-Tries/code/005-Help-Me-Pradyumana.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/018-Fenwick-Tree/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/018-Fenwick-Tree/README.md -------------------------------------------------------------------------------- /03-competitive-programming/modules/018-Fenwick-Tree/assets/Fenwick-Tree.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/018-Fenwick-Tree/assets/Fenwick-Tree.pdf -------------------------------------------------------------------------------- /03-competitive-programming/modules/018-Fenwick-Tree/code/001-Fenwick-Tree-Oper.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/018-Fenwick-Tree/code/001-Fenwick-Tree-Oper.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/018-Fenwick-Tree/code/002-Coders-Rating.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/018-Fenwick-Tree/code/002-Coders-Rating.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/018-Fenwick-Tree/code/003-Distinct-Elements.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/018-Fenwick-Tree/code/003-Distinct-Elements.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/018-Fenwick-Tree/code/004-Order-Set.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/018-Fenwick-Tree/code/004-Order-Set.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/018-Fenwick-Tree/code/005-KQUERY.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/018-Fenwick-Tree/code/005-KQUERY.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/018-Fenwick-Tree/code/007-INCSEQ.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/018-Fenwick-Tree/code/007-INCSEQ.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/019-DP-And-Bitmasking/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/019-DP-And-Bitmasking/README.md -------------------------------------------------------------------------------- /03-competitive-programming/modules/019-DP-And-Bitmasking/assets/DP-And-Bitmasking.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/019-DP-And-Bitmasking/assets/DP-And-Bitmasking.pdf -------------------------------------------------------------------------------- /03-competitive-programming/modules/019-DP-And-Bitmasking/code/002-Candy.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/019-DP-And-Bitmasking/code/002-Candy.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/019-DP-And-Bitmasking/code/003-Ghost-Type.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/019-DP-And-Bitmasking/code/003-Ghost-Type.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/019-DP-And-Bitmasking/code/004-Dilemma.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/019-DP-And-Bitmasking/code/004-Dilemma.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/019-DP-And-Bitmasking/code/006-String-Maker.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/019-DP-And-Bitmasking/code/006-String-Maker.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/019-DP-And-Bitmasking/code/008-Number-Of-APs.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/019-DP-And-Bitmasking/code/008-Number-Of-APs.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/020-Number-Theory-1/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/020-Number-Theory-1/README.md -------------------------------------------------------------------------------- /03-competitive-programming/modules/020-Number-Theory-1/assets/Number-Theory-1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/020-Number-Theory-1/assets/Number-Theory-1.pdf -------------------------------------------------------------------------------- /03-competitive-programming/modules/020-Number-Theory-1/assets/Number-Theory-2.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/020-Number-Theory-1/assets/Number-Theory-2.pdf -------------------------------------------------------------------------------- /03-competitive-programming/modules/020-Number-Theory-1/code-part-2/007-Card-Game.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/020-Number-Theory-1/code-part-2/007-Card-Game.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/021-Number-Theory-2/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/021-Number-Theory-2/README.md -------------------------------------------------------------------------------- /03-competitive-programming/modules/021-Number-Theory-2/assets/Number-Theory-3.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/021-Number-Theory-2/assets/Number-Theory-3.pdf -------------------------------------------------------------------------------- /03-competitive-programming/modules/021-Number-Theory-2/code/002-LCM-SUM.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/021-Number-Theory-2/code/002-LCM-SUM.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/021-Number-Theory-2/code/003-Segment-Sieve.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/021-Number-Theory-2/code/003-Segment-Sieve.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/022-Number-Theory-3/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/022-Number-Theory-3/README.md -------------------------------------------------------------------------------- /03-competitive-programming/modules/022-Number-Theory-3/assets/Number-Theory-4.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/022-Number-Theory-3/assets/Number-Theory-4.pdf -------------------------------------------------------------------------------- /03-competitive-programming/modules/022-Number-Theory-3/code/003-Fibonacci-Sum.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/022-Number-Theory-3/code/003-Fibonacci-Sum.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/022-Number-Theory-3/code/005-Wilson-Theorem.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/022-Number-Theory-3/code/005-Wilson-Theorem.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/022-Number-Theory-3/code/006-Boring-Factorials.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/022-Number-Theory-3/code/006-Boring-Factorials.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/022-Number-Theory-3/code/007-Income-On-Nth-Day.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/022-Number-Theory-3/code/007-Income-On-Nth-Day.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/022-Number-Theory-3/code/008-Cubic-Square.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/022-Number-Theory-3/code/008-Cubic-Square.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/022-Number-Theory-3/code/009-GCD-Extreme.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/022-Number-Theory-3/code/009-GCD-Extreme.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/022-Number-Theory-3/code/012-Sehwag-And-ETF.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/022-Number-Theory-3/code/012-Sehwag-And-ETF.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/023-Game-Theory/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/023-Game-Theory/README.md -------------------------------------------------------------------------------- /03-competitive-programming/modules/023-Game-Theory/assets/Game-Theory.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/023-Game-Theory/assets/Game-Theory.pdf -------------------------------------------------------------------------------- /03-competitive-programming/modules/023-Game-Theory/code/002-Othello.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/023-Game-Theory/code/002-Othello.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/024-Computational-Geometry/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/024-Computational-Geometry/README.md -------------------------------------------------------------------------------- /03-competitive-programming/modules/024-Computational-Geometry/code/003-Surveyor.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/024-Computational-Geometry/code/003-Surveyor.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/024-Computational-Geometry/code/004-Warehouse.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/024-Computational-Geometry/code/004-Warehouse.cpp -------------------------------------------------------------------------------- /03-competitive-programming/modules/025-FFT/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/025-FFT/README.md -------------------------------------------------------------------------------- /03-competitive-programming/modules/025-FFT/code/001-FFT.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/03-competitive-programming/modules/025-FFT/code/001-FFT.cpp -------------------------------------------------------------------------------- /04-aptitude/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/04-aptitude/README.md -------------------------------------------------------------------------------- /04-aptitude/modules/001-HCF-and-LCM.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/04-aptitude/modules/001-HCF-and-LCM.cpp -------------------------------------------------------------------------------- /04-aptitude/modules/002-Averages.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/04-aptitude/modules/002-Averages.cpp -------------------------------------------------------------------------------- /04-aptitude/modules/003-Alligations.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/04-aptitude/modules/003-Alligations.cpp -------------------------------------------------------------------------------- /04-aptitude/modules/004-Percentages.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/04-aptitude/modules/004-Percentages.cpp -------------------------------------------------------------------------------- /04-aptitude/modules/005-Ratio-Proportaion-Variation-1.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/04-aptitude/modules/005-Ratio-Proportaion-Variation-1.cpp -------------------------------------------------------------------------------- /04-aptitude/modules/006-Profit-And-Loss.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/04-aptitude/modules/006-Profit-And-Loss.cpp -------------------------------------------------------------------------------- /04-aptitude/modules/007-Ratio-Proportaion-Variation-2.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/04-aptitude/modules/007-Ratio-Proportaion-Variation-2.cpp -------------------------------------------------------------------------------- /04-aptitude/modules/008-Time-Ans-Work.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/04-aptitude/modules/008-Time-Ans-Work.cpp -------------------------------------------------------------------------------- /04-aptitude/modules/009-Reasoning-1.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/04-aptitude/modules/009-Reasoning-1.cpp -------------------------------------------------------------------------------- /04-aptitude/modules/010-Permutation-Combination.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/04-aptitude/modules/010-Permutation-Combination.cpp -------------------------------------------------------------------------------- /04-aptitude/modules/011-Probability.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/04-aptitude/modules/011-Probability.cpp -------------------------------------------------------------------------------- /04-aptitude/modules/012-Time-Speed-Distance.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/04-aptitude/modules/012-Time-Speed-Distance.cpp -------------------------------------------------------------------------------- /04-aptitude/modules/013-Blood-Relation-Calenders.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/04-aptitude/modules/013-Blood-Relation-Calenders.cpp -------------------------------------------------------------------------------- /04-aptitude/modules/014-Applications-Of-Time-Speed-Distance.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/04-aptitude/modules/014-Applications-Of-Time-Speed-Distance.cpp -------------------------------------------------------------------------------- /04-aptitude/modules/015-Set-Theory-Mensuration-Log.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/04-aptitude/modules/015-Set-Theory-Mensuration-Log.cpp -------------------------------------------------------------------------------- /04-aptitude/modules/016-Important-Topics.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/04-aptitude/modules/016-Important-Topics.cpp -------------------------------------------------------------------------------- /05-introduction-to-os/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/05-introduction-to-os/README.md -------------------------------------------------------------------------------- /05-introduction-to-os/assets/01-Introduction-of-OS.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/05-introduction-to-os/assets/01-Introduction-of-OS.pdf -------------------------------------------------------------------------------- /05-introduction-to-os/assets/02-Installation-Of-Ubuntu-In-Virtual-Machine.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/05-introduction-to-os/assets/02-Installation-Of-Ubuntu-In-Virtual-Machine.pdf -------------------------------------------------------------------------------- /05-introduction-to-os/assets/03-Introduction-to-Linux-Terminal.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/05-introduction-to-os/assets/03-Introduction-to-Linux-Terminal.pdf -------------------------------------------------------------------------------- /05-introduction-to-os/assets/04-Summary-Document-Introduction-of-OS.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/05-introduction-to-os/assets/04-Summary-Document-Introduction-of-OS.pdf -------------------------------------------------------------------------------- /05-introduction-to-os/assets/05-Introduction-to-Process.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/05-introduction-to-os/assets/05-Introduction-to-Process.pdf -------------------------------------------------------------------------------- /05-introduction-to-os/assets/06-Process-Scheduling-Algorithms-1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/05-introduction-to-os/assets/06-Process-Scheduling-Algorithms-1.pdf -------------------------------------------------------------------------------- /05-introduction-to-os/assets/07-Preemptive-SJF-And-RR-Scheduling-Algorithms.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/05-introduction-to-os/assets/07-Preemptive-SJF-And-RR-Scheduling-Algorithms.pdf -------------------------------------------------------------------------------- /05-introduction-to-os/assets/08-Process-Scheduling-Algorithms-2.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/05-introduction-to-os/assets/08-Process-Scheduling-Algorithms-2.pdf -------------------------------------------------------------------------------- /05-introduction-to-os/assets/09-Memory-Management-1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/05-introduction-to-os/assets/09-Memory-Management-1.pdf -------------------------------------------------------------------------------- /05-introduction-to-os/assets/10-Functions-in-C-for-Memory-Management.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/05-introduction-to-os/assets/10-Functions-in-C-for-Memory-Management.pdf -------------------------------------------------------------------------------- /05-introduction-to-os/assets/11-Memory-Management-2.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/05-introduction-to-os/assets/11-Memory-Management-2.pdf -------------------------------------------------------------------------------- /05-introduction-to-os/assets/13-Concurrency-Introduction.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/05-introduction-to-os/assets/13-Concurrency-Introduction.pdf -------------------------------------------------------------------------------- /05-introduction-to-os/assets/14-Concurrency-Key-Notes.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/05-introduction-to-os/assets/14-Concurrency-Key-Notes.pdf -------------------------------------------------------------------------------- /05-introduction-to-os/assets/15-Failed-Attempt-To-Solve-Race-Condition.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/05-introduction-to-os/assets/15-Failed-Attempt-To-Solve-Race-Condition.pdf -------------------------------------------------------------------------------- /05-introduction-to-os/assets/16-Petersons-Solution.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/05-introduction-to-os/assets/16-Petersons-Solution.pdf -------------------------------------------------------------------------------- /05-introduction-to-os/assets/17-Hardware-And-OS-Support.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/05-introduction-to-os/assets/17-Hardware-And-OS-Support.pdf -------------------------------------------------------------------------------- /05-introduction-to-os/assets/18-Producer-And-Consumer-Problem.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/05-introduction-to-os/assets/18-Producer-And-Consumer-Problem.pdf -------------------------------------------------------------------------------- /05-introduction-to-os/assets/19-Mutexes-Vs-Semaphores.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/05-introduction-to-os/assets/19-Mutexes-Vs-Semaphores.pdf -------------------------------------------------------------------------------- /05-introduction-to-os/assets/20-Summary-Concurrency.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/05-introduction-to-os/assets/20-Summary-Concurrency.pdf -------------------------------------------------------------------------------- /05-introduction-to-os/assets/21-Introduction-to-Storage-Management.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/05-introduction-to-os/assets/21-Introduction-to-Storage-Management.pdf -------------------------------------------------------------------------------- /05-introduction-to-os/assets/22-Introduction-to-Files-and-Directories.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/05-introduction-to-os/assets/22-Introduction-to-Files-and-Directories.pdf -------------------------------------------------------------------------------- /05-introduction-to-os/assets/23-Introduction-to-Disk-Space-Allocation-Methods.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/05-introduction-to-os/assets/23-Introduction-to-Disk-Space-Allocation-Methods.pdf -------------------------------------------------------------------------------- /05-introduction-to-os/assets/24-Summary-Storage-Management.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/05-introduction-to-os/assets/24-Summary-Storage-Management.pdf -------------------------------------------------------------------------------- /06-system-design/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/README.md -------------------------------------------------------------------------------- /06-system-design/assets/001-Introduction-to-system-design.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/001-Introduction-to-system-design.pdf -------------------------------------------------------------------------------- /06-system-design/assets/002-HLD-And-LLD.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/002-HLD-And-LLD.pdf -------------------------------------------------------------------------------- /06-system-design/assets/003-Monolithic-Architecture.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/003-Monolithic-Architecture.pdf -------------------------------------------------------------------------------- /06-system-design/assets/004-Distributed-System.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/004-Distributed-System.pdf -------------------------------------------------------------------------------- /06-system-design/assets/005-Latency.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/005-Latency.pdf -------------------------------------------------------------------------------- /06-system-design/assets/006-Throughput.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/006-Throughput.pdf -------------------------------------------------------------------------------- /06-system-design/assets/007-Availability.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/007-Availability.pdf -------------------------------------------------------------------------------- /06-system-design/assets/008-Consistency.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/008-Consistency.pdf -------------------------------------------------------------------------------- /06-system-design/assets/009-CAP-Theorem.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/009-CAP-Theorem.pdf -------------------------------------------------------------------------------- /06-system-design/assets/010-Time.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/010-Time.pdf -------------------------------------------------------------------------------- /06-system-design/assets/011-Redundancy-And-Replication.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/011-Redundancy-And-Replication.pdf -------------------------------------------------------------------------------- /06-system-design/assets/012-Load-Balancers.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/012-Load-Balancers.pdf -------------------------------------------------------------------------------- /06-system-design/assets/013-Load-Balancing-Algorithms.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/013-Load-Balancing-Algorithms.pdf -------------------------------------------------------------------------------- /06-system-design/assets/014-Caching.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/014-Caching.pdf -------------------------------------------------------------------------------- /06-system-design/assets/015-Caching-Strategies.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/015-Caching-Strategies.pdf -------------------------------------------------------------------------------- /06-system-design/assets/016-Databases.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/016-Databases.pdf -------------------------------------------------------------------------------- /06-system-design/assets/017-Indexing.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/017-Indexing.pdf -------------------------------------------------------------------------------- /06-system-design/assets/018-Partitioning.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/018-Partitioning.pdf -------------------------------------------------------------------------------- /06-system-design/assets/019-Synchronous-Communication.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/019-Synchronous-Communication.pdf -------------------------------------------------------------------------------- /06-system-design/assets/020-Asynchronous-Communication.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/020-Asynchronous-Communication.pdf -------------------------------------------------------------------------------- /06-system-design/assets/021-Message-Based-Communication.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/021-Message-Based-Communication.pdf -------------------------------------------------------------------------------- /06-system-design/assets/022-Web-Application.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/022-Web-Application.pdf -------------------------------------------------------------------------------- /06-system-design/assets/023-REST-API.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/023-REST-API.pdf -------------------------------------------------------------------------------- /06-system-design/assets/024-Service-Oriented-Architecture.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/024-Service-Oriented-Architecture.pdf -------------------------------------------------------------------------------- /06-system-design/assets/025-Microservice-Architecture.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/025-Microservice-Architecture.pdf -------------------------------------------------------------------------------- /06-system-design/assets/026-Tier-Architecture.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/026-Tier-Architecture.pdf -------------------------------------------------------------------------------- /06-system-design/assets/027-Web-Servers.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/027-Web-Servers.pdf -------------------------------------------------------------------------------- /06-system-design/assets/028-Communication-Protocols.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/028-Communication-Protocols.pdf -------------------------------------------------------------------------------- /06-system-design/assets/029-Proxies.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/029-Proxies.pdf -------------------------------------------------------------------------------- /06-system-design/assets/030-Application-Security.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/assets/030-Application-Security.pdf -------------------------------------------------------------------------------- /06-system-design/code/001-Introduction.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/code/001-Introduction.cpp -------------------------------------------------------------------------------- /06-system-design/code/002-Architecture-Patterns.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/code/002-Architecture-Patterns.cpp -------------------------------------------------------------------------------- /06-system-design/code/003-Application-Characteristics-1.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/code/003-Application-Characteristics-1.cpp -------------------------------------------------------------------------------- /06-system-design/code/004-Application-Characteristics-2.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/code/004-Application-Characteristics-2.cpp -------------------------------------------------------------------------------- /06-system-design/code/005-Scaling-Techniques.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/code/005-Scaling-Techniques.cpp -------------------------------------------------------------------------------- /06-system-design/code/006-Databases.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/code/006-Databases.cpp -------------------------------------------------------------------------------- /06-system-design/code/007-Database-Optimization.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/code/007-Database-Optimization.cpp -------------------------------------------------------------------------------- /06-system-design/code/008-Communication.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/code/008-Communication.cpp -------------------------------------------------------------------------------- /06-system-design/code/009-Web-Applications.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/code/009-Web-Applications.cpp -------------------------------------------------------------------------------- /06-system-design/code/010-Servers-And-Security.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/code/010-Servers-And-Security.cpp -------------------------------------------------------------------------------- /06-system-design/code/011-Additional-Practice-Questions-I.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/code/011-Additional-Practice-Questions-I.cpp -------------------------------------------------------------------------------- /06-system-design/code/012-Additional-Practice-Questions-II.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/06-system-design/code/012-Additional-Practice-Questions-II.cpp -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/README.md -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/001-Introduction-to-DBMS.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/001-Introduction-to-DBMS.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/002-Need-for-DBMS.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/002-Need-for-DBMS.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/003-Data-Models.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/003-Data-Models.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/004-Schemas.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/004-Schemas.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/005-Schema-Architecture.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/005-Schema-Architecture.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/006-Advanced-Concepts.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/006-Advanced-Concepts.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/007-Relational-Model.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/007-Relational-Model.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/008-Keys.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/008-Keys.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/009-Integrity-Rules-And-Constraints.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/009-Integrity-Rules-And-Constraints.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/010-Relational-Algebra.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/010-Relational-Algebra.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/011-MySQL-Install-Linux.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/011-MySQL-Install-Linux.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/011-MySQL-Install-MacOS.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/011-MySQL-Install-MacOS.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/011-MySQL-Install-Windows.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/011-MySQL-Install-Windows.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/012-SQL-Quick-Summary.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/012-SQL-Quick-Summary.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/013-SQL-Datatypes-Summary.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/013-SQL-Datatypes-Summary.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/014-SQL-Commands-Summary.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/014-SQL-Commands-Summary.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/015-Filtering-And-Sorting-Data.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/015-Filtering-And-Sorting-Data.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/016-Grouping-Data-Summary.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/016-Grouping-Data-Summary.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/017-Queries-Tables-Constraints.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/017-Queries-Tables-Constraints.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/018-Modifying-Data.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/018-Modifying-Data.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/019-Joining-Tables.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/019-Joining-Tables.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/020-Set-Operations.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/020-Set-Operations.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/021-SubQuery-And-Types.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/021-SubQuery-And-Types.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/022-SubQuery-Examples.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/022-SubQuery-Examples.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/023-Joins-Vs-Subqueries.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/023-Joins-Vs-Subqueries.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/024-Transaction-Statement.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/024-Transaction-Statement.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/025-Import-Export.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/025-Import-Export.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/026-Functional-Dependency.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/026-Functional-Dependency.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/027-Anomalies.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/027-Anomalies.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/028-Normalisation-1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/028-Normalisation-1.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/028-Normalisation-2.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/028-Normalisation-2.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/029-Transaction-ACID-Properties.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/029-Transaction-ACID-Properties.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/030-Transaction-States.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/030-Transaction-States.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/031-Indexing-1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/031-Indexing-1.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/031-Indexing-2.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/031-Indexing-2.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/032-Advantages-Disadvantages-NoSQL.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/032-Advantages-Disadvantages-NoSQL.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/033-Key-Value-NoSQL-DB.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/033-Key-Value-NoSQL-DB.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/034-Columnar-NoSQL-DB.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/034-Columnar-NoSQL-DB.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/035-Document-NoSQL-DB.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/035-Document-NoSQL-DB.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/036-Graph-Based-NoSQL-DB.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/036-Graph-Based-NoSQL-DB.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/037-Relational-Database.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/037-Relational-Database.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/038-Object-Oriented-Database.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/038-Object-Oriented-Database.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/039-Hierarchical-Database.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/039-Hierarchical-Database.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/040-Network-Database.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/040-Network-Database.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/041-Concurrency-Control.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/041-Concurrency-Control.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/042-Clustering.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/042-Clustering.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/043-Partitioning-Sharding.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/043-Partitioning-Sharding.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/assets/044-Imp-Functions-And-Commands.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/assets/044-Imp-Functions-And-Commands.pdf -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/code/001-Introduction-to-dbms.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/code/001-Introduction-to-dbms.cpp -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/code/002-Data-Models.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/code/002-Data-Models.cpp -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/code/003-ER-Model.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/code/003-ER-Model.cpp -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/code/004-Relational-Models.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/code/004-Relational-Models.cpp -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/code/005-Intro-To-SQL.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/code/005-Intro-To-SQL.cpp -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/code/006-SQL-Datatypes.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/code/006-SQL-Datatypes.cpp -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/code/007-SQL-Commands.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/code/007-SQL-Commands.cpp -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/code/008-Filtering-And-Sorting-Data.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/code/008-Filtering-And-Sorting-Data.cpp -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/code/009-Grouping-Data.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/code/009-Grouping-Data.cpp -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/code/010-Query-Table-And-Constraints.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/code/010-Query-Table-And-Constraints.cpp -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/code/011-Modifying-Data.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/code/011-Modifying-Data.cpp -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/code/012-Joining-Tables.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/code/012-Joining-Tables.cpp -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/code/013-Set-Operations.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/code/013-Set-Operations.cpp -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/code/014-Sub-Queries.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/code/014-Sub-Queries.cpp -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/code/015-Managing-Databases.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/code/015-Managing-Databases.cpp -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/code/016-Transaction-Statement.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/code/016-Transaction-Statement.cpp -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/code/017-Import-Export.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/code/017-Import-Export.cpp -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/code/018-Normalization.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/code/018-Normalization.cpp -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/code/019-Transaction.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/code/019-Transaction.cpp -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/code/020-Indexing.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/code/020-Indexing.cpp -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/code/021-NOSQL.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/code/021-NOSQL.cpp -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/code/022-Database-Types.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/code/022-Database-Types.cpp -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/code/023-Database-Optimization.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/code/023-Database-Optimization.cpp -------------------------------------------------------------------------------- /07-Introduction-to-DBMS/code/024-SQL-Query-Assessment.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/07-Introduction-to-DBMS/code/024-SQL-Query-Assessment.cpp -------------------------------------------------------------------------------- /08-curated-interview-dsa-problems-java/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/08-curated-interview-dsa-problems-java/README.md -------------------------------------------------------------------------------- /08-curated-interview-dsa-problems-java/modules/001-array/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/08-curated-interview-dsa-problems-java/modules/001-array/README.md -------------------------------------------------------------------------------- /Contributing.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/Contributing.md -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/README.md -------------------------------------------------------------------------------- /pre-placement-checklist-questions.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/coding-ninja-dsa-competitive-package/codig-ninja-dsa-learning/HEAD/pre-placement-checklist-questions.pdf --------------------------------------------------------------------------------