├── Addison Wesley - The C++ standard library_a tutorial and reference.pdf ├── Binary Indexed tree ├── Binary indexed tree-Theory.cpp └── Binary indexed tree.cpp ├── Binary Search ├── binary search.cpp └── notes ├── Bit manipulation ├── Bit manipulation.pdf ├── Exor │ ├── Binary trie.cpp │ ├── Given an array of integers, we have to find two elements whose XOR is maximum..cpp │ ├── Subarrays of array used in exor.cpp │ └── Tutorial on Trie and example problems - Threads @ IIIT Hyderabad - Quora.pdf ├── Gospers Hack.pdf ├── Gospers hack.cpp ├── Read me.txt └── template.cpp ├── Calendar dates └── Notes ├── Complexities └── Notes ├── Computational geometry ├── Check whether 2 line segments intersect.cpp ├── Geometry(Skiena).pdf ├── Geometry.txt ├── List_of_formulas_in_elementary_geometry.pdf ├── Notes.pdf ├── Picks theorem.pdf ├── Stanford notes.pdf ├── Sweep Line ├── check whether 2 line segments intersects_easy.cpp ├── check_if_two_given_line_segments_intersect.pdf ├── compuatational geometry.pdf ├── convex_hull ├── convex_hull.cpp ├── how_to_check_if_a_given_point_lies_inside a polygon.pdf ├── orientation of points in plane.pdf └── wcipeg_com_wiki_Computational_geometry.pdf ├── Containers ├── Bignumber library.cpp ├── Deque.cpp ├── Handle Overflow.cpp ├── Hashing ├── Imp. points regarding ip op.cpp ├── Infix to Postfix(verify).cpp ├── List.cpp ├── Map.cpp ├── Note about std::distance ├── Priority Queue.cpp ├── Queue.cpp ├── STL quick revision ├── Sets.cpp ├── Sliding window problems ├── Stacks and queues ├── Stacks.cpp ├── Strings.cpp ├── Vectors.cpp ├── bitset.cpp ├── c++ 11.txt ├── first elem >= and last elem <=.cpp ├── pairs.cpp ├── policy based DS.cpp ├── string - C++ Reference.pdf ├── tuples.cpp ├── unordered containers.txt └── valid iterator ├── Divide and conquer ├── D&C ├── __Counting inversions.txt └── test.cpp ├── Dynamic Programming ├── 19.txt ├── Codeforces DP problems list ├── Convex Hull ├── DP ├── DP+Bitmasking │ ├── ASSIGN.cpp │ ├── Another sith tournament.cpp │ ├── Bitmasking.txt │ ├── ColorfulGardenHard.cpp │ ├── Kefa and dishes.cpp │ ├── LINEUP SPOJ.cpp │ ├── Maximum coprime subset.cpp │ ├── When the integers got upset.cpp │ └── www_geeksforgeeks_org_travelling_salesman_problem_set_1.pdf ├── Dp on trees template.cpp ├── Fibonacci No(DP).cpp ├── Fibonacci No.cpp ├── LCS(both).cpp ├── LIS.cpp ├── Links.txt ├── Longest common substring.cpp ├── Longest increasing subsequence.cpp ├── Longest palin subseq.cpp ├── Longest palin subsequence.cpp ├── Matrix Expo.cpp ├── Matrix exponentiation _ HackerEarth.pdf ├── No of palin subseq.cpp ├── Notes.txt ├── Partioning problem using bitset.cpp ├── Partioning problem.cpp ├── RWALK.cpp ├── coin_change(gfg).pdf ├── knapsack(with recursion only).cpp └── knapsack.cpp ├── Game Theory ├── ONE ICPC QN+ CF 402 └── letuskode_blogspot_in_2014_08_grundy_numbers_html.pdf ├── Graphs ├── Adjacency List.cpp ├── Adjacency matrix.cpp ├── Articulations points and bridge edges ├── Articulations points.cpp ├── BFS.cpp ├── Bellman_ford.cpp ├── Bipartite Matching.cpp ├── Counting no. of connected components.cpp ├── DFS.cpp ├── Dijkstra.cpp ├── Edge classification.pdf ├── Edge labelling in directed graph.cpp ├── Floyd Warshall .cpp ├── Flyod Warshal.pdf ├── Ford Fulkerson.cpp ├── Imp points.txt ├── Kosaraju Algo. ├── Kruskal.cpp ├── Lowest common ancestor((N+Q)LOGN).cpp ├── Modified dfs giving path to every other node.cpp ├── Notes.txt ├── Prim's algorithm in 2 minutes — Review and example - YouTube.WEBM ├── Prims.txt ├── Recursive DFS.cpp ├── Topological sort.cpp └── Union find data structure │ ├── unionfind.cpp │ ├── unionfind.txt │ └── weighted union find with path compression.cpp ├── Greedy ├── Greedy └── Greedy is Good – topcoder.pdf ├── Handle Overflow.cpp ├── Important points for python programming ├── Interview ├── BST ├── Graphs and trees └── Left ├── LONG TERM PLAN ├── Left Topics ├── Linked List ├── Linked List └── test.cpp ├── Number theory ├── C ├── C.cpp ├── ETF .cpp ├── Extended euclid and modular inverse.cpp ├── Formulas_for_generating_Pythagorean_tr.pdf ├── Four square theorem.pdf ├── GCD and modular exp. by squaring.cpp ├── LDE ├── Miller rabin.cpp ├── Modular arithmetic.pptx ├── Modular arithmetic.txt ├── Number Theory ├── Power func.cpp ├── Properties of etf.docx ├── Properties of etf.pdf ├── Pythagorean_triple.pdf ├── Read me.txt ├── Segmented Seive.cpp ├── Sieve of Eratosthenes.cpp ├── Small factorials.cpp ├── arithmetic and algebra.docx ├── basic and extended Euclidean algorithms.pdf ├── crt and gauss theorem.pdf ├── digital root.cpp ├── ebooks │ ├── Elementary Number Theory - David M. Burton.pdf │ ├── Number theory for computing - Yan S Y..pdf │ └── itn-niven.pdf ├── faster primality test.cpp ├── he 1.pdf ├── he 3.pdf ├── linear diophantine eqn.pdf ├── maxprime and etf using seive.cpp ├── modular arithmetic template.cpp ├── modular exp. to handle overflow.cpp ├── modular multiplicative inverse.pdf ├── primality testing.cpp └── www_khanacademy_org_computing_computer_science_cryptography.pdf ├── Python ├── 2 and 3 differences.txt ├── Classes in python.txt ├── Datetime in python.txt ├── Dictionaries.txt ├── Exception Handling and assert.txt ├── File io.txt ├── Input Output.txt ├── Lists.txt ├── Misc..txt ├── Naming conventions.txt ├── Packages and modules.txt ├── Python Tut. Pt ├── Screenshot (96).png ├── Screenshot (97).png ├── Screenshot (98).png ├── Sets and frozen sets.txt ├── Strings.txt ├── Tuples.txt ├── generators.txt └── using mysql with python.py ├── Segment tree,Sparse Table and SQRT DECOMP ├── Assignment Lazy Propagation ├── Generalized Seg tree.cpp ├── Generalized Sparse Table.cpp ├── Kth Number Morgan Stanley.cpp ├── Lazy Propagation where you are multiplying numbers in range in update.cpp ├── Lazy propagation.cpp ├── RMQ O(1).cpp ├── RMQ SEG TREE.cpp ├── SQRT DECOMP ├── Seg tree with ordered multiset.cpp ├── Segment tree recursive.cpp └── sparseTable and RMQ.cpp ├── Sorting ├── Basic functions.c ├── Heapsort.cpp ├── Readme.txt ├── mergesort.c ├── quadratic sorting algos.cpp └── quicksort.cpp ├── Strings ├── .Binary trie.cpp.swp ├── Binary_trie.cpp ├── Hackerearth practice qns │ ├── manachar │ │ └── www_hackerearth_com_problem_algorithm_last_forever.pdf │ ├── suffix array │ │ ├── Practice Problem on Suffix Arrays.pdf │ │ ├── Practice Problem on Suffix Arrays2.pdf │ │ ├── Practice Problem on Suffix Arrays3.pdf │ │ ├── Practice Problem on Suffix Arrays4.pdf │ │ ├── www_hackerearth_com_practice_algorithms_string_algorithm_man.pdf │ │ ├── www_hackerearth_com_practice_algorithms_string_algorithm_suf.pdf │ │ ├── www_hackerearth_com_problem_algorithm_cats_substrings_descri.pdf │ │ ├── www_hackerearth_com_problem_algorithm_little_bear_and_string (1).pdf │ │ ├── www_hackerearth_com_problem_algorithm_little_bear_and_string.pdf │ │ └── www_hackerearth_com_problem_algorithm_sonya_and_string_shift.pdf │ └── z │ │ ├── Practice Problem on Z Algorithm.pdf │ │ ├── Practice Problem on Z Algorithm2.pdf │ │ ├── Practice Problem on Z Algorithm3.pdf │ │ ├── cyclic permutations.cpp │ │ ├── omar and string.cpp │ │ ├── www_hackerearth_com_practice_algorithms_string_algorithm_z_a.pdf │ │ ├── www_hackerearth_com_problem_algorithm_cyclic_permutations_15.pdf │ │ ├── www_hackerearth_com_problem_algorithm_omar_and_strings_1_des.pdf │ │ └── www_hackerearth_com_problem_algorithm_rhezo_and_division_des.pdf ├── Important Points ├── KMP(gfg).cpp ├── Rabin karp with modulo.cpp ├── Rabin karp without modulo.cpp ├── Strings ├── Suffix and LCP array(NLOGN).cpp ├── Suffix and LCP array.cpp ├── Trie easy implementation.cpp ├── Z algorithm.cpp ├── kasai alg for building lcp from sa.cpp ├── suffix-array.pdf └── topics left ├── TODO PROBLEMS.md ├── TODO ├── Counting strings │ ├── correct.cpp │ └── counting strings.cpp └── Flash and his race │ ├── input.txt │ ├── my.cpp │ └── output.txt ├── Templates ├── Codejam template.cpp ├── Double.cpp ├── fast io.cpp ├── fraction class.cpp ├── test case generator.cpp └── testfile to check whether to files are same.cpp ├── Time complexity.txt ├── Topcoder templates ├── String separation.cpp ├── String to vector.cpp └── vector to string.cpp ├── Untitled Document ├── codejam template.cpp ├── neighbours in matrix.cpp ├── oops ├── Console io │ ├── Untitled1.cpp │ ├── file.cpp │ ├── fill.cpp │ ├── flags.cpp │ ├── flags1.cpp │ ├── new.txt │ ├── precision.cpp │ └── width.cpp ├── Constructors.txt ├── Copy constructor.cpp ├── Destructor in c++.cpp ├── Imp. points from oops - Copy.txt ├── Imp. points from oops.txt ├── Inline functions in c++.pdf ├── Local Classes in C++.pdf ├── Operator overloading │ ├── Binary +.cpp │ ├── Overloading [].cpp │ ├── Read me.cpp │ ├── Try oo of [] using friend function.txt │ ├── Unary minus.cpp │ ├── cascading of extraction operator.cpp │ ├── overloading of extraction operator.cpp │ ├── postfix.cpp │ └── prefix.cpp ├── Reference variables in C++.pdf ├── Templates in c++.cpp ├── Type conversion │ ├── Basic to derived.cpp │ ├── Derived to basic.cpp │ ├── Derived to derived using casting operator.cpp │ ├── Derived to derived(using parameterized constructor).cpp │ └── Type conversion using operator overloading.txt ├── oops-tasks.txt └── when can we use forward declaration.docx ├── programming.collective.intelligence.aug.2007.pdf ├── standtard template used.cpp ├── t._cormen_-_introduction_to_algorithms_3rd_edition.pdf └── tasks of the day /Addison Wesley - The C++ standard library_a tutorial and reference.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Addison Wesley - The C++ standard library_a tutorial and reference.pdf -------------------------------------------------------------------------------- /Binary Indexed tree/Binary indexed tree-Theory.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Binary Indexed tree/Binary indexed tree-Theory.cpp -------------------------------------------------------------------------------- /Binary Indexed tree/Binary indexed tree.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Binary Indexed tree/Binary indexed tree.cpp -------------------------------------------------------------------------------- /Binary Search/binary search.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Binary Search/binary search.cpp -------------------------------------------------------------------------------- /Binary Search/notes: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Binary Search/notes -------------------------------------------------------------------------------- /Bit manipulation/Bit manipulation.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Bit manipulation/Bit manipulation.pdf -------------------------------------------------------------------------------- /Bit manipulation/Exor/Binary trie.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Bit manipulation/Exor/Binary trie.cpp -------------------------------------------------------------------------------- /Bit manipulation/Exor/Given an array of integers, we have to find two elements whose XOR is maximum..cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Bit manipulation/Exor/Given an array of integers, we have to find two elements whose XOR is maximum..cpp -------------------------------------------------------------------------------- /Bit manipulation/Exor/Subarrays of array used in exor.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Bit manipulation/Exor/Subarrays of array used in exor.cpp -------------------------------------------------------------------------------- /Bit manipulation/Exor/Tutorial on Trie and example problems - Threads @ IIIT Hyderabad - Quora.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Bit manipulation/Exor/Tutorial on Trie and example problems - Threads @ IIIT Hyderabad - Quora.pdf -------------------------------------------------------------------------------- /Bit manipulation/Gospers Hack.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Bit manipulation/Gospers Hack.pdf -------------------------------------------------------------------------------- /Bit manipulation/Gospers hack.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Bit manipulation/Gospers hack.cpp -------------------------------------------------------------------------------- /Bit manipulation/Read me.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Bit manipulation/Read me.txt -------------------------------------------------------------------------------- /Bit manipulation/template.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Bit manipulation/template.cpp -------------------------------------------------------------------------------- /Calendar dates/Notes: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Calendar dates/Notes -------------------------------------------------------------------------------- /Complexities/Notes: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Complexities/Notes -------------------------------------------------------------------------------- /Computational geometry/Check whether 2 line segments intersect.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Computational geometry/Check whether 2 line segments intersect.cpp -------------------------------------------------------------------------------- /Computational geometry/Geometry(Skiena).pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Computational geometry/Geometry(Skiena).pdf -------------------------------------------------------------------------------- /Computational geometry/Geometry.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Computational geometry/Geometry.txt -------------------------------------------------------------------------------- /Computational geometry/List_of_formulas_in_elementary_geometry.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Computational geometry/List_of_formulas_in_elementary_geometry.pdf -------------------------------------------------------------------------------- /Computational geometry/Notes.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Computational geometry/Notes.pdf -------------------------------------------------------------------------------- /Computational geometry/Picks theorem.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Computational geometry/Picks theorem.pdf -------------------------------------------------------------------------------- /Computational geometry/Stanford notes.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Computational geometry/Stanford notes.pdf -------------------------------------------------------------------------------- /Computational geometry/Sweep Line: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Computational geometry/Sweep Line -------------------------------------------------------------------------------- /Computational geometry/check whether 2 line segments intersects_easy.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Computational geometry/check whether 2 line segments intersects_easy.cpp -------------------------------------------------------------------------------- /Computational geometry/check_if_two_given_line_segments_intersect.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Computational geometry/check_if_two_given_line_segments_intersect.pdf -------------------------------------------------------------------------------- /Computational geometry/compuatational geometry.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Computational geometry/compuatational geometry.pdf -------------------------------------------------------------------------------- /Computational geometry/convex_hull: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Computational geometry/convex_hull -------------------------------------------------------------------------------- /Computational geometry/convex_hull.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Computational geometry/convex_hull.cpp -------------------------------------------------------------------------------- /Computational geometry/how_to_check_if_a_given_point_lies_inside a polygon.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Computational geometry/how_to_check_if_a_given_point_lies_inside a polygon.pdf -------------------------------------------------------------------------------- /Computational geometry/orientation of points in plane.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Computational geometry/orientation of points in plane.pdf -------------------------------------------------------------------------------- /Computational geometry/wcipeg_com_wiki_Computational_geometry.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Computational geometry/wcipeg_com_wiki_Computational_geometry.pdf -------------------------------------------------------------------------------- /Containers/Bignumber library.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Containers/Bignumber library.cpp -------------------------------------------------------------------------------- /Containers/Deque.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Containers/Deque.cpp -------------------------------------------------------------------------------- /Containers/Handle Overflow.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Containers/Handle Overflow.cpp -------------------------------------------------------------------------------- /Containers/Hashing: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Containers/Hashing -------------------------------------------------------------------------------- /Containers/Imp. points regarding ip op.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Containers/Imp. points regarding ip op.cpp -------------------------------------------------------------------------------- /Containers/Infix to Postfix(verify).cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Containers/Infix to Postfix(verify).cpp -------------------------------------------------------------------------------- /Containers/List.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Containers/List.cpp -------------------------------------------------------------------------------- /Containers/Map.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Containers/Map.cpp -------------------------------------------------------------------------------- /Containers/Note about std::distance: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Containers/Note about std::distance -------------------------------------------------------------------------------- /Containers/Priority Queue.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Containers/Priority Queue.cpp -------------------------------------------------------------------------------- /Containers/Queue.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Containers/Queue.cpp -------------------------------------------------------------------------------- /Containers/STL quick revision: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Containers/STL quick revision -------------------------------------------------------------------------------- /Containers/Sets.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Containers/Sets.cpp -------------------------------------------------------------------------------- /Containers/Sliding window problems: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Containers/Sliding window problems -------------------------------------------------------------------------------- /Containers/Stacks and queues: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Containers/Stacks and queues -------------------------------------------------------------------------------- /Containers/Stacks.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Containers/Stacks.cpp -------------------------------------------------------------------------------- /Containers/Strings.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Containers/Strings.cpp -------------------------------------------------------------------------------- /Containers/Vectors.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Containers/Vectors.cpp -------------------------------------------------------------------------------- /Containers/bitset.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Containers/bitset.cpp -------------------------------------------------------------------------------- /Containers/c++ 11.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Containers/c++ 11.txt -------------------------------------------------------------------------------- /Containers/first elem >= and last elem <=.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Containers/first elem >= and last elem <=.cpp -------------------------------------------------------------------------------- /Containers/pairs.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Containers/pairs.cpp -------------------------------------------------------------------------------- /Containers/policy based DS.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Containers/policy based DS.cpp -------------------------------------------------------------------------------- /Containers/string - C++ Reference.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Containers/string - C++ Reference.pdf -------------------------------------------------------------------------------- /Containers/tuples.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Containers/tuples.cpp -------------------------------------------------------------------------------- /Containers/unordered containers.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Containers/unordered containers.txt -------------------------------------------------------------------------------- /Containers/valid iterator: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Containers/valid iterator -------------------------------------------------------------------------------- /Divide and conquer/D&C: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Divide and conquer/D&C -------------------------------------------------------------------------------- /Divide and conquer/__Counting inversions.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Divide and conquer/__Counting inversions.txt -------------------------------------------------------------------------------- /Divide and conquer/test.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Divide and conquer/test.cpp -------------------------------------------------------------------------------- /Dynamic Programming/19.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/19.txt -------------------------------------------------------------------------------- /Dynamic Programming/Codeforces DP problems list: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/Codeforces DP problems list -------------------------------------------------------------------------------- /Dynamic Programming/Convex Hull: -------------------------------------------------------------------------------- 1 | smallest area an perimeter. 2 | 3 | -------------------------------------------------------------------------------- /Dynamic Programming/DP: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/DP -------------------------------------------------------------------------------- /Dynamic Programming/DP+Bitmasking/ASSIGN.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/DP+Bitmasking/ASSIGN.cpp -------------------------------------------------------------------------------- /Dynamic Programming/DP+Bitmasking/Another sith tournament.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/DP+Bitmasking/Another sith tournament.cpp -------------------------------------------------------------------------------- /Dynamic Programming/DP+Bitmasking/Bitmasking.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/DP+Bitmasking/Bitmasking.txt -------------------------------------------------------------------------------- /Dynamic Programming/DP+Bitmasking/ColorfulGardenHard.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/DP+Bitmasking/ColorfulGardenHard.cpp -------------------------------------------------------------------------------- /Dynamic Programming/DP+Bitmasking/Kefa and dishes.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/DP+Bitmasking/Kefa and dishes.cpp -------------------------------------------------------------------------------- /Dynamic Programming/DP+Bitmasking/LINEUP SPOJ.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/DP+Bitmasking/LINEUP SPOJ.cpp -------------------------------------------------------------------------------- /Dynamic Programming/DP+Bitmasking/Maximum coprime subset.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/DP+Bitmasking/Maximum coprime subset.cpp -------------------------------------------------------------------------------- /Dynamic Programming/DP+Bitmasking/When the integers got upset.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/DP+Bitmasking/When the integers got upset.cpp -------------------------------------------------------------------------------- /Dynamic Programming/DP+Bitmasking/www_geeksforgeeks_org_travelling_salesman_problem_set_1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/DP+Bitmasking/www_geeksforgeeks_org_travelling_salesman_problem_set_1.pdf -------------------------------------------------------------------------------- /Dynamic Programming/Dp on trees template.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/Dp on trees template.cpp -------------------------------------------------------------------------------- /Dynamic Programming/Fibonacci No(DP).cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/Fibonacci No(DP).cpp -------------------------------------------------------------------------------- /Dynamic Programming/Fibonacci No.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/Fibonacci No.cpp -------------------------------------------------------------------------------- /Dynamic Programming/LCS(both).cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/LCS(both).cpp -------------------------------------------------------------------------------- /Dynamic Programming/LIS.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/LIS.cpp -------------------------------------------------------------------------------- /Dynamic Programming/Links.txt: -------------------------------------------------------------------------------- 1 | http://people.cs.clemson.edu/~bcdean/dp_practice/ 2 | 3 | -------------------------------------------------------------------------------- /Dynamic Programming/Longest common substring.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/Longest common substring.cpp -------------------------------------------------------------------------------- /Dynamic Programming/Longest increasing subsequence.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/Longest increasing subsequence.cpp -------------------------------------------------------------------------------- /Dynamic Programming/Longest palin subseq.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/Longest palin subseq.cpp -------------------------------------------------------------------------------- /Dynamic Programming/Longest palin subsequence.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/Longest palin subsequence.cpp -------------------------------------------------------------------------------- /Dynamic Programming/Matrix Expo.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/Matrix Expo.cpp -------------------------------------------------------------------------------- /Dynamic Programming/Matrix exponentiation _ HackerEarth.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/Matrix exponentiation _ HackerEarth.pdf -------------------------------------------------------------------------------- /Dynamic Programming/No of palin subseq.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/No of palin subseq.cpp -------------------------------------------------------------------------------- /Dynamic Programming/Notes.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/Notes.txt -------------------------------------------------------------------------------- /Dynamic Programming/Partioning problem using bitset.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/Partioning problem using bitset.cpp -------------------------------------------------------------------------------- /Dynamic Programming/Partioning problem.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/Partioning problem.cpp -------------------------------------------------------------------------------- /Dynamic Programming/RWALK.cpp: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /Dynamic Programming/coin_change(gfg).pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/coin_change(gfg).pdf -------------------------------------------------------------------------------- /Dynamic Programming/knapsack(with recursion only).cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/knapsack(with recursion only).cpp -------------------------------------------------------------------------------- /Dynamic Programming/knapsack.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Dynamic Programming/knapsack.cpp -------------------------------------------------------------------------------- /Game Theory/ONE ICPC QN+ CF 402: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Game Theory/ONE ICPC QN+ CF 402 -------------------------------------------------------------------------------- /Game Theory/letuskode_blogspot_in_2014_08_grundy_numbers_html.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Game Theory/letuskode_blogspot_in_2014_08_grundy_numbers_html.pdf -------------------------------------------------------------------------------- /Graphs/Adjacency List.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Graphs/Adjacency List.cpp -------------------------------------------------------------------------------- /Graphs/Adjacency matrix.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Graphs/Adjacency matrix.cpp -------------------------------------------------------------------------------- /Graphs/Articulations points and bridge edges: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Graphs/Articulations points and bridge edges -------------------------------------------------------------------------------- /Graphs/Articulations points.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Graphs/Articulations points.cpp -------------------------------------------------------------------------------- /Graphs/BFS.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Graphs/BFS.cpp -------------------------------------------------------------------------------- /Graphs/Bellman_ford.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Graphs/Bellman_ford.cpp -------------------------------------------------------------------------------- /Graphs/Bipartite Matching.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Graphs/Bipartite Matching.cpp -------------------------------------------------------------------------------- /Graphs/Counting no. of connected components.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Graphs/Counting no. of connected components.cpp -------------------------------------------------------------------------------- /Graphs/DFS.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Graphs/DFS.cpp -------------------------------------------------------------------------------- /Graphs/Dijkstra.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Graphs/Dijkstra.cpp -------------------------------------------------------------------------------- /Graphs/Edge classification.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Graphs/Edge classification.pdf -------------------------------------------------------------------------------- /Graphs/Edge labelling in directed graph.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Graphs/Edge labelling in directed graph.cpp -------------------------------------------------------------------------------- /Graphs/Floyd Warshall .cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Graphs/Floyd Warshall .cpp -------------------------------------------------------------------------------- /Graphs/Flyod Warshal.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Graphs/Flyod Warshal.pdf -------------------------------------------------------------------------------- /Graphs/Ford Fulkerson.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Graphs/Ford Fulkerson.cpp -------------------------------------------------------------------------------- /Graphs/Imp points.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Graphs/Imp points.txt -------------------------------------------------------------------------------- /Graphs/Kosaraju Algo.: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Graphs/Kosaraju Algo. -------------------------------------------------------------------------------- /Graphs/Kruskal.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Graphs/Kruskal.cpp -------------------------------------------------------------------------------- /Graphs/Lowest common ancestor((N+Q)LOGN).cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Graphs/Lowest common ancestor((N+Q)LOGN).cpp -------------------------------------------------------------------------------- /Graphs/Modified dfs giving path to every other node.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Graphs/Modified dfs giving path to every other node.cpp -------------------------------------------------------------------------------- /Graphs/Notes.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Graphs/Notes.txt -------------------------------------------------------------------------------- /Graphs/Prim's algorithm in 2 minutes — Review and example - YouTube.WEBM: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Graphs/Prim's algorithm in 2 minutes — Review and example - YouTube.WEBM -------------------------------------------------------------------------------- /Graphs/Prims.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Graphs/Prims.txt -------------------------------------------------------------------------------- /Graphs/Recursive DFS.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Graphs/Recursive DFS.cpp -------------------------------------------------------------------------------- /Graphs/Topological sort.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Graphs/Topological sort.cpp -------------------------------------------------------------------------------- /Graphs/Union find data structure/unionfind.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Graphs/Union find data structure/unionfind.cpp -------------------------------------------------------------------------------- /Graphs/Union find data structure/unionfind.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Graphs/Union find data structure/unionfind.txt -------------------------------------------------------------------------------- /Graphs/Union find data structure/weighted union find with path compression.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Graphs/Union find data structure/weighted union find with path compression.cpp -------------------------------------------------------------------------------- /Greedy/Greedy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Greedy/Greedy -------------------------------------------------------------------------------- /Greedy/Greedy is Good – topcoder.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Greedy/Greedy is Good – topcoder.pdf -------------------------------------------------------------------------------- /Handle Overflow.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Handle Overflow.cpp -------------------------------------------------------------------------------- /Important points for python programming: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Important points for python programming -------------------------------------------------------------------------------- /Interview/BST: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Interview/BST -------------------------------------------------------------------------------- /Interview/Graphs and trees: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Interview/Graphs and trees -------------------------------------------------------------------------------- /Interview/Left: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Interview/Left -------------------------------------------------------------------------------- /LONG TERM PLAN: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/LONG TERM PLAN -------------------------------------------------------------------------------- /Left Topics: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Left Topics -------------------------------------------------------------------------------- /Linked List/Linked List: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Linked List/Linked List -------------------------------------------------------------------------------- /Linked List/test.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Linked List/test.cpp -------------------------------------------------------------------------------- /Number theory/C: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/C -------------------------------------------------------------------------------- /Number theory/C.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/C.cpp -------------------------------------------------------------------------------- /Number theory/ETF .cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/ETF .cpp -------------------------------------------------------------------------------- /Number theory/Extended euclid and modular inverse.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/Extended euclid and modular inverse.cpp -------------------------------------------------------------------------------- /Number theory/Formulas_for_generating_Pythagorean_tr.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/Formulas_for_generating_Pythagorean_tr.pdf -------------------------------------------------------------------------------- /Number theory/Four square theorem.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/Four square theorem.pdf -------------------------------------------------------------------------------- /Number theory/GCD and modular exp. by squaring.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/GCD and modular exp. by squaring.cpp -------------------------------------------------------------------------------- /Number theory/LDE: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/LDE -------------------------------------------------------------------------------- /Number theory/Miller rabin.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/Miller rabin.cpp -------------------------------------------------------------------------------- /Number theory/Modular arithmetic.pptx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/Modular arithmetic.pptx -------------------------------------------------------------------------------- /Number theory/Modular arithmetic.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/Modular arithmetic.txt -------------------------------------------------------------------------------- /Number theory/Number Theory: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/Number Theory -------------------------------------------------------------------------------- /Number theory/Power func.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/Power func.cpp -------------------------------------------------------------------------------- /Number theory/Properties of etf.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/Properties of etf.docx -------------------------------------------------------------------------------- /Number theory/Properties of etf.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/Properties of etf.pdf -------------------------------------------------------------------------------- /Number theory/Pythagorean_triple.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/Pythagorean_triple.pdf -------------------------------------------------------------------------------- /Number theory/Read me.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/Read me.txt -------------------------------------------------------------------------------- /Number theory/Segmented Seive.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/Segmented Seive.cpp -------------------------------------------------------------------------------- /Number theory/Sieve of Eratosthenes.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/Sieve of Eratosthenes.cpp -------------------------------------------------------------------------------- /Number theory/Small factorials.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/Small factorials.cpp -------------------------------------------------------------------------------- /Number theory/arithmetic and algebra.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/arithmetic and algebra.docx -------------------------------------------------------------------------------- /Number theory/basic and extended Euclidean algorithms.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/basic and extended Euclidean algorithms.pdf -------------------------------------------------------------------------------- /Number theory/crt and gauss theorem.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/crt and gauss theorem.pdf -------------------------------------------------------------------------------- /Number theory/digital root.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/digital root.cpp -------------------------------------------------------------------------------- /Number theory/ebooks/Elementary Number Theory - David M. Burton.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/ebooks/Elementary Number Theory - David M. Burton.pdf -------------------------------------------------------------------------------- /Number theory/ebooks/Number theory for computing - Yan S Y..pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/ebooks/Number theory for computing - Yan S Y..pdf -------------------------------------------------------------------------------- /Number theory/ebooks/itn-niven.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/ebooks/itn-niven.pdf -------------------------------------------------------------------------------- /Number theory/faster primality test.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/faster primality test.cpp -------------------------------------------------------------------------------- /Number theory/he 1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/he 1.pdf -------------------------------------------------------------------------------- /Number theory/he 3.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/he 3.pdf -------------------------------------------------------------------------------- /Number theory/linear diophantine eqn.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/linear diophantine eqn.pdf -------------------------------------------------------------------------------- /Number theory/maxprime and etf using seive.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/maxprime and etf using seive.cpp -------------------------------------------------------------------------------- /Number theory/modular arithmetic template.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/modular arithmetic template.cpp -------------------------------------------------------------------------------- /Number theory/modular exp. to handle overflow.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/modular exp. to handle overflow.cpp -------------------------------------------------------------------------------- /Number theory/modular multiplicative inverse.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/modular multiplicative inverse.pdf -------------------------------------------------------------------------------- /Number theory/primality testing.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/primality testing.cpp -------------------------------------------------------------------------------- /Number theory/www_khanacademy_org_computing_computer_science_cryptography.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Number theory/www_khanacademy_org_computing_computer_science_cryptography.pdf -------------------------------------------------------------------------------- /Python/2 and 3 differences.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Python/2 and 3 differences.txt -------------------------------------------------------------------------------- /Python/Classes in python.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Python/Classes in python.txt -------------------------------------------------------------------------------- /Python/Datetime in python.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Python/Datetime in python.txt -------------------------------------------------------------------------------- /Python/Dictionaries.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Python/Dictionaries.txt -------------------------------------------------------------------------------- /Python/Exception Handling and assert.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Python/Exception Handling and assert.txt -------------------------------------------------------------------------------- /Python/File io.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Python/File io.txt -------------------------------------------------------------------------------- /Python/Input Output.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Python/Input Output.txt -------------------------------------------------------------------------------- /Python/Lists.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Python/Lists.txt -------------------------------------------------------------------------------- /Python/Misc..txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Python/Misc..txt -------------------------------------------------------------------------------- /Python/Naming conventions.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Python/Naming conventions.txt -------------------------------------------------------------------------------- /Python/Packages and modules.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Python/Packages and modules.txt -------------------------------------------------------------------------------- /Python/Python Tut. Pt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Python/Python Tut. Pt -------------------------------------------------------------------------------- /Python/Screenshot (96).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Python/Screenshot (96).png -------------------------------------------------------------------------------- /Python/Screenshot (97).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Python/Screenshot (97).png -------------------------------------------------------------------------------- /Python/Screenshot (98).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Python/Screenshot (98).png -------------------------------------------------------------------------------- /Python/Sets and frozen sets.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Python/Sets and frozen sets.txt -------------------------------------------------------------------------------- /Python/Strings.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Python/Strings.txt -------------------------------------------------------------------------------- /Python/Tuples.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Python/Tuples.txt -------------------------------------------------------------------------------- /Python/generators.txt: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /Python/using mysql with python.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Python/using mysql with python.py -------------------------------------------------------------------------------- /Segment tree,Sparse Table and SQRT DECOMP/Assignment Lazy Propagation: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Segment tree,Sparse Table and SQRT DECOMP/Assignment Lazy Propagation -------------------------------------------------------------------------------- /Segment tree,Sparse Table and SQRT DECOMP/Generalized Seg tree.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Segment tree,Sparse Table and SQRT DECOMP/Generalized Seg tree.cpp -------------------------------------------------------------------------------- /Segment tree,Sparse Table and SQRT DECOMP/Generalized Sparse Table.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Segment tree,Sparse Table and SQRT DECOMP/Generalized Sparse Table.cpp -------------------------------------------------------------------------------- /Segment tree,Sparse Table and SQRT DECOMP/Kth Number Morgan Stanley.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Segment tree,Sparse Table and SQRT DECOMP/Kth Number Morgan Stanley.cpp -------------------------------------------------------------------------------- /Segment tree,Sparse Table and SQRT DECOMP/Lazy Propagation where you are multiplying numbers in range in update.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Segment tree,Sparse Table and SQRT DECOMP/Lazy Propagation where you are multiplying numbers in range in update.cpp -------------------------------------------------------------------------------- /Segment tree,Sparse Table and SQRT DECOMP/Lazy propagation.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Segment tree,Sparse Table and SQRT DECOMP/Lazy propagation.cpp -------------------------------------------------------------------------------- /Segment tree,Sparse Table and SQRT DECOMP/RMQ O(1).cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Segment tree,Sparse Table and SQRT DECOMP/RMQ O(1).cpp -------------------------------------------------------------------------------- /Segment tree,Sparse Table and SQRT DECOMP/RMQ SEG TREE.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Segment tree,Sparse Table and SQRT DECOMP/RMQ SEG TREE.cpp -------------------------------------------------------------------------------- /Segment tree,Sparse Table and SQRT DECOMP/SQRT DECOMP: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Segment tree,Sparse Table and SQRT DECOMP/SQRT DECOMP -------------------------------------------------------------------------------- /Segment tree,Sparse Table and SQRT DECOMP/Seg tree with ordered multiset.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Segment tree,Sparse Table and SQRT DECOMP/Seg tree with ordered multiset.cpp -------------------------------------------------------------------------------- /Segment tree,Sparse Table and SQRT DECOMP/Segment tree recursive.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Segment tree,Sparse Table and SQRT DECOMP/Segment tree recursive.cpp -------------------------------------------------------------------------------- /Segment tree,Sparse Table and SQRT DECOMP/sparseTable and RMQ.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Segment tree,Sparse Table and SQRT DECOMP/sparseTable and RMQ.cpp -------------------------------------------------------------------------------- /Sorting/Basic functions.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Sorting/Basic functions.c -------------------------------------------------------------------------------- /Sorting/Heapsort.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Sorting/Heapsort.cpp -------------------------------------------------------------------------------- /Sorting/Readme.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Sorting/Readme.txt -------------------------------------------------------------------------------- /Sorting/mergesort.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Sorting/mergesort.c -------------------------------------------------------------------------------- /Sorting/quadratic sorting algos.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Sorting/quadratic sorting algos.cpp -------------------------------------------------------------------------------- /Sorting/quicksort.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Sorting/quicksort.cpp -------------------------------------------------------------------------------- /Strings/.Binary trie.cpp.swp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/.Binary trie.cpp.swp -------------------------------------------------------------------------------- /Strings/Binary_trie.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Binary_trie.cpp -------------------------------------------------------------------------------- /Strings/Hackerearth practice qns/manachar/www_hackerearth_com_problem_algorithm_last_forever.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Hackerearth practice qns/manachar/www_hackerearth_com_problem_algorithm_last_forever.pdf -------------------------------------------------------------------------------- /Strings/Hackerearth practice qns/suffix array/Practice Problem on Suffix Arrays.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Hackerearth practice qns/suffix array/Practice Problem on Suffix Arrays.pdf -------------------------------------------------------------------------------- /Strings/Hackerearth practice qns/suffix array/Practice Problem on Suffix Arrays2.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Hackerearth practice qns/suffix array/Practice Problem on Suffix Arrays2.pdf -------------------------------------------------------------------------------- /Strings/Hackerearth practice qns/suffix array/Practice Problem on Suffix Arrays3.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Hackerearth practice qns/suffix array/Practice Problem on Suffix Arrays3.pdf -------------------------------------------------------------------------------- /Strings/Hackerearth practice qns/suffix array/Practice Problem on Suffix Arrays4.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Hackerearth practice qns/suffix array/Practice Problem on Suffix Arrays4.pdf -------------------------------------------------------------------------------- /Strings/Hackerearth practice qns/suffix array/www_hackerearth_com_practice_algorithms_string_algorithm_man.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Hackerearth practice qns/suffix array/www_hackerearth_com_practice_algorithms_string_algorithm_man.pdf -------------------------------------------------------------------------------- /Strings/Hackerearth practice qns/suffix array/www_hackerearth_com_practice_algorithms_string_algorithm_suf.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Hackerearth practice qns/suffix array/www_hackerearth_com_practice_algorithms_string_algorithm_suf.pdf -------------------------------------------------------------------------------- /Strings/Hackerearth practice qns/suffix array/www_hackerearth_com_problem_algorithm_cats_substrings_descri.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Hackerearth practice qns/suffix array/www_hackerearth_com_problem_algorithm_cats_substrings_descri.pdf -------------------------------------------------------------------------------- /Strings/Hackerearth practice qns/suffix array/www_hackerearth_com_problem_algorithm_little_bear_and_string (1).pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Hackerearth practice qns/suffix array/www_hackerearth_com_problem_algorithm_little_bear_and_string (1).pdf -------------------------------------------------------------------------------- /Strings/Hackerearth practice qns/suffix array/www_hackerearth_com_problem_algorithm_little_bear_and_string.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Hackerearth practice qns/suffix array/www_hackerearth_com_problem_algorithm_little_bear_and_string.pdf -------------------------------------------------------------------------------- /Strings/Hackerearth practice qns/suffix array/www_hackerearth_com_problem_algorithm_sonya_and_string_shift.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Hackerearth practice qns/suffix array/www_hackerearth_com_problem_algorithm_sonya_and_string_shift.pdf -------------------------------------------------------------------------------- /Strings/Hackerearth practice qns/z/Practice Problem on Z Algorithm.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Hackerearth practice qns/z/Practice Problem on Z Algorithm.pdf -------------------------------------------------------------------------------- /Strings/Hackerearth practice qns/z/Practice Problem on Z Algorithm2.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Hackerearth practice qns/z/Practice Problem on Z Algorithm2.pdf -------------------------------------------------------------------------------- /Strings/Hackerearth practice qns/z/Practice Problem on Z Algorithm3.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Hackerearth practice qns/z/Practice Problem on Z Algorithm3.pdf -------------------------------------------------------------------------------- /Strings/Hackerearth practice qns/z/cyclic permutations.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Hackerearth practice qns/z/cyclic permutations.cpp -------------------------------------------------------------------------------- /Strings/Hackerearth practice qns/z/omar and string.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Hackerearth practice qns/z/omar and string.cpp -------------------------------------------------------------------------------- /Strings/Hackerearth practice qns/z/www_hackerearth_com_practice_algorithms_string_algorithm_z_a.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Hackerearth practice qns/z/www_hackerearth_com_practice_algorithms_string_algorithm_z_a.pdf -------------------------------------------------------------------------------- /Strings/Hackerearth practice qns/z/www_hackerearth_com_problem_algorithm_cyclic_permutations_15.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Hackerearth practice qns/z/www_hackerearth_com_problem_algorithm_cyclic_permutations_15.pdf -------------------------------------------------------------------------------- /Strings/Hackerearth practice qns/z/www_hackerearth_com_problem_algorithm_omar_and_strings_1_des.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Hackerearth practice qns/z/www_hackerearth_com_problem_algorithm_omar_and_strings_1_des.pdf -------------------------------------------------------------------------------- /Strings/Hackerearth practice qns/z/www_hackerearth_com_problem_algorithm_rhezo_and_division_des.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Hackerearth practice qns/z/www_hackerearth_com_problem_algorithm_rhezo_and_division_des.pdf -------------------------------------------------------------------------------- /Strings/Important Points: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Important Points -------------------------------------------------------------------------------- /Strings/KMP(gfg).cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/KMP(gfg).cpp -------------------------------------------------------------------------------- /Strings/Rabin karp with modulo.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Rabin karp with modulo.cpp -------------------------------------------------------------------------------- /Strings/Rabin karp without modulo.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Rabin karp without modulo.cpp -------------------------------------------------------------------------------- /Strings/Strings: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Strings -------------------------------------------------------------------------------- /Strings/Suffix and LCP array(NLOGN).cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Suffix and LCP array(NLOGN).cpp -------------------------------------------------------------------------------- /Strings/Suffix and LCP array.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Suffix and LCP array.cpp -------------------------------------------------------------------------------- /Strings/Trie easy implementation.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Trie easy implementation.cpp -------------------------------------------------------------------------------- /Strings/Z algorithm.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/Z algorithm.cpp -------------------------------------------------------------------------------- /Strings/kasai alg for building lcp from sa.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/kasai alg for building lcp from sa.cpp -------------------------------------------------------------------------------- /Strings/suffix-array.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/suffix-array.pdf -------------------------------------------------------------------------------- /Strings/topics left: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Strings/topics left -------------------------------------------------------------------------------- /TODO PROBLEMS.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/TODO PROBLEMS.md -------------------------------------------------------------------------------- /TODO/Counting strings/correct.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/TODO/Counting strings/correct.cpp -------------------------------------------------------------------------------- /TODO/Counting strings/counting strings.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/TODO/Counting strings/counting strings.cpp -------------------------------------------------------------------------------- /TODO/Flash and his race/input.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/TODO/Flash and his race/input.txt -------------------------------------------------------------------------------- /TODO/Flash and his race/my.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/TODO/Flash and his race/my.cpp -------------------------------------------------------------------------------- /TODO/Flash and his race/output.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/TODO/Flash and his race/output.txt -------------------------------------------------------------------------------- /Templates/Codejam template.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Templates/Codejam template.cpp -------------------------------------------------------------------------------- /Templates/Double.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Templates/Double.cpp -------------------------------------------------------------------------------- /Templates/fast io.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Templates/fast io.cpp -------------------------------------------------------------------------------- /Templates/fraction class.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Templates/fraction class.cpp -------------------------------------------------------------------------------- /Templates/test case generator.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Templates/test case generator.cpp -------------------------------------------------------------------------------- /Templates/testfile to check whether to files are same.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Templates/testfile to check whether to files are same.cpp -------------------------------------------------------------------------------- /Time complexity.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Time complexity.txt -------------------------------------------------------------------------------- /Topcoder templates/String separation.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Topcoder templates/String separation.cpp -------------------------------------------------------------------------------- /Topcoder templates/String to vector.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Topcoder templates/String to vector.cpp -------------------------------------------------------------------------------- /Topcoder templates/vector to string.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/Topcoder templates/vector to string.cpp -------------------------------------------------------------------------------- /Untitled Document: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /codejam template.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/codejam template.cpp -------------------------------------------------------------------------------- /neighbours in matrix.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/neighbours in matrix.cpp -------------------------------------------------------------------------------- /oops/Console io/Untitled1.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/Console io/Untitled1.cpp -------------------------------------------------------------------------------- /oops/Console io/file.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/Console io/file.cpp -------------------------------------------------------------------------------- /oops/Console io/fill.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/Console io/fill.cpp -------------------------------------------------------------------------------- /oops/Console io/flags.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/Console io/flags.cpp -------------------------------------------------------------------------------- /oops/Console io/flags1.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/Console io/flags1.cpp -------------------------------------------------------------------------------- /oops/Console io/new.txt: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /oops/Console io/precision.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/Console io/precision.cpp -------------------------------------------------------------------------------- /oops/Console io/width.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/Console io/width.cpp -------------------------------------------------------------------------------- /oops/Constructors.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/Constructors.txt -------------------------------------------------------------------------------- /oops/Copy constructor.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/Copy constructor.cpp -------------------------------------------------------------------------------- /oops/Destructor in c++.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/Destructor in c++.cpp -------------------------------------------------------------------------------- /oops/Imp. points from oops - Copy.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/Imp. points from oops - Copy.txt -------------------------------------------------------------------------------- /oops/Imp. points from oops.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/Imp. points from oops.txt -------------------------------------------------------------------------------- /oops/Inline functions in c++.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/Inline functions in c++.pdf -------------------------------------------------------------------------------- /oops/Local Classes in C++.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/Local Classes in C++.pdf -------------------------------------------------------------------------------- /oops/Operator overloading/Binary +.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/Operator overloading/Binary +.cpp -------------------------------------------------------------------------------- /oops/Operator overloading/Overloading [].cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/Operator overloading/Overloading [].cpp -------------------------------------------------------------------------------- /oops/Operator overloading/Read me.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/Operator overloading/Read me.cpp -------------------------------------------------------------------------------- /oops/Operator overloading/Try oo of [] using friend function.txt: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /oops/Operator overloading/Unary minus.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/Operator overloading/Unary minus.cpp -------------------------------------------------------------------------------- /oops/Operator overloading/cascading of extraction operator.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/Operator overloading/cascading of extraction operator.cpp -------------------------------------------------------------------------------- /oops/Operator overloading/overloading of extraction operator.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/Operator overloading/overloading of extraction operator.cpp -------------------------------------------------------------------------------- /oops/Operator overloading/postfix.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/Operator overloading/postfix.cpp -------------------------------------------------------------------------------- /oops/Operator overloading/prefix.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/Operator overloading/prefix.cpp -------------------------------------------------------------------------------- /oops/Reference variables in C++.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/Reference variables in C++.pdf -------------------------------------------------------------------------------- /oops/Templates in c++.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/Templates in c++.cpp -------------------------------------------------------------------------------- /oops/Type conversion/Basic to derived.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/Type conversion/Basic to derived.cpp -------------------------------------------------------------------------------- /oops/Type conversion/Derived to basic.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/Type conversion/Derived to basic.cpp -------------------------------------------------------------------------------- /oops/Type conversion/Derived to derived using casting operator.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/Type conversion/Derived to derived using casting operator.cpp -------------------------------------------------------------------------------- /oops/Type conversion/Derived to derived(using parameterized constructor).cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/Type conversion/Derived to derived(using parameterized constructor).cpp -------------------------------------------------------------------------------- /oops/Type conversion/Type conversion using operator overloading.txt: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /oops/oops-tasks.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/oops-tasks.txt -------------------------------------------------------------------------------- /oops/when can we use forward declaration.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/oops/when can we use forward declaration.docx -------------------------------------------------------------------------------- /programming.collective.intelligence.aug.2007.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/programming.collective.intelligence.aug.2007.pdf -------------------------------------------------------------------------------- /standtard template used.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/standtard template used.cpp -------------------------------------------------------------------------------- /t._cormen_-_introduction_to_algorithms_3rd_edition.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/t._cormen_-_introduction_to_algorithms_3rd_edition.pdf -------------------------------------------------------------------------------- /tasks of the day: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ishan-nitj/Competitve-Programming/HEAD/tasks of the day --------------------------------------------------------------------------------