├── .classpath ├── .gitignore ├── .idea ├── .name ├── codeStyleSettings.xml ├── compiler.xml └── vcs.xml ├── .project ├── LICENSE ├── README.md ├── build.gradle ├── cracking-the-coding-interview ├── .classpath ├── .project ├── build.gradle ├── gradle │ └── wrapper │ │ ├── gradle-wrapper.jar │ │ └── gradle-wrapper.properties ├── gradlew ├── gradlew.bat ├── input_files │ ├── chapter_1 │ │ ├── check_permutation │ │ │ └── test_case │ │ ├── one_away │ │ │ └── test_case │ │ ├── palindrome_permutation │ │ │ └── test_case │ │ ├── rotate_matrix │ │ │ └── test_case │ │ ├── string_compression │ │ │ └── test_case │ │ ├── string_rotation │ │ │ └── test_case │ │ ├── string_unique │ │ │ └── test_case │ │ ├── urlify │ │ │ └── test_case │ │ └── zero_matrix │ │ │ ├── test_case_1 │ │ │ ├── test_case_2 │ │ │ └── test_case_3 │ ├── chapter_10 │ │ ├── peaks_and_valleys │ │ │ └── test_case │ │ ├── sort_stream │ │ │ ├── test_case_1 │ │ │ └── test_case_2 │ │ ├── sorted_merge │ │ │ └── test_case │ │ ├── sorted_search_no_size │ │ │ └── test_case │ │ └── sparse_search │ │ │ └── test_case │ ├── chapter_2 │ │ ├── alternate_linking │ │ ├── delete_middle │ │ ├── detect_loops │ │ ├── intersection │ │ ├── kth_to_last │ │ │ └── test_case │ │ ├── palindrome │ │ ├── partition │ │ ├── remove_duplicates │ │ │ └── test_case │ │ ├── reverse_linked_list │ │ └── sum_lists │ ├── chapter_3 │ │ ├── animal_shelter │ │ ├── queue_via_stacks │ │ ├── set_of_plates │ │ ├── set_of_plates_rollover │ │ ├── sort_stack │ │ ├── stack_min │ │ ├── stack_via_queues │ │ └── three_in_one │ ├── chapter_4 │ │ ├── bst_sequences │ │ ├── build_order │ │ ├── check_balanced │ │ ├── check_subtree │ │ ├── common_ancestor │ │ ├── list_of_depths │ │ ├── minimal_tree │ │ ├── paths_with_sum │ │ ├── random_node_binary_tree │ │ ├── random_node_bst │ │ ├── route_between_nodes │ │ ├── successor │ │ └── validate_bst │ ├── chapter_5 │ │ ├── binary_string │ │ │ └── test_case │ │ ├── conversion │ │ │ └── test_case │ │ ├── debugger │ │ │ └── test_case │ │ ├── draw_line │ │ │ ├── test_case_1 │ │ │ ├── test_case_2 │ │ │ ├── test_case_3 │ │ │ ├── test_case_4 │ │ │ └── test_case_5 │ │ ├── flip_bit_to_win │ │ │ └── test_case │ │ ├── insertion │ │ │ ├── test_case_1 │ │ │ ├── test_case_2 │ │ │ └── test_case_3 │ │ ├── next_number │ │ │ └── test_case │ │ └── pairwise_swap │ │ │ └── test_case │ └── chapter_8 │ │ ├── boolean_evaluation │ │ └── test_case │ │ ├── coins │ │ └── test_case │ │ ├── magic_index │ │ └── test_case │ │ ├── paint_fill │ │ ├── color_mappings │ │ ├── input_matrix │ │ ├── test_case_1 │ │ ├── test_case_2 │ │ ├── test_case_3 │ │ └── test_case_4 │ │ ├── parens │ │ └── test_case │ │ ├── permutations_with_dups │ │ ├── test_case_1 │ │ ├── test_case_2 │ │ └── test_case_3 │ │ ├── permutations_without_dups │ │ ├── test_case_1 │ │ └── test_case_2 │ │ ├── power_set │ │ └── test_case │ │ ├── recursive_multiply │ │ └── test_case │ │ ├── robot_in_a_grid │ │ ├── test_case_1 │ │ ├── test_case_2 │ │ └── test_case_3 │ │ ├── stack_of_boxes │ │ ├── test_case_1 │ │ ├── test_case_2 │ │ └── test_case_3 │ │ ├── towers_of_hanoi │ │ └── test_case │ │ └── triple_step │ │ └── test_case ├── src │ ├── chapter_1 │ │ ├── CheckPermutation.java │ │ ├── OneAway.java │ │ ├── PalindromePermutation.java │ │ ├── RotateMatrix.java │ │ ├── StringCompression.java │ │ ├── StringRotation.java │ │ ├── StringUnique.java │ │ ├── URLify.java │ │ └── ZeroMatrix.java │ ├── chapter_10 │ │ ├── GroupAnagrams.java │ │ ├── Listy.java │ │ ├── PeaksAndValleys.java │ │ ├── SearchInRotatedArray.java │ │ ├── SortStream.java │ │ ├── SortedMerge.java │ │ ├── SortedSearchNoSize.java │ │ ├── SparseSearch.java │ │ └── TreeNodeWithRank.java │ ├── chapter_2 │ │ ├── DeleteMiddleNode.java │ │ ├── Intersection.java │ │ ├── KthToLast.java │ │ ├── LoopDetection.java │ │ ├── Palindrome.java │ │ ├── Partition.java │ │ ├── RemoveDuplicates.java │ │ ├── SumLists.java │ │ ├── SumListsForward.java │ │ └── additional │ │ │ ├── AlternateLinking.java │ │ │ └── ReverseLinkedList.java │ ├── chapter_3 │ │ ├── AnimalShelter.java │ │ ├── QueueViaStacks.java │ │ ├── SetOfPlates.java │ │ ├── SetOfPlatesRollover.java │ │ ├── SortStack.java │ │ ├── StackMin.java │ │ ├── ThreeinOne.java │ │ ├── additional │ │ │ ├── MyStack.java │ │ │ ├── MyStack2.java │ │ │ └── StackviaQueues.java │ │ └── stack_queue │ │ │ ├── Animal.java │ │ │ ├── Cat.java │ │ │ ├── CustomStackMin.java │ │ │ ├── Dog.java │ │ │ ├── FixedSizeStack.java │ │ │ ├── MultiStack.java │ │ │ ├── MyQueue.java │ │ │ ├── SetOfStacks.java │ │ │ ├── SetOfStacksRollover.java │ │ │ ├── Shelter.java │ │ │ └── TwoWayStack.java │ ├── chapter_4 │ │ ├── BSTSequences.java │ │ ├── BuildOrder.java │ │ ├── CheckBalanced.java │ │ ├── CheckSubTree.java │ │ ├── CommonAncestor.java │ │ ├── ListOfDepths.java │ │ ├── MinimalTree.java │ │ ├── PathsWithSum.java │ │ ├── RandomNodeBST.java │ │ ├── RandomNodeBinaryTree.java │ │ ├── RouteBetweenNodes.java │ │ ├── Successor.java │ │ ├── ValidateBST.java │ │ └── tree_graph │ │ │ ├── BSTRandom.java │ │ │ └── BinaryTreeRandom.java │ ├── chapter_5 │ │ ├── BinaryString.java │ │ ├── Conversion.java │ │ ├── Debugger.java │ │ ├── DrawLine.java │ │ ├── FlipBitToWin.java │ │ ├── Insertion.java │ │ ├── NextNumber.java │ │ └── PairwiseSwap.java │ ├── chapter_8 │ │ ├── BalancedBrackets.java │ │ ├── BooleanEvaluation.java │ │ ├── Box.java │ │ ├── Coins.java │ │ ├── Color.java │ │ ├── EightQueens.java │ │ ├── MagicIndex.java │ │ ├── PaintFill.java │ │ ├── Parens.java │ │ ├── PermutationsWithDups.java │ │ ├── PermutationsWithoutDups.java │ │ ├── Point.java │ │ ├── PowerSet.java │ │ ├── RecursiveMultiply.java │ │ ├── RobotInAGrid.java │ │ ├── RobotInAGrid2.java │ │ ├── StackOfBoxes.java │ │ ├── TowersOfHanoi.java │ │ ├── TripleStep.java │ │ └── additional │ │ │ ├── CombinationsWithDups.java │ │ │ └── NQueens.java │ └── util │ │ ├── InputUtil.java │ │ └── TimerUtil.java └── test │ ├── chapter_1 │ ├── TestCheckPermutation.java │ ├── TestOneAway.java │ ├── TestPalindromePermutation.java │ ├── TestRotateMatrix.java │ ├── TestStringCompression.java │ ├── TestStringRotation.java │ ├── TestStringUnique.java │ ├── TestURLify.java │ └── TestZeroMatrix.java │ ├── chapter_10 │ ├── TestPeaksAndValleys.java │ ├── TestSortStream.java │ ├── TestSortedMerge.java │ ├── TestSortedSearchNoSize.java │ └── TestSparseSearch.java │ ├── chapter_2 │ ├── TestKthToLast.java │ └── TestRemoveDuplicates.java │ ├── chapter_5 │ ├── TestBinaryString.java │ ├── TestConversion.java │ ├── TestDebugger.java │ ├── TestDrawLine.java │ ├── TestFlipBitToWin.java │ ├── TestInsertion.java │ ├── TestNextNumber.java │ └── TestPairwiseSwap.java │ └── chapter_8 │ ├── TestBooleanEvaluation.java │ ├── TestCoins.java │ ├── TestEightQueens.java │ ├── TestMagicIndex.java │ ├── TestPaintFill.java │ ├── TestParens.java │ ├── TestPermutationsWithDups.java │ ├── TestPermutationsWithoutDups.java │ ├── TestPowerSet.java │ ├── TestRecursiveMultiply.java │ ├── TestRobotInAGrid.java │ ├── TestRobotInAGrid2.java │ ├── TestStackOfBoxes.java │ ├── TestTowersOfHanoi.java │ ├── TestTripleStep.java │ └── additional │ ├── TestCombinationsWithDups.java │ └── TestNQueens.java ├── datastructures ├── .classpath ├── .project ├── build.gradle ├── gradle │ └── wrapper │ │ ├── gradle-wrapper.jar │ │ └── gradle-wrapper.properties ├── gradlew ├── gradlew.bat ├── input_files │ ├── binary_heap │ │ ├── test_case_1 │ │ └── test_case_2 │ ├── disjoint_sets │ │ ├── test_case_1 │ │ ├── test_case_2 │ │ └── test_case_3 │ ├── max_priority_queue │ │ ├── test_case_1 │ │ └── test_case_2 │ ├── min_priority_queue │ │ ├── test_case_1 │ │ └── test_case_2 │ ├── test_binary_heap │ ├── test_binary_search_tree │ ├── test_graph │ ├── test_graph_set_2 │ ├── test_hash_table │ ├── test_max_priority_queue │ ├── test_min_priority_queue │ └── trie │ │ ├── test_case_1 │ │ └── test_case_2 ├── src │ └── datastructures │ │ ├── disjointsets │ │ ├── DisjointSetList.java │ │ ├── DisjointSetListNode.java │ │ ├── DisjointSetNaive.java │ │ ├── DisjointSetNode.java │ │ └── DisjointSetWithPathCompression.java │ │ ├── graph │ │ ├── AbstractGraph.java │ │ ├── DirectedGraph.java │ │ ├── Edge.java │ │ ├── GenericGraph.java │ │ ├── GraphType.java │ │ ├── UndirectedGraph.java │ │ └── Vertex.java │ │ ├── hashtable │ │ ├── HashTable.java │ │ └── HashTableNode.java │ │ ├── heap │ │ ├── BinaryHeap.java │ │ ├── BinaryMaxHeap.java │ │ ├── BinaryMinHeap.java │ │ ├── HeapType.java │ │ ├── PriorityQueue.java │ │ └── PriorityQueueElement.java │ │ ├── lists │ │ ├── AbstractList.java │ │ ├── CircularLinkedList.java │ │ ├── CustomLinkedList.java │ │ ├── DoubleLinkedList.java │ │ ├── GenericList.java │ │ └── LinkedListNode.java │ │ ├── queue │ │ └── CustomQueue.java │ │ ├── stack │ │ ├── CustomStack.java │ │ └── GenericStack.java │ │ ├── test │ │ ├── TestBinarySearchTree.java │ │ ├── TestCircularLinkedList.java │ │ ├── TestDoubleLinkedList.java │ │ ├── TestGraph.java │ │ ├── TestHashTable.java │ │ └── TestTrie.java │ │ ├── tree │ │ ├── AbstractBinaryTree.java │ │ ├── BinarySearchTree.java │ │ ├── BinaryTree.java │ │ ├── GenericBinaryTree.java │ │ ├── SegmentTree.java │ │ ├── TreeNode.java │ │ ├── Trie.java │ │ └── TrieNode.java │ │ └── util │ │ ├── BinaryTreeUtil.java │ │ ├── GraphUtil.java │ │ ├── InputUtil.java │ │ ├── ListUtil.java │ │ └── TreeUtil.java └── test │ └── datastructures │ ├── disjointsets │ ├── TestDisjointSetNaive.java │ └── TestDisjointSetWithPathCompression.java │ ├── heap │ ├── TestBinaryMaxHeap.java │ ├── TestBinaryMinHeap.java │ ├── TestMaxPriorityQueue.java │ └── TestMinPriorityQueue.java │ └── trie │ └── TestTrie.java ├── geeks-for-geeks ├── .classpath ├── .project ├── build.gradle ├── gradle │ └── wrapper │ │ ├── gradle-wrapper.jar │ │ └── gradle-wrapper.properties ├── gradlew ├── gradlew.bat ├── input_files │ ├── array │ │ ├── count_pairs_sorted_less_than_sum │ │ │ └── test_case │ │ ├── element_occurs_once │ │ │ └── test_case │ │ ├── equal_sum_subarray │ │ │ └── test_case │ │ ├── find_all_pairs_abcd │ │ │ ├── test_case_1 │ │ │ ├── test_case_2 │ │ │ └── test_case_3 │ │ ├── find_common_three_sorted_arrays │ │ │ └── test_case │ │ ├── find_missing_number │ │ │ └── test_case │ │ ├── mimum_sum_abs_diff │ │ │ └── test_case │ │ ├── noble_integers_in_array │ │ │ └── test_case │ │ ├── sum_of_distinct_in_array │ │ │ └── test_case │ │ └── union_and_intersection │ │ │ └── test_case │ ├── dp │ │ ├── coin_change │ │ │ └── test_case │ │ ├── coin_change_min_coins │ │ │ └── test_case │ │ ├── count_binary_without_consecutive_ones │ │ │ └── test_case │ │ ├── count_ways_n_stairs │ │ │ └── test_case │ │ ├── egg_dropping_problem │ │ │ └── test_case │ │ ├── fibonacci_number │ │ │ └── test_case │ │ ├── largest_subsquare_xo │ │ │ └── test_case │ │ ├── levenshtein │ │ │ └── test_case │ │ ├── longest_bitonic_subsequence │ │ │ └── test_case │ │ ├── longest_common_subsequence │ │ │ └── test_case │ │ ├── longest_common_substring │ │ │ └── test_case │ │ ├── longest_increasing_subsequence │ │ │ └── test_case │ │ ├── longest_palindromic_subsequence │ │ │ └── test_case │ │ ├── longest_palindromic_substring │ │ │ └── test_case │ │ ├── matrix_multiplication │ │ │ └── test_case │ │ ├── maximum_sum_increasing_subsequence │ │ │ └── test_case │ │ ├── maximum_sum_non_adjacent │ │ │ └── test_case │ │ ├── maximum_sum_rectangular_sub_matrix │ │ │ └── test_case │ │ ├── min_cost_path │ │ │ └── test_case │ │ ├── min_jumps_to_end │ │ │ └── test_case │ │ ├── optimal_bst │ │ │ └── test_case │ │ ├── optimal_strategy_game_picks │ │ │ └── test_case │ │ ├── palindrome_partitioning │ │ │ └── test_case │ │ ├── rod_cutting │ │ │ └── test_case │ │ ├── subset_sum │ │ │ └── test_case │ │ ├── text_justification │ │ │ ├── test_case_1 │ │ │ ├── test_case_2 │ │ │ ├── test_case_3 │ │ │ ├── test_case_4 │ │ │ ├── test_case_5 │ │ │ └── test_case_6 │ │ ├── total_number_of_bst_nkeys │ │ │ └── test_case │ │ ├── total_ways_matrix │ │ │ └── test_case │ │ ├── weighted_job_scheduling │ │ │ └── test_case │ │ └── zero_one_knapsack │ │ │ ├── test_case_1 │ │ │ ├── test_case_2 │ │ │ ├── test_case_3 │ │ │ └── test_case_4 │ ├── graph │ │ ├── all_pairs_shortest_path │ │ │ ├── test_case_1 │ │ │ ├── test_case_2 │ │ │ └── test_case_3 │ │ ├── connected_components │ │ │ ├── test_case_1 │ │ │ ├── test_case_2 │ │ │ └── test_case_3 │ │ ├── detect_cycle │ │ │ ├── test_case_1 │ │ │ ├── test_case_2 │ │ │ ├── test_case_3 │ │ │ ├── test_case_4 │ │ │ └── test_case_5 │ │ ├── min_steps_knights_tour │ │ │ └── test_case │ │ ├── minimum_spanning_tree │ │ │ ├── test_case_1 │ │ │ ├── test_case_2 │ │ │ ├── test_case_3 │ │ │ └── test_case_4 │ │ ├── screen_keyboard │ │ │ └── test_case │ │ ├── shortest_path │ │ │ ├── test_case_1 │ │ │ ├── test_case_2 │ │ │ ├── test_case_3 │ │ │ └── test_case_4 │ │ ├── shortest_path_dag │ │ │ ├── test_case_1 │ │ │ └── test_case_2 │ │ ├── strongly_connected_components │ │ │ ├── test_case_1 │ │ │ ├── test_case_2 │ │ │ └── test_case_3 │ │ └── topological_sort │ │ │ └── test_case_1 │ ├── greedy │ │ ├── activity_selection │ │ │ └── test_case │ │ ├── fractional_knapsack │ │ │ └── test_case │ │ ├── huffman_coding │ │ │ └── test_case │ │ └── job_sequencing │ │ │ └── test_case │ ├── linked_list │ │ ├── add_polynomials_linked_list │ │ │ ├── test_case_1 │ │ │ ├── test_case_2 │ │ │ └── test_case_3 │ │ ├── clone_linked_list_pseudo │ │ │ ├── test_case_1 │ │ │ ├── test_case_2 │ │ │ ├── test_case_3 │ │ │ └── test_case_4 │ │ ├── merge_sorted_linked_list_reverse │ │ │ ├── test_case_1 │ │ │ ├── test_case_2 │ │ │ ├── test_case_3 │ │ │ └── test_case_4 │ │ ├── move_all_occurances_to_end │ │ │ └── test_case │ │ └── pairwise_swap │ │ │ └── test_case │ ├── matrix │ │ ├── circular_matrix │ │ │ └── test_case │ │ └── sparse_matrix │ │ │ ├── test_case_1 │ │ │ ├── test_case_2 │ │ │ └── test_case_3 │ ├── random │ │ ├── cartesian_product │ │ │ ├── test_case_1 │ │ │ ├── test_case_2 │ │ │ ├── test_case_3 │ │ │ └── test_case_4 │ │ ├── count_inversions │ │ │ ├── test_case_1 │ │ │ ├── test_case_2 │ │ │ ├── test_case_3 │ │ │ └── test_case_4 │ │ ├── is_digit_frequency_less_than_digit │ │ │ └── test_case │ │ ├── longest_palindromic_substring │ │ │ └── test_case │ │ └── second_smallest │ │ │ ├── test_case_1 │ │ │ ├── test_case_2 │ │ │ ├── test_case_3 │ │ │ └── test_case_4 │ ├── sort │ │ ├── test_case_1 │ │ ├── test_case_2 │ │ └── test_case_3 │ ├── string │ │ └── count_substrings_first_last │ │ │ └── test_case │ └── tree │ │ ├── check_bst_has_dead_end │ │ ├── test_case_1 │ │ ├── test_case_2 │ │ ├── test_case_3 │ │ └── test_case_4 │ │ ├── check_cousins_binary_tree │ │ ├── test_case_1 │ │ └── test_case_2 │ │ ├── check_sorted_subsequence_bst │ │ ├── test_case_1 │ │ ├── test_case_2 │ │ └── test_case_3 │ │ ├── convert_binary_tree_doubly_linked_list │ │ ├── test_case_1 │ │ ├── test_case_2 │ │ └── test_case_3 │ │ ├── count_half_nodes │ │ ├── test_case_1 │ │ ├── test_case_2 │ │ ├── test_case_3 │ │ └── test_case_4 │ │ ├── deepest_node_binary_tree │ │ ├── test_case_1 │ │ ├── test_case_2 │ │ ├── test_case_3 │ │ └── test_case_4 │ │ ├── full_nodes │ │ ├── test_case_1 │ │ ├── test_case_2 │ │ ├── test_case_3 │ │ └── test_case_4 │ │ ├── largest_bst │ │ ├── test_case_1 │ │ └── test_case_2 │ │ ├── lca │ │ ├── test_case_1 │ │ ├── test_case_2 │ │ ├── test_case_3 │ │ └── test_case_4 │ │ ├── max_diff_node_ancestor │ │ ├── test_case_1 │ │ ├── test_case_2 │ │ ├── test_case_3 │ │ └── test_case_4 │ │ ├── non_matching_leaves │ │ ├── test_case_1.1 │ │ ├── test_case_1.2 │ │ ├── test_case_2.1 │ │ ├── test_case_2.2 │ │ ├── test_case_3.1 │ │ └── test_case_3.2 │ │ └── smallest_sub_tree_deepest_nodes │ │ └── test_case ├── src │ ├── array │ │ ├── CountPairsSortedLessThanSum.java │ │ ├── ElementOccursOnce.java │ │ ├── EqualSumSubArrays.java │ │ ├── FindAllPairsABCD.java │ │ ├── FindCommonThreeSortedArrays.java │ │ ├── FindMissingNumber.java │ │ ├── MinimumSumAbsDiffTwoArrays.java │ │ ├── NobleIntegersInArray.java │ │ ├── SumOfDistinctInArray.java │ │ └── UnionAndIntersection.java │ ├── backtracking │ │ └── KnightsPath.java │ ├── dp │ │ ├── CoinChange.java │ │ ├── CoinChangeMinCoins.java │ │ ├── CountBinaryWithoutConsecutiveOnes.java │ │ ├── CountWaysToReachNStairs.java │ │ ├── EggDroppingProblem.java │ │ ├── FibonacciNumber.java │ │ ├── Job.java │ │ ├── LargestSubsquareXO.java │ │ ├── Levenshtein.java │ │ ├── LongestBitonicSubsequence.java │ │ ├── LongestCommonSubsequence.java │ │ ├── LongestCommonSubstring.java │ │ ├── LongestIncreasingSubsequence.java │ │ ├── LongestPalindromicSubsequence.java │ │ ├── LongestPalindromicSubstring.java │ │ ├── MatrixMultiplication.java │ │ ├── MaximumSumIncreasingSubsequence.java │ │ ├── MaximumSumNonAdjacent.java │ │ ├── MaximumSumRectangularSubMatrix.java │ │ ├── MinCostPath.java │ │ ├── MinJumpsToEnd.java │ │ ├── OptimalBST.java │ │ ├── OptimalStrategyGamePicks.java │ │ ├── PalindromePartitioning.java │ │ ├── RodCutting.java │ │ ├── SubsetSum.java │ │ ├── TextJustification.java │ │ ├── TotalNumberOfBSTNKeys.java │ │ ├── TotalWaysMatrix.java │ │ ├── WeightedJobScheduling.java │ │ └── ZeroOneKnapsack.java │ ├── graph │ │ ├── BellmanFordShortestPath.java │ │ ├── ConnectedComponents.java │ │ ├── DetectCycleDirectedGraph.java │ │ ├── DetectCycleUndirectedGraph.java │ │ ├── DetectCycleUndirectedGraph2.java │ │ ├── DijkstraShortestPath.java │ │ ├── FloydWarshallShortestPath.java │ │ ├── KruskalMST.java │ │ ├── MinStepsKnightsTour.java │ │ ├── PrimMST.java │ │ ├── ShortestPathDAG.java │ │ ├── StronglyConnectedComponents.java │ │ └── TopologicalSort.java │ ├── greedy │ │ ├── ActivitySelection.java │ │ ├── FractionalKnapsack.java │ │ ├── HuffmanCoding.java │ │ └── JobSequencing.java │ ├── linked_list │ │ ├── AddPolynomialsLinkedList.java │ │ ├── CloneLinkedListPsuedo.java │ │ ├── MergeSortedLinkedListsReverse.java │ │ ├── MoveAllOccurancesToEnd.java │ │ └── PairwiseSwapLinkedList.java │ ├── matrix │ │ ├── CircularMatrix.java │ │ └── SparseMatrix.java │ ├── random │ │ ├── CartesianProduct.java │ │ ├── CountInversions.java │ │ ├── IsDigitFrequencyLessThanDigit.java │ │ ├── LongestPalindromicSubstring.java │ │ └── SecondSmallest.java │ ├── sort │ │ ├── BubbleSort.java │ │ ├── HeapSort.java │ │ ├── InsertionSort.java │ │ ├── MergeSort.java │ │ ├── SelectionSort.java │ │ └── Sort.java │ ├── string │ │ └── CountSubstringsFirstLastCharacters.java │ └── tree │ │ ├── CheckBSTHasDeadEnd.java │ │ ├── CheckCousinsBinaryTree.java │ │ ├── CheckSortedSubSequenceBST.java │ │ ├── ConvertBinaryTreeDoublyLinkedList.java │ │ ├── ConvertBinaryTreeDoublyLinkedList2.java │ │ ├── CountHalfNodesBinaryTree.java │ │ ├── DeepestNodeBinaryTree.java │ │ ├── FullNodesInBinaryTree.java │ │ ├── LCABinaryTree.java │ │ ├── LargestBST.java │ │ ├── MaxDifferenceNodeAncestor.java │ │ ├── MultiTree.java │ │ ├── MultiTreeNode.java │ │ ├── NonMatchingLeavesBinaryTree.java │ │ └── SmallestSubTreeDeepestNodes.java └── test │ ├── array │ ├── TestCountPairsSortedLessThanSum.java │ ├── TestElementOccursOnce.java │ ├── TestEqualSumSubArray.java │ ├── TestFindAllPairsABCD.java │ ├── TestFindCommonThreeSortedArrays.java │ ├── TestFindMissingNumber.java │ ├── TestMimumSumAbsDiffTwoArrays.java │ ├── TestNobleIntegersInArray.java │ ├── TestSumOfDistinctInArray.java │ └── TestUnionAndIntersection.java │ ├── dp │ ├── TestCoinChange.java │ ├── TestCoinChangeMinCoins.java │ ├── TestCountBinaryWithoutConsecutiveOnes.java │ ├── TestCountWaysToReachNStairs.java │ ├── TestEggDroppingProblem.java │ ├── TestFibonacciNumber.java │ ├── TestLargestSubsquareXO.java │ ├── TestLevenshtein.java │ ├── TestLongestBitonicSubsequence.java │ ├── TestLongestCommonSubsequence.java │ ├── TestLongestCommonSubstring.java │ ├── TestLongestIncreasingSubsequence.java │ ├── TestLongestPalindromicSubsequence.java │ ├── TestLongestPalindromicSubstring.java │ ├── TestMatrixMultiplication.java │ ├── TestMaximumSumIncreasingSubsequence.java │ ├── TestMaximumSumNonAdjacent.java │ ├── TestMaximumSumRectangularSubMatrix.java │ ├── TestMinCostPath.java │ ├── TestMinJumpsToEnd.java │ ├── TestOptimalBST.java │ ├── TestOptimalStrategyGamePicks.java │ ├── TestPalindromePartitioning.java │ ├── TestRodCutting.java │ ├── TestSubsetSum.java │ ├── TestTextJustification.java │ ├── TestTotalNumberOfBSTNkeys.java │ ├── TestTotalWaysMatrix.java │ ├── TestWeightedJobScheduling.java │ └── TestZeroOneKnapsack.java │ ├── graph │ ├── TestBellmanFordShortestPath.java │ ├── TestConnectedComponents.java │ ├── TestDetectCycleDirectedGraph.java │ ├── TestDetectCycleUndirectedGraph.java │ ├── TestDetectCycleUndirectedGraph2.java │ ├── TestDijkstraShortestPath.java │ ├── TestFloydWarshallShortestPath.java │ ├── TestKruskalMST.java │ ├── TestMinStepsKnightsTour.java │ ├── TestPrimMST.java │ ├── TestShortestPathDAG.java │ ├── TestStronglyConnectedComponents.java │ └── TestTopologicalSort.java │ ├── greedy │ ├── TestActivitySelection.java │ ├── TestFractionalKnapsack.java │ ├── TestHuffmanCoding.java │ └── TestJobSequencing.java │ ├── linked_list │ ├── TestAddPolynomialsLinkedList.java │ ├── TestCloneLinkedListPsuedo.java │ ├── TestMergeSortedLinkedListReverse.java │ ├── TestMoveAllOccurancesToEnd.java │ └── TestParwiseSwapLinkedList.java │ ├── matrix │ ├── TestCircularMatrix.java │ └── TestSparseMatrix.java │ ├── random │ ├── TestCartesianProduct.java │ ├── TestCountInversions.java │ ├── TestIsDigitFrequencyLesserThanDigit.java │ ├── TestLongestPalindromicSubstring.java │ └── TestSecondSmallest.java │ ├── sort │ ├── TestBubbleSort.java │ ├── TestHeapSort.java │ ├── TestInsertionSort.java │ ├── TestMergeSort.java │ └── TestSelectionSort.java │ ├── string │ └── TestCountSubstringsFirstLastCharacters.java │ └── tree │ ├── TestCheckBSTHasDeadEnd.java │ ├── TestCheckCousinsBinaryTree.java │ ├── TestCheckSortedSubSequenceBST.java │ ├── TestConvertBinaryTreeDoublyLinkedList.java │ ├── TestConvertBinaryTreeDoublyLinkedList2.java │ ├── TestCountHalfNodes.java │ ├── TestDeepestNodeBinaryTree.java │ ├── TestFullNodesBinaryTree.java │ ├── TestLCABinaryTree.java │ ├── TestLargestBST.java │ ├── TestMaxDifferenceNodeAncestor.java │ ├── TestNonMatchingLeavesBinaryTree.java │ └── TestSmallestSubTreeDeepestNodes.java ├── gradle └── wrapper │ ├── gradle-wrapper.jar │ └── gradle-wrapper.properties ├── gradlew ├── gradlew.bat └── settings.gradle /.classpath: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | -------------------------------------------------------------------------------- /.idea/.name: -------------------------------------------------------------------------------- 1 | cracking-the-code -------------------------------------------------------------------------------- /.idea/codeStyleSettings.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 7 | 9 | -------------------------------------------------------------------------------- /.idea/compiler.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | -------------------------------------------------------------------------------- /.idea/vcs.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /.project: -------------------------------------------------------------------------------- 1 | 2 | 3 | cracking-the-code 4 | Project cracking-the-code created by Buildship. 5 | 6 | 7 | 8 | 9 | org.eclipse.jdt.core.javabuilder 10 | 11 | 12 | 13 | 14 | 15 | org.eclipse.jdt.core.javanature 16 | org.eclipse.buildship.core.gradleprojectnature 17 | 18 | 19 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2016 Sudharsanan M 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /build.gradle: -------------------------------------------------------------------------------- 1 | /* 2 | * This build file was generated by the Gradle 'init' task. 3 | * 4 | * This generated file contains a commented-out sample Java project to get you started. 5 | * For more details take a look at the Java Quickstart chapter in the Gradle 6 | * user guide available at https://docs.gradle.org/3.4/userguide/tutorial_java_projects.html 7 | */ 8 | 9 | apply plugin: 'idea' 10 | apply plugin: 'java' 11 | apply plugin: 'jacoco' 12 | 13 | repositories { 14 | mavenCentral() 15 | } 16 | 17 | dependencies { 18 | testCompile 'junit:junit:4.12' 19 | testCompile 'org.hamcrest:hamcrest-library:1.3' 20 | } 21 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/.classpath: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/.project: -------------------------------------------------------------------------------- 1 | 2 | 3 | cracking-the-coding-interview 4 | 5 | 6 | 7 | 8 | 9 | org.eclipse.jdt.core.javabuilder 10 | 11 | 12 | 13 | 14 | 15 | org.eclipse.jdt.core.javanature 16 | org.eclipse.buildship.core.gradleprojectnature 17 | 18 | 19 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/build.gradle: -------------------------------------------------------------------------------- 1 | /* 2 | * This build file was generated by the Gradle 'init' task. 3 | * 4 | * This generated file contains a commented-out sample Java project to get you started. 5 | * For more details take a look at the Java Quickstart chapter in the Gradle 6 | * user guide available at https://docs.gradle.org/3.4/userguide/tutorial_java_projects.html 7 | */ 8 | 9 | // Apply the java plugin to add support for Java 10 | apply plugin: 'java' 11 | apply plugin: 'jacoco' 12 | 13 | sourceSets { 14 | main { 15 | java { 16 | srcDir 'src' 17 | } 18 | } 19 | 20 | test { 21 | java { 22 | srcDir 'test' 23 | } 24 | } 25 | } 26 | 27 | dependencies { 28 | compile project(':datastructures') 29 | } 30 | 31 | repositories { 32 | mavenCentral() 33 | } 34 | 35 | dependencies { 36 | testCompile 'junit:junit:4.12' 37 | testCompile 'org.hamcrest:hamcrest-library:1.3' 38 | } 39 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/gradle/wrapper/gradle-wrapper.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/scaffeinate/crack-the-code/b4a12b8c062ca89d033bc48c36ad4f43f7471012/cracking-the-coding-interview/gradle/wrapper/gradle-wrapper.jar -------------------------------------------------------------------------------- /cracking-the-coding-interview/gradle/wrapper/gradle-wrapper.properties: -------------------------------------------------------------------------------- 1 | #Mon Mar 27 00:36:13 EDT 2017 2 | distributionBase=GRADLE_USER_HOME 3 | distributionPath=wrapper/dists 4 | zipStoreBase=GRADLE_USER_HOME 5 | zipStorePath=wrapper/dists 6 | distributionUrl=https\://services.gradle.org/distributions/gradle-3.4-bin.zip 7 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_1/check_permutation/test_case: -------------------------------------------------------------------------------- 1 | django jdango true 2 | toffee eefffto false 3 | toffee eeffot true -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_1/one_away/test_case: -------------------------------------------------------------------------------- 1 | coding interview,coding_interview,true 2 | bulb,hulk,false 3 | cat,acat,true 4 | catch,catdhy,false 5 | calk,chalk,false 6 | cracking,cracking,true 7 | coding interview,codinginterview1,false -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_1/palindrome_permutation/test_case: -------------------------------------------------------------------------------- 1 | tacocat true 2 | tactful false 3 | ayalmmala true -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_1/rotate_matrix/test_case: -------------------------------------------------------------------------------- 1 | 1 2 4 5 6 9 2 | 2 3 1 3 4 8 3 | 0 9 8 2 4 5 4 | 9 4 5 6 2 1 5 | 7 8 0 1 0 2 6 | 1 2 7 8 9 0 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_1/string_compression/test_case: -------------------------------------------------------------------------------- 1 | aabcccccaaa,a2b1c5a3 2 | abccdefgm,abccdefgm 3 | aaabbbcccddd,a3b3c3d3 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_1/string_rotation/test_case: -------------------------------------------------------------------------------- 1 | waterbottle lewaterbott true 2 | bottle ottleb true 3 | wallet tewall false -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_1/string_unique/test_case: -------------------------------------------------------------------------------- 1 | Cracking The Code,false 2 | Fjord Nymphs XV Beg Quick Waltz,true 3 | Call,false 4 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_1/urlify/test_case: -------------------------------------------------------------------------------- 1 | Mr John Smith,Mr%20John%20Smith 2 | I Love Programming,I%20Love%20Programming 3 | G a m e,G%20a%20m%20e -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_1/zero_matrix/test_case_1: -------------------------------------------------------------------------------- 1 | 1 2 0 9 8 1 2 | 8 4 5 6 0 2 3 | 1 2 4 5 3 3 4 | 4 4 2 2 1 4 5 | 1 2 3 4 0 5 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_1/zero_matrix/test_case_2: -------------------------------------------------------------------------------- 1 | 1 2 0 4 2 | 5 6 7 0 3 | 0 9 1 3 4 | 1 0 2 1 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_1/zero_matrix/test_case_3: -------------------------------------------------------------------------------- 1 | 0 2 3 4 5 2 | 6 7 8 9 1 3 | 9 8 7 3 1 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_10/peaks_and_valleys/test_case: -------------------------------------------------------------------------------- 1 | 5,3,1,2,3 2 | 5,1,4,4,5,9,7,13,3 3 | 10,9,8,7,6,5 4 | 1,2,3,4,5 5 | 9,8,6,7,10,9,1,2,5,4,6,8 6 | 1,2,3,3,5 7 | 8,9,10,0,1,4,7,7 8 | 0,1 9 | 1 10 | 9,1,0,4,8,7 11 | 0,1,4,7,8,9 12 | 2,0,1 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_10/sort_stream/test_case_1: -------------------------------------------------------------------------------- 1 | t 5 2 | t 1 3 | t 4 4 | r 4 1 5 | t 4 6 | t 5 7 | r 5 4 8 | t 9 9 | t 7 10 | t 13 11 | r 13 7 12 | t 3 13 | r 3 1 14 | r 9 7 15 | r 13 8 16 | r 7 6 17 | r 1 0 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_10/sort_stream/test_case_2: -------------------------------------------------------------------------------- 1 | t 20 2 | t 15 3 | r 15 0 4 | t 10 5 | t 25 6 | r 25 3 7 | t 23 8 | t 5 9 | r 5 0 10 | t 13 2 11 | t 24 12 | r 24 6 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_10/sorted_merge/test_case: -------------------------------------------------------------------------------- 1 | 7,8,9,10,12,14,16,19,0,0,0,0,0,0,0:8:1,2,3,10,11,14,19:7|1,2,3,7,8,9,10,10,11,12,14,14,16,19,19 2 | 4,5,6,0,0,0:3:1,2,3:3|1,2,3,4,5,6 3 | 1,1,1,1,0,0,0,0:4:1,1,1,1:4|1,1,1,1,1,1,1,1 4 | 11,0,0,0,0,0,0,0,0,0,0:1:1,2,3,4,5,6,7,8,9,10:10|1,2,3,4,5,6,7,8,9,10,11 5 | 2,0:1:1:1|1,2 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_10/sorted_search_no_size/test_case: -------------------------------------------------------------------------------- 1 | 0,1,2,4,5,6,7|5|4 2 | 2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97|41|12 3 | 7,8,9,10,12,14,16,19|1|-1 4 | 0,1,1,2,3,5,8,13,21,34,55|0|0 5 | 0,1,1,2,3,5,8,13,21,34,55|55|10 6 | 0,1,1,2,3,5,8,13,21,34,55|1|2 7 | 2,2,2,3,3,3,5,5,7|3|4 8 | 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64|63|62 9 | 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31|14|13 10 | 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49|49|48 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_10/sparse_search/test_case: -------------------------------------------------------------------------------- 1 | a,,b,c,d,,e,f,,,,g,h|c|3 2 | a,,b,c,d,,e,f,,,,g,h|g|11 3 | a,,,,,b,,,,,c|b|5 4 | a,,,,,b,,,,,c|a|0 5 | a,,,,,b,,,,,c|c|10 6 | ,a,b,c,c,,,,d,,,d|d|8 7 | ,a,b,,c,d|a|1 8 | a,,c,,,d,,e,,g,,,i|d|5 9 | a,,c,,,d,,e,,g,,,i|e|7 10 | a,,g,,h,,j,,l,,m,,n|l|8 11 | a,,g,,h,,j,,l,,m,,n|b|-1 12 | ,,,,,,,,,,,,,,|a|-1 13 | d,,,,,,,,,|d|0 14 | d,,,,,,,,,|o|-1 15 | |z|-1 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_2/alternate_linking: -------------------------------------------------------------------------------- 1 | a1:a2:a3:a4:b1:b2:b3:b4 2 | a:b:c:d:e:f -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_2/delete_middle: -------------------------------------------------------------------------------- 1 | 3 1:12:5:3:2:1:8:9:30:3 2 | -1 8:9:5:3:6:9 3 | 1 8:9:5:3:6:9 4 | 3 3:5:2:8:1 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_2/detect_loops: -------------------------------------------------------------------------------- 1 | a:b:c:d:e:f:g:h -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_2/intersection: -------------------------------------------------------------------------------- 1 | 1:4:5:8:7:9:10 3:4:2:5:9:11:13 2 | 4:5:8:1:3:4:2:11 0:4:21:12:3:8:11:5:9:10 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_2/kth_to_last/test_case: -------------------------------------------------------------------------------- 1 | 2:4:21:12:5:3:2:1:8:9:30:3 5 2 2 | 1:5:5:9 4 -1 3 | 6:4:3:4:1:5 5 6 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_2/palindrome: -------------------------------------------------------------------------------- 1 | crackinc 2 | 123454321 3 | ssaaass 4 | aascdscaa 5 | malayalam 6 | a -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_2/partition: -------------------------------------------------------------------------------- 1 | 3:6:8:5:2:1 5 2 | 3:51:8:5:2:1 1 3 | 3:5:8:5:2:1 3 4 | 6:5:4:5:1:3:6 5 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_2/remove_duplicates/test_case: -------------------------------------------------------------------------------- 1 | 7:1:2:4:6:5:10:4:5:7:3:32:57:2:41 7:1:2:4:6:5:10:3:32:57:41 2 | 1:1:1:1:1 1 3 | 1:2:3:4:1:2:3 1:2:3:4 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_2/reverse_linked_list: -------------------------------------------------------------------------------- 1 | a:b:c:d:e 2 | 1:a:b:c:d:e:3:3:5 3 | a -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_2/sum_lists: -------------------------------------------------------------------------------- 1 | 9:3:1+8:2:7 2 | 1:8:7+9:7:5:6:1 3 | 7:5:1+9:0:9 4 | 9:1:6+6:1:9 5 | 0+1:2:4:5 6 | 9:9:9+9:9:9 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_3/animal_shelter: -------------------------------------------------------------------------------- 1 | enqueue Cat:1 2 | enqueue Dog:2 3 | enqueue Cat:3 4 | enqueue Cat:4 5 | enqueue Dog:1 6 | enqueue Cat:6 7 | enqueue Dog:1 8 | enqueue Dog:8 9 | enqueue Cat:2 10 | enqueue Dog:9 11 | enqueue Dog:2 12 | enqueue Cat:10 13 | dequeue 14 | dequeueDog 15 | dequeue 16 | dequeueCat -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_3/queue_via_stacks: -------------------------------------------------------------------------------- 1 | add(1) 2 | peek() 3 | remove() 4 | add(2) 5 | add(3) 6 | add(4) 7 | peek() 8 | add(5) 9 | remove() 10 | remove() 11 | add(6) 12 | add(7) 13 | peek() 14 | remove() 15 | remove() 16 | add(8) 17 | peek() 18 | remove() 19 | remove() 20 | peek() 21 | remove() -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_3/set_of_plates: -------------------------------------------------------------------------------- 1 | 5 2 | push(1) 3 | push(2) 4 | push(3) 5 | peek() 6 | push(4) 7 | push(5) 8 | push(6) 9 | peek() 10 | pop() 11 | peek() 12 | push(7) 13 | push(8) 14 | push(9) 15 | push(10) 16 | pop() 17 | push(11) 18 | peek() 19 | push(12) 20 | pop() 21 | push(13) 22 | push(14) 23 | peek() 24 | pop() 25 | push(15) 26 | push(16) 27 | peek() 28 | pop() 29 | peek() 30 | pop() 31 | pop() 32 | pop() 33 | pop() 34 | peek() -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_3/set_of_plates_rollover: -------------------------------------------------------------------------------- 1 | 5 2 | push(1) 3 | push(2) 4 | push(3) 5 | push(4) 6 | push(5) 7 | push(6) 8 | push(7) 9 | push(8) 10 | push(9) 11 | push(10) 12 | push(11) 13 | push(12) 14 | push(13) 15 | push(14) 16 | push(15) 17 | push(16) 18 | push(17) 19 | push(18) 20 | push(19) 21 | push(20) 22 | pop() 23 | popAt(1) 24 | popAt(0) 25 | popAt(1) 26 | popAt(1) 27 | push(21) 28 | push(22) 29 | push(23) 30 | push(24) 31 | popAt(0) 32 | popAt(0) 33 | peek() 34 | popAt(2) 35 | peek() 36 | popAt(2) 37 | peek() 38 | popAt(4) 39 | peek() 40 | popAt(2) 41 | peek() 42 | popAt(1) 43 | popAt(1) 44 | popAt(1) 45 | popAt(1) 46 | popAt(1) 47 | peek() -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_3/sort_stack: -------------------------------------------------------------------------------- 1 | 8 5 6 7 1 3 4 0 2 9 0 10 2 | 10 9 8 7 6 5 4 3 2 1 0 3 | 0 1 2 3 4 5 6 7 8 9 10 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_3/stack_min: -------------------------------------------------------------------------------- 1 | push(20) 2 | push(9) 3 | min() 4 | push(2) 5 | push(10) 6 | min() 7 | push(3) 8 | push(8) 9 | min() 10 | push(1) 11 | min() 12 | push(5) 13 | pop() 14 | pop() 15 | min() -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_3/stack_via_queues: -------------------------------------------------------------------------------- 1 | push(1) 2 | peek() 3 | pop() 4 | push(2) 5 | push(3) 6 | push(4) 7 | peek() 8 | push(5) 9 | pop() 10 | pop() 11 | push(6) 12 | push(7) 13 | peek() 14 | pop() 15 | pop() 16 | push(8) 17 | peek() 18 | pop() 19 | peek() 20 | pop() 21 | peek() 22 | pop() 23 | pop() 24 | peek() -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_3/three_in_one: -------------------------------------------------------------------------------- 1 | 5 3 2 | push(0,1) 3 | push(0,2) 4 | push(1,6) 5 | push(2,11) 6 | push(0,3) 7 | push(2,12) 8 | pop(0) 9 | pop(2) 10 | push(1,7) 11 | push(1,8) 12 | pop(2) 13 | pop(2) 14 | push(2,13) 15 | push(2,14) 16 | push(0,4) 17 | push(2,15) 18 | push(1,9) 19 | pop(0) 20 | pop(0) 21 | push(1,10) 22 | push(1,11) 23 | pop(1) 24 | push(0,5) -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_4/bst_sequences: -------------------------------------------------------------------------------- 1 | insertRoot 4 2 | insert 2 5 1 3 6 7 3 | bstSeq 4 | insertRoot 100 5 | insert 100 50 20 75 150 120 170 6 | bstSeq -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_4/build_order: -------------------------------------------------------------------------------- 1 | vertex a 2 | vertex b 3 | vertex c 4 | vertex d 5 | vertex e 6 | vertex f 7 | vertex g 8 | vertex h 9 | edge e a 10 | edge e b 11 | edge a f 12 | edge a c 13 | edge a b 14 | edge h b 15 | edge c f 16 | edge b f 17 | edge g d 18 | print -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_4/check_balanced: -------------------------------------------------------------------------------- 1 | insertRoot 5 2 | insert 2 3 | insert 8 4 | insert 1 5 | insert 7 6 | insert 3 7 | insert 2 8 | insert 4 9 | insert 10 10 | insert 11 11 | insert 12 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_4/check_subtree: -------------------------------------------------------------------------------- 1 | tree 2 | insertRoot 4 3 | insertLeft 4->8 4 | insertRight 4->5 5 | insertLeft 5->6 6 | insertRight 5->7 7 | insertLeft 7->1 8 | insertRight 7->10 9 | insertRight 1->3 10 | insertLeft 10->8 11 | insertRight 10->15 12 | insertLeft 1->6 13 | print 14 | subTree 15 | insertRoot 5 16 | insertLeft 5->6 17 | insertRight 5->7 18 | insertRight 7->10 19 | insertLeft 10->8 20 | insertRight 10->15 21 | print 22 | checkSubTree -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_4/common_ancestor: -------------------------------------------------------------------------------- 1 | insert 5 6 7 2 1 10 11 8 3 9 7 15 13 12 17 2 | print 3 | findAncestor 8 9 4 | findAncestor 11 17 5 | findAncestor 5 10 6 | findAncestor 2 8 7 | findAncestor 9 11 8 | findAncestor 6 8 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_4/list_of_depths: -------------------------------------------------------------------------------- 1 | insertRoot 6 2 | insert 3 3 | insert 9 4 | insert 2 5 | insert 5 6 | insert 8 7 | insert 10 8 | insert 1 9 | insert 4 10 | insert 7 11 | insert 11 12 | insert 4 13 | insert 12 14 | listOfDepths -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_4/minimal_tree: -------------------------------------------------------------------------------- 1 | 1 2 3 4 5 6 7 8 9 10 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_4/paths_with_sum: -------------------------------------------------------------------------------- 1 | insertRoot 5 2 | insert 2 3 | insert 8 4 | insert 1 5 | insert 4 6 | insert 7 7 | insert 10 8 | insert -1 9 | insert 2 10 | insert 3 11 | insert 6 12 | insert 9 13 | insert 11 14 | insert 12 15 | insert -1 16 | print 17 | pathsSum 23 18 | pathsSum 34 19 | pathsSum 7 20 | pathsSum 21 21 | pathsSum 3 22 | pathsSum 6 23 | pathsSum -1 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_4/random_node_binary_tree: -------------------------------------------------------------------------------- 1 | insertRoot 5 2 | insertLeft 5 4 3 | insertLeft 4 6 4 | insertRight 5 3 5 | insertRight 4 9 6 | insertLeft 9 1 7 | insertLeft 1 7 8 | insertRight 1 8 9 | insertLeft 3 2 10 | insertRight 8 10 11 | insertRight 10 0 12 | print 13 | find 4 14 | find 10 15 | find 21 16 | delete 1 17 | delete 0 18 | delete 5 19 | find 0 20 | find 1 21 | find 9 22 | print 23 | getRandom 24 | getRandom 25 | getRandom 26 | getRandom 27 | getRandom 28 | getRandom 29 | getRandom -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_4/random_node_bst: -------------------------------------------------------------------------------- 1 | insertRoot 5 2 | insert 4 3 | insert 6 4 | insert 3 5 | insert 9 6 | insert 1 7 | insert 7 8 | insert 8 9 | insert 2 10 | insert 10 11 | insert 0 12 | print 13 | find 4 14 | find 10 15 | find 21 16 | delete 9 17 | delete 5 18 | delete 3 19 | delete 1 20 | delete 17 21 | find 0 22 | find 1 23 | find 9 24 | print 25 | getRandom 26 | getRandom 27 | getRandom 28 | getRandom 29 | getRandom 30 | getRandom 31 | getRandom -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_4/route_between_nodes: -------------------------------------------------------------------------------- 1 | vertex 0 2 | vertex 1 3 | vertex 2 4 | vertex 3 5 | vertex 4 6 | vertex 5 7 | edge 0 1 8 | edge 0 4 9 | edge 0 5 10 | edge 1 4 11 | edge 1 3 12 | edge 3 4 13 | edge 3 2 14 | edge 2 1 15 | print 16 | route 0 4 17 | route 2 5 18 | route 0 2 19 | route 5 2 20 | route 3 3 21 | route 1 2 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_4/successor: -------------------------------------------------------------------------------- 1 | insertRoot 6 2 | insert 2 3 | insert 9 4 | insert 0 5 | insert 1 6 | insert 5 7 | insert 4 8 | insert 3 9 | insert 11 10 | insert 8 11 | insert 7 12 | insert 10 13 | insert 12 14 | insert 13 15 | print 16 | successor 13 17 | successor 5 18 | successor 7 19 | successor 1 20 | successor 9 21 | successor 6 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_4/validate_bst: -------------------------------------------------------------------------------- 1 | insert 6 4 8 1 5 7 10 1 2 | validate 3 | insert 6 4 8 1 5 7 10 1 9 4 | validate -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_5/binary_string/test_case: -------------------------------------------------------------------------------- 1 | 0.75 0.11 2 | 0.625 0.101 3 | 0.72 ERROR 4 | 0.375 0.011 5 | 0 ERROR 6 | 1 ERROR -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_5/conversion/test_case: -------------------------------------------------------------------------------- 1 | 11101 01111 2 2 | 00000 11111 5 3 | 101010 010101 6 4 | 0 1 1 5 | 1 0 1 6 | 11010 001 4 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_5/debugger/test_case: -------------------------------------------------------------------------------- 1 | 4 true 2 | 16 true 3 | 512 true 4 | 12 false 5 | 100 false 6 | 1 true 7 | 0 true -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_5/draw_line/test_case_1: -------------------------------------------------------------------------------- 1 | 16 6 12 2 2 | 8 3 | 0000000000000000 4 | 0000000000000000 5 | 0000000000000000 6 | 0000000000000000 7 | --- 8 | 0000000000000000 9 | 0000000000000000 10 | 0000001111111000 11 | 0000000000000000 12 | --- -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_5/draw_line/test_case_2: -------------------------------------------------------------------------------- 1 | 16 0 15 2 2 | 8 3 | 1111111111111111 4 | 0000000000000000 5 | 0000000000000000 6 | 0000000000000000 7 | --- 8 | 1111111111111111 9 | 0000000000000000 10 | 1111111111111111 11 | 0000000000000000 12 | --- -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_5/draw_line/test_case_3: -------------------------------------------------------------------------------- 1 | 8 2 5 0 2 | 4 3 | 00000000 4 | 11000011 5 | 11000011 6 | 00111100 7 | --- 8 | 00111100 9 | 11000011 10 | 11000011 11 | 00111100 12 | --- -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_5/draw_line/test_case_4: -------------------------------------------------------------------------------- 1 | 8 7 7 3 2 | 4 3 | 00000000 4 | 11000011 5 | 11000011 6 | 00111100 7 | --- 8 | 00000000 9 | 11000011 10 | 11000011 11 | 00111101 12 | --- -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_5/draw_line/test_case_5: -------------------------------------------------------------------------------- 1 | 16 12 16 3 2 | 8 3 | 1111111111111111 4 | 0000000000000000 5 | 0000000000000000 6 | 0000000000000000 7 | --- 8 | 1111111111111111 9 | 0000000000000000 10 | 0000000000000000 11 | 0000000000000000 12 | --- -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_5/flip_bit_to_win/test_case: -------------------------------------------------------------------------------- 1 | 11111110101101111 9 2 | 11011101111 8 3 | 1010101010101010 3 4 | 1111110101 8 5 | 111111 6 6 | 1000000111111 7 7 | 1 1 8 | 11111101111101101 12 9 | 10 2 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_5/insertion/test_case_1: -------------------------------------------------------------------------------- 1 | 11101000 1001 2 5 2 | 11100100 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_5/insertion/test_case_2: -------------------------------------------------------------------------------- 1 | 10000000000 10011 2 6 2 | 10001001100 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_5/insertion/test_case_3: -------------------------------------------------------------------------------- 1 | 1111111111 0000 5 8 2 | 1000011111 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_5/next_number/test_case: -------------------------------------------------------------------------------- 1 | 8 16 4 2 | 21 22 19 3 | 7 11 7 4 | 45 46 43 5 | 10290 10292 10289 6 | 13948 13967 13946 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_5/pairwise_swap/test_case: -------------------------------------------------------------------------------- 1 | 10110001 01110010 2 | 00101101 00011110 3 | 111111 111111 4 | 0 0 5 | 10011 100011 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_8/boolean_evaluation/test_case: -------------------------------------------------------------------------------- 1 | 1^0|0|1 false 2 2 | 0&0&0&1^1|0 true 10 3 | 1^0&1 true 2 4 | 1^0|0 true 2 5 | 1|1&0^1 true 4 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_8/coins/test_case: -------------------------------------------------------------------------------- 1 | 30 18 2 | 100 242 3 | 92 187 4 | 56 60 5 | 0 1 6 | 500 19006 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_8/magic_index/test_case: -------------------------------------------------------------------------------- 1 | 0,1,2,4,5,6,9 0,1,2 2 | 0,2,3,5,8,9,10 0 3 | -20,-15,-10,-5,0,1,2,5,8 8 4 | -40,-20,-1,1,2,3,5,7,9,12,13 7 5 | 1,2,3,4,5 -1 6 | -20,-15,-10,-5,0,1,2,5 -1 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_8/paint_fill/color_mappings: -------------------------------------------------------------------------------- 1 | 0:red 2 | 1:green 3 | 2:yellow 4 | 3:blue -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_8/paint_fill/input_matrix: -------------------------------------------------------------------------------- 1 | 0 1 1 2 2 2 2 0 2 | 0 2 2 1 1 0 2 2 3 | 0 0 2 1 1 1 2 2 4 | 0 0 0 1 1 2 2 2 5 | 0 0 0 1 1 2 2 2 6 | 1 1 1 1 1 1 1 2 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_8/paint_fill/test_case_1: -------------------------------------------------------------------------------- 1 | 3 1 3 2 | 3 1 1 2 2 2 2 0 3 | 3 2 2 1 1 0 2 2 4 | 3 3 2 1 1 1 2 2 5 | 3 3 3 1 1 2 2 2 6 | 3 3 3 1 1 2 2 2 7 | 1 1 1 1 1 1 1 2 8 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_8/paint_fill/test_case_2: -------------------------------------------------------------------------------- 1 | 5 5 2 2 | 0 1 1 2 2 2 2 0 3 | 0 2 2 2 2 0 2 2 4 | 0 0 2 2 2 2 2 2 5 | 0 0 0 2 2 2 2 2 6 | 0 0 0 2 2 2 2 2 7 | 2 2 2 2 2 2 2 2 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_8/paint_fill/test_case_3: -------------------------------------------------------------------------------- 1 | 0 3 1 2 | 0 1 1 1 1 1 1 0 3 | 0 2 2 1 1 0 1 1 4 | 0 0 2 1 1 1 1 1 5 | 0 0 0 1 1 1 1 1 6 | 0 0 0 1 1 1 1 1 7 | 1 1 1 1 1 1 1 1 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_8/paint_fill/test_case_4: -------------------------------------------------------------------------------- 1 | 1 5 3 2 | 0 1 1 2 2 2 2 0 3 | 0 2 2 1 1 3 2 2 4 | 0 0 2 1 1 1 2 2 5 | 0 0 0 1 1 2 2 2 6 | 0 0 0 1 1 2 2 2 7 | 1 1 1 1 1 1 1 2 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_8/parens/test_case: -------------------------------------------------------------------------------- 1 | 1 1 2 | 3 5 3 | 5 42 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_8/permutations_with_dups/test_case_1: -------------------------------------------------------------------------------- 1 | 1234 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_8/permutations_with_dups/test_case_2: -------------------------------------------------------------------------------- 1 | abcd -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_8/permutations_with_dups/test_case_3: -------------------------------------------------------------------------------- 1 | aabc -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_8/permutations_without_dups/test_case_1: -------------------------------------------------------------------------------- 1 | 1234 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_8/permutations_without_dups/test_case_2: -------------------------------------------------------------------------------- 1 | abcd -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_8/power_set/test_case: -------------------------------------------------------------------------------- 1 | a b c 2 | 5 4 2 1 3 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_8/recursive_multiply/test_case: -------------------------------------------------------------------------------- 1 | 7 5 35 2 | 1511111 153920 232590205120 3 | 60 80 4800 4 | 0 0 0 5 | 1 10 10 6 | 17 23 391 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_8/robot_in_a_grid/test_case_1: -------------------------------------------------------------------------------- 1 | 0 0 0 0 0 0 0 0 2 | 0 0 -1 0 0 0 -1 0 3 | 0 0 0 0 -1 0 0 0 4 | -1 0 -1 0 0 -1 0 0 5 | 0 0 -1 0 0 0 0 0 6 | 0 0 0 -1 -1 0 -1 0 7 | 0 -1 0 0 0 -1 0 0 8 | 0 0 0 0 0 0 0 0 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_8/robot_in_a_grid/test_case_2: -------------------------------------------------------------------------------- 1 | 0 0 -1 -1 -1 2 | -1 0 -1 0 0 3 | -1 0 0 0 0 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_8/robot_in_a_grid/test_case_3: -------------------------------------------------------------------------------- 1 | 0 0 -1 0 2 | 0 -1 0 0 3 | -1 0 0 0 4 | 0 0 0 0 5 | 0 0 0 0 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_8/stack_of_boxes/test_case_1: -------------------------------------------------------------------------------- 1 | 5 4 1 2 | 2 3 4 3 | 1 5 2 4 | 2 7 3 5 | 1 1 1 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_8/stack_of_boxes/test_case_2: -------------------------------------------------------------------------------- 1 | 3 4 1 2 | 8 6 2 3 | 7 8 3 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_8/stack_of_boxes/test_case_3: -------------------------------------------------------------------------------- 1 | 6 7 4 2 | 2 3 1 3 | 5 6 4 4 | 12 32 10 5 | 4 1 3 6 | 6 2 8 7 | 8 3 7 8 | 5 2 1 9 | 7 3 2 10 | 2 2 11 11 | 5 6 2 12 | 6 4 1 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_8/towers_of_hanoi/test_case: -------------------------------------------------------------------------------- 1 | 1 2 3 4 5 2 | 5 10 22 45 100 3 | 5 5 5 5 5 5 5 -------------------------------------------------------------------------------- /cracking-the-coding-interview/input_files/chapter_8/triple_step/test_case: -------------------------------------------------------------------------------- 1 | 19 66012 2 | 14 3136 3 | 9 149 4 | 50 906045778 5 | 99 1087163732 6 | 0 1 -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/chapter_10/GroupAnagrams.java: -------------------------------------------------------------------------------- 1 | package chapter_10; 2 | 3 | /** 4 | * Question 10.2: 5 | */ 6 | public class GroupAnagrams { 7 | 8 | } 9 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/chapter_10/Listy.java: -------------------------------------------------------------------------------- 1 | package chapter_10; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | /** 7 | * Created by sudharti on 8/9/17. 8 | */ 9 | public class Listy { 10 | private List list; 11 | 12 | public Listy() { 13 | list = new ArrayList(); 14 | } 15 | 16 | public int get(int index) { 17 | if (index < 0 || index >= list.size()) { 18 | return -1; 19 | } 20 | return list.get(index); 21 | } 22 | 23 | public void add(int value) { 24 | list.add(value); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/chapter_10/PeaksAndValleys.java: -------------------------------------------------------------------------------- 1 | package chapter_10; 2 | 3 | /** 4 | * Question 10.11: Peaks And Valleys 5 | */ 6 | public class PeaksAndValleys { 7 | public void sort(int[] nums) { 8 | for (int i = 0; i < nums.length - 1; i++) { 9 | if (((i % 2) == 0 && nums[i] < nums[i + 1]) || ((i % 2) != 0 && nums[i] > nums[i + 1])) { 10 | swap(nums, i, i + 1); 11 | } 12 | } 13 | } 14 | 15 | private void swap(int[] nums, int i, int j) { 16 | nums[i] = nums[i] + nums[j]; 17 | nums[j] = nums[i] - nums[j]; 18 | nums[i] = nums[i] - nums[j]; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/chapter_10/SearchInRotatedArray.java: -------------------------------------------------------------------------------- 1 | package chapter_10; 2 | 3 | /** 4 | * Question 10.3 5 | */ 6 | public class SearchInRotatedArray { 7 | public int search(int[] nums, int target) { 8 | if (nums.length == 0) return -1; 9 | return search(nums, target, 0, nums.length - 1); 10 | } 11 | 12 | private int search(int[] nums, int target, int start, int end) { 13 | if (start >= end) return (nums[start] == target) ? start : -1; 14 | int middle = (start + end) / 2; 15 | if (nums[middle] == target) return middle; 16 | else if (nums[middle] > nums[end]) { 17 | return (target >= nums[start] && middle > 0 && target <= nums[middle - 1]) 18 | ? search(nums, target, start, middle - 1) : search(nums, target, middle + 1, end); 19 | } else { 20 | return (target >= nums[middle + 1] && middle < nums.length - 1 && target <= nums[end]) 21 | ? search(nums, target, middle + 1, end) : search(nums, target, start, middle - 1); 22 | } 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/chapter_10/SortStream.java: -------------------------------------------------------------------------------- 1 | package chapter_10; 2 | 3 | /** 4 | * Question 10.10 5 | */ 6 | public class SortStream { 7 | private TreeNodeWithRank root = null; 8 | 9 | public void track(int n) { 10 | if (this.root == null) { 11 | this.root = new TreeNodeWithRank(n); 12 | } else { 13 | insert(this.root, n); 14 | } 15 | } 16 | 17 | public int getRank(int target) { 18 | return getRank(root, target); 19 | } 20 | 21 | private TreeNodeWithRank insert(TreeNodeWithRank root, int n) { 22 | if (root == null) { 23 | return new TreeNodeWithRank(n); 24 | } else if (root.value >= n) { 25 | root.incrementRank(); 26 | root.left = insert(root.left, n); 27 | } else { 28 | root.right = insert(root.right, n); 29 | } 30 | 31 | return root; 32 | } 33 | 34 | private int getRank(TreeNodeWithRank root, int target) { 35 | if (root == null) return -1; 36 | if (root.value == target) { 37 | return root.getRank(); 38 | } else if (root.value >= target) { 39 | return getRank(root.left, target); 40 | } else { 41 | int rank = getRank(root.right, target); 42 | return (rank == -1) ? -1 : (1 + root.getRank() + rank); 43 | } 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/chapter_10/SortedMerge.java: -------------------------------------------------------------------------------- 1 | package chapter_10; 2 | 3 | /** 4 | * Question 10.1: 5 | */ 6 | public class SortedMerge { 7 | public void mergeSorted(int[] arr1, int m, int[] arr2, int n) { 8 | int i = m - 1, j = n - 1, k = m + n - 1; 9 | while (i >= 0 && j >= 0) { 10 | if (arr1[i] > arr2[j]) arr1[k--] = arr1[i--]; 11 | else arr1[k--] = arr2[j--]; 12 | } 13 | while (i >= 0) arr1[k--] = arr1[i--]; 14 | while (j >= 0) arr1[k--] = arr2[j--]; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/chapter_10/SortedSearchNoSize.java: -------------------------------------------------------------------------------- 1 | package chapter_10; 2 | 3 | /** 4 | * Question 10.4 5 | */ 6 | public class SortedSearchNoSize { 7 | public int search(Listy listy, int target) { 8 | int i = 1; 9 | while (listy.get(i) != -1) { 10 | i *= 2; 11 | } 12 | int bound = findBound(listy, i / 2, i - 1); 13 | return search(listy, 0, bound, target); 14 | } 15 | 16 | private int search(Listy listy, int start, int end, int target) { 17 | if (start >= end) return (listy.get(start) == target) ? start : -1; 18 | int middle = (start + end) / 2; 19 | int current = listy.get(middle); 20 | if (current == target) { 21 | return middle; 22 | } else if (current > target) { 23 | return search(listy, start, middle - 1, target); 24 | } else { 25 | return search(listy, middle + 1, end, target); 26 | } 27 | 28 | } 29 | 30 | private int findBound(Listy listy, int start, int end) { 31 | if (start >= end) return start; 32 | int middle = (start + end) / 2; 33 | if (listy.get(middle) != -1 && listy.get(middle + 1) == -1) { 34 | return middle; 35 | } else if (listy.get(middle) == -1) { 36 | return findBound(listy, start, middle - 1); 37 | } else { 38 | return findBound(listy, middle + 1, end); 39 | } 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/chapter_10/SparseSearch.java: -------------------------------------------------------------------------------- 1 | package chapter_10; 2 | 3 | /** 4 | * Questio 5 | */ 6 | public class SparseSearch { 7 | public int sparseSearch(String[] arr, String s) { 8 | if (arr.length == 0) return -1; 9 | return search(arr, 0, arr.length - 1, s); 10 | } 11 | 12 | private int search(String[] arr, int start, int end, String s) { 13 | if (start >= end) return (arr[start].equals(s)) ? start : -1; 14 | int middle = (start + end) / 2; 15 | if (arr[middle].isEmpty()) { 16 | int index = search(arr, start, middle - 1, s); 17 | if (index == -1) { 18 | index = search(arr, middle + 1, end, s); 19 | } 20 | return index; 21 | } else if (arr[middle].equals(s)) { 22 | return middle; 23 | } else if (arr[middle].compareTo(s) > 0) { 24 | return search(arr, start, middle - 1, s); 25 | } else { 26 | return search(arr, middle + 1, end, s); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/chapter_10/TreeNodeWithRank.java: -------------------------------------------------------------------------------- 1 | package chapter_10; 2 | 3 | /** 4 | * Created by sudharti on 8/11/17. 5 | */ 6 | public class TreeNodeWithRank { 7 | protected TreeNodeWithRank left = null, right = null; 8 | protected int value = 0; 9 | private int rank = 0; 10 | 11 | public TreeNodeWithRank(int value) { 12 | this.value = value; 13 | } 14 | 15 | public void incrementRank() { 16 | this.rank++; 17 | } 18 | 19 | public int getRank() { 20 | return this.rank; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/chapter_3/QueueViaStacks.java: -------------------------------------------------------------------------------- 1 | package chapter_3; 2 | 3 | import java.io.FileNotFoundException; 4 | 5 | import chapter_3.stack_queue.MyQueue; 6 | import util.InputUtil; 7 | 8 | /** 9 | * Question 3.4: Implement a MyQueue class which implements a queue using two 10 | * stacks 11 | * 12 | * @author Sudharsanan Muralidharan 13 | */ 14 | public class QueueViaStacks { 15 | public static void main(String[] args) throws FileNotFoundException { 16 | String[] input = InputUtil.readContents(3, "queue_via_stacks"); 17 | MyQueue myQueue = new MyQueue(); 18 | for (String line : input) { 19 | if (line.startsWith("add")) { 20 | int data = Integer.parseInt(InputUtil.getArg(line)); 21 | System.out.println("Adding to queue: " + data); 22 | myQueue.add(data); 23 | } else if (line.startsWith("remove")) { 24 | System.out.println("Removing from queue : " + myQueue.remove()); 25 | } else if (line.startsWith("peek")) { 26 | System.out.println("Peek: " + myQueue.peek()); 27 | } 28 | } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/chapter_3/stack_queue/Animal.java: -------------------------------------------------------------------------------- 1 | package chapter_3.stack_queue; 2 | 3 | /** 4 | * abstract class Animal 5 | * 6 | * @param 7 | * @author Sudharsanan Muralidharan 8 | */ 9 | public abstract class Animal { 10 | private T name; 11 | private int order; 12 | 13 | public Animal(T name) { 14 | this.name = name; 15 | } 16 | 17 | public T getName() { 18 | return name; 19 | } 20 | 21 | public void setName(T name) { 22 | this.name = name; 23 | } 24 | 25 | public int getOrder() { 26 | return order; 27 | } 28 | 29 | public void setOrder(int order) { 30 | this.order = order; 31 | } 32 | 33 | public boolean isOlderThan(Animal animal) { 34 | return (this.order < animal.order); 35 | } 36 | 37 | @Override 38 | public String toString() { 39 | StringBuilder builder = new StringBuilder(); 40 | builder.append("Name: ").append(this.name).append(" Of Type: ").append(this.getClass().getSimpleName()); 41 | builder.append(" Of Order: ").append(this.order); 42 | return builder.toString(); 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/chapter_3/stack_queue/Cat.java: -------------------------------------------------------------------------------- 1 | package chapter_3.stack_queue; 2 | 3 | /** 4 | * class Cat extends Animal 5 | * 6 | * @param 7 | * @author Sudharsanan Muralidharan 8 | */ 9 | public class Cat extends Animal { 10 | public Cat(T name) { 11 | super(name); 12 | } 13 | } -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/chapter_3/stack_queue/Dog.java: -------------------------------------------------------------------------------- 1 | package chapter_3.stack_queue; 2 | 3 | /** 4 | * class Dog extends Animal 5 | * 6 | * @param 7 | * @author Sudharsanan Muralidharan 8 | */ 9 | public class Dog extends Animal { 10 | public Dog(T name) { 11 | super(name); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/chapter_3/stack_queue/MultiStack.java: -------------------------------------------------------------------------------- 1 | package chapter_3.stack_queue; 2 | 3 | /** 4 | * Interface Multistack operations 5 | * 6 | * @author Sudharsanan Muralidharan 7 | */ 8 | public interface MultiStack { 9 | void push(int stackNumber, int value); 10 | 11 | int pop(int stackNumber); 12 | 13 | boolean isEmpty(int stackNumber); 14 | 15 | String toString(int stackNumber); 16 | 17 | String toString(); 18 | } -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/chapter_5/BinaryString.java: -------------------------------------------------------------------------------- 1 | package chapter_5; 2 | 3 | public class BinaryString { 4 | public String toBinaryString(double num) { 5 | if (num <= 0 || num >= 1) { 6 | return "ERROR"; 7 | } 8 | 9 | StringBuilder builder = new StringBuilder(); 10 | builder.append("0."); 11 | int counter = 0; 12 | while (num > 0) { 13 | if (counter >= 32) { 14 | return "ERROR"; 15 | } 16 | num = num * 2; 17 | if (num >= 1) { 18 | builder.append(1); 19 | num -= 1; 20 | } else { 21 | builder.append(0); 22 | } 23 | counter++; 24 | } 25 | return builder.toString(); 26 | } 27 | 28 | public String toBinaryString2(double num) { 29 | if (num <= 0 || num >= 1) { 30 | return "ERROR"; 31 | } 32 | StringBuilder builder = new StringBuilder(); 33 | builder.append("0."); 34 | int counter = 0; 35 | double base = 0.5; 36 | while (num > 0) { 37 | if (counter >= 32) { 38 | return "ERROR"; 39 | } 40 | 41 | if (num >= base) { 42 | builder.append(1); 43 | num -= base; 44 | } else { 45 | builder.append(0); 46 | } 47 | base /= 2; 48 | counter++; 49 | } 50 | 51 | return builder.toString(); 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/chapter_5/Conversion.java: -------------------------------------------------------------------------------- 1 | package chapter_5; 2 | 3 | public class Conversion { 4 | 5 | public int numConversionBits(int n, int m) { 6 | int x = n ^ m; 7 | return countOnes(x); 8 | } 9 | 10 | private int countOnes(int n) { 11 | int counter = 0; 12 | while (n > 0) { 13 | n = (n & (n - 1)); 14 | counter++; 15 | } 16 | 17 | return counter; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/chapter_5/Debugger.java: -------------------------------------------------------------------------------- 1 | package chapter_5; 2 | 3 | public class Debugger { 4 | public boolean powerOfTwo(int n) { 5 | return (n & (n - 1)) == 0; 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/chapter_5/FlipBitToWin.java: -------------------------------------------------------------------------------- 1 | package chapter_5; 2 | 3 | public class FlipBitToWin { 4 | 5 | public int flipBitToWin(String binaryString) { 6 | int max = Integer.MIN_VALUE; 7 | int val = Integer.parseInt(binaryString, 2); 8 | int leftCounter = 0, rightCounter = 0, zeroCounter = 0; 9 | while (val > 0) { 10 | if ((val & 1) != 0) { 11 | leftCounter++; 12 | } else { 13 | rightCounter = leftCounter; 14 | leftCounter = 0; 15 | zeroCounter = 1; 16 | } 17 | 18 | max = Math.max(max, (leftCounter + rightCounter + zeroCounter)); 19 | val >>= 1; 20 | } 21 | 22 | return max; 23 | } 24 | 25 | public int flipBitToWin2(String binaryString) { 26 | int max = Integer.MIN_VALUE; 27 | ; 28 | int val = Integer.parseInt(binaryString, 2); 29 | int leftCounter = 0, rightCounter = 0; 30 | int allOnes = (1 << binaryString.length()) - 1; 31 | 32 | if ((allOnes - val) == 0) { 33 | return binaryString.length(); 34 | } 35 | 36 | while (val > 0) { 37 | if ((val & 1) != 0) { 38 | leftCounter++; 39 | } else { 40 | rightCounter = ((val & 2) == 0) ? 0 : leftCounter; 41 | leftCounter = 0; 42 | } 43 | 44 | max = Math.max(max, (leftCounter + rightCounter + 1)); 45 | val >>>= 1; 46 | } 47 | 48 | return max; 49 | } 50 | 51 | } 52 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/chapter_5/Insertion.java: -------------------------------------------------------------------------------- 1 | package chapter_5; 2 | 3 | public class Insertion { 4 | public String insertMIntoN(int m, int n, int i, int j) { 5 | int nCleared = clearBits(n, i, j); 6 | return Integer.toBinaryString(nCleared | (m << i)); 7 | } 8 | 9 | private int clearBits(int n, int i, int j) { 10 | int leftCleared = -1 >>> (31 - j); // 00111111 11 | int rightCleared = -1 << i; // 11111100 12 | int mask = ~(leftCleared & rightCleared); // mask 00111100, ~(mask) 11000011 13 | return n & mask; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/chapter_5/PairwiseSwap.java: -------------------------------------------------------------------------------- 1 | package chapter_5; 2 | 3 | public class PairwiseSwap { 4 | 5 | public int swap(int n) { 6 | return ((n & 0xAAAAAAAA) >>> 1) | ((n & 0x55555555) << 1); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/chapter_8/BalancedBrackets.java: -------------------------------------------------------------------------------- 1 | /** 2 | * 3 | */ 4 | package chapter_8; 5 | 6 | import java.util.HashMap; 7 | import java.util.Map; 8 | import java.util.Stack; 9 | 10 | /** 11 | * @author Sudharsanan Muralidharan 12 | */ 13 | public class BalancedBrackets { 14 | 15 | private static Map mapping = null; 16 | 17 | public BalancedBrackets() { 18 | mapping = new HashMap(); 19 | mapping.put('(', ')'); 20 | } 21 | 22 | public boolean isBalanced(String s) { 23 | Stack stack = new Stack(); 24 | 25 | for (int i = 0; i < s.length(); i++) { 26 | char c = s.charAt(i); 27 | if (c == '(') { 28 | stack.push(c); 29 | } else if (c == ')') { 30 | if (stack.isEmpty() || (!stack.isEmpty() && c != mapping.getOrDefault(stack.pop(), ' '))) { 31 | return false; 32 | } 33 | } 34 | } 35 | 36 | return stack.isEmpty(); 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/chapter_8/Box.java: -------------------------------------------------------------------------------- 1 | package chapter_8; 2 | 3 | public class Box { 4 | public int width = 0, height = 0, depth = 0; 5 | 6 | public Box(int width, int height, int depth) { 7 | this.width = width; 8 | this.height = height; 9 | this.depth = depth; 10 | } 11 | 12 | public boolean greaterThan(Box box) { 13 | return (this.width > box.width && this.height > box.height && this.depth > box.depth); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/chapter_8/Color.java: -------------------------------------------------------------------------------- 1 | package chapter_8; 2 | 3 | public class Color { 4 | public int colorCode = 0; 5 | public String color; 6 | 7 | public Color(int colorCode, String color) { 8 | this.colorCode = colorCode; 9 | this.color = color; 10 | } 11 | 12 | @Override 13 | public String toString() { 14 | return this.colorCode + ":" + this.color; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/chapter_8/MagicIndex.java: -------------------------------------------------------------------------------- 1 | package chapter_8; 2 | 3 | public class MagicIndex { 4 | public int findMagicIndex(int[] arr) { 5 | return findMagicIndex(arr, 0, arr.length - 1); 6 | } 7 | 8 | private int findMagicIndex(int[] arr, int start, int end) { 9 | if (start > end) { 10 | return -1; 11 | } 12 | 13 | int middle = (start + end) / 2; 14 | if (arr[middle] == middle) { 15 | return middle; 16 | } else if (arr[middle] > middle) { 17 | return findMagicIndex(arr, start, middle - 1); 18 | } else { 19 | return findMagicIndex(arr, middle + 1, end); 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/chapter_8/PermutationsWithDups.java: -------------------------------------------------------------------------------- 1 | package chapter_8; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | import java.util.Map; 6 | import java.util.Map.Entry; 7 | import java.util.Set; 8 | import java.util.TreeMap; 9 | 10 | public class PermutationsWithDups { 11 | 12 | public List permutations(String word) { 13 | List results = new ArrayList(); 14 | Map counterMap = new TreeMap(); 15 | for (char c : word.toCharArray()) { 16 | counterMap.put(c, counterMap.getOrDefault(c, 0) + 1); 17 | } 18 | permutate(counterMap, new StringBuilder(), results); 19 | return results; 20 | } 21 | 22 | private void permutate(Map map, StringBuilder builder, List results) { 23 | Set> entrySet = map.entrySet(); 24 | boolean nonZeroExists = false; 25 | for (Entry entry : entrySet) { 26 | char c = entry.getKey(); 27 | int counter = entry.getValue(); 28 | if (entry.getValue() > 0) { 29 | map.put(c, counter - 1); 30 | builder.append(c); 31 | permutate(map, builder, results); 32 | builder.setLength(builder.length() - 1); 33 | map.put(c, counter); 34 | nonZeroExists = true; 35 | } 36 | } 37 | 38 | if (!nonZeroExists) { 39 | results.add(builder.toString()); 40 | } 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/chapter_8/RecursiveMultiply.java: -------------------------------------------------------------------------------- 1 | package chapter_8; 2 | 3 | public class RecursiveMultiply { 4 | 5 | public long multiply(int m, int n) { 6 | if (m == 0 || n == 0) { 7 | return 0; 8 | } 9 | 10 | int min = (m < n) ? m : n; 11 | int max = (m < n) ? n : m; 12 | 13 | return recursiveMultiply(min, max); 14 | } 15 | 16 | private long recursiveMultiply(int m, int n) { 17 | if (m == 1) { 18 | return n; 19 | } else { 20 | return (recursiveMultiply((m >> 1), n) << 1) + ((m % 2 != 0) ? n : 0); 21 | } 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/chapter_8/TowersOfHanoi.java: -------------------------------------------------------------------------------- 1 | package chapter_8; 2 | 3 | import java.util.Stack; 4 | 5 | public class TowersOfHanoi { 6 | public Stack towers(Stack source) { 7 | Stack dest = new Stack(); 8 | towersOfHanoi(source.size(), source, new Stack(), dest); 9 | return dest; 10 | } 11 | 12 | private void towersOfHanoi(int n, Stack source, Stack temp, Stack dest) { 13 | if (n > 0) { 14 | // Move N-1 disks from source to temp 15 | towersOfHanoi(n - 1, source, dest, temp); 16 | // Move Nth disk from source to dest 17 | dest.push(source.pop()); 18 | // Move back the N-1 disks from temo to dest 19 | towersOfHanoi(n - 1, temp, source, dest); 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/chapter_8/TripleStep.java: -------------------------------------------------------------------------------- 1 | package chapter_8; 2 | 3 | public class TripleStep { 4 | public int countWays(int numSteps) { 5 | return countWays(numSteps, new int[numSteps + 1]); 6 | } 7 | 8 | private int countWays(int numSteps, int[] results) { 9 | if (numSteps < 0) { 10 | return 0; 11 | } else if (numSteps == 0) { 12 | return 1; 13 | } else if (results[numSteps] == 0) { 14 | results[numSteps] = countWays(numSteps - 1, results) + countWays(numSteps - 2, results) 15 | + countWays(numSteps - 3, results); 16 | } 17 | 18 | return results[numSteps]; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/src/util/TimerUtil.java: -------------------------------------------------------------------------------- 1 | package util; 2 | 3 | public class TimerUtil { 4 | 5 | private String process; 6 | private long startTime; 7 | private long stopTime; 8 | 9 | public TimerUtil(String process) { 10 | this.process = process; 11 | } 12 | 13 | public void setStartTime() { 14 | this.startTime = System.nanoTime(); 15 | } 16 | 17 | public void setStopTime() { 18 | this.stopTime = System.nanoTime(); 19 | } 20 | 21 | public void calculateExecTime() { 22 | System.out.println(this.process + " time taken: " + ((double) (this.stopTime - this.startTime) / 1000000) + "ms"); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/test/chapter_1/TestStringCompression.java: -------------------------------------------------------------------------------- 1 | package chapter_1; 2 | 3 | import static org.junit.Assert.assertEquals; 4 | 5 | import org.junit.AfterClass; 6 | import org.junit.BeforeClass; 7 | import org.junit.Test; 8 | 9 | import datastructures.util.InputUtil; 10 | 11 | public class TestStringCompression { 12 | private static String inputFile = "input_files/chapter_1/string_compression/test_case"; 13 | private static StringCompression stringCompression; 14 | private static String[] input = null; 15 | 16 | @BeforeClass 17 | public static void setup() { 18 | stringCompression = new StringCompression(); 19 | input = InputUtil.readContents(inputFile); 20 | } 21 | 22 | @AfterClass 23 | public static void teardown() { 24 | stringCompression = null; 25 | input = null; 26 | } 27 | 28 | @Test 29 | public void testStringCompressionTestCase1() { 30 | assertStringCompression(input[0]); 31 | } 32 | 33 | @Test 34 | public void testStringCompressionTestCase2() { 35 | assertStringCompression(input[1]); 36 | } 37 | 38 | @Test 39 | public void testStringCompressionTestCase3() { 40 | assertStringCompression(input[2]); 41 | } 42 | 43 | private void assertStringCompression(String input) { 44 | String[] values = input.split(","); 45 | String line = values[0]; 46 | assertEquals(values[1], stringCompression.compressString(line)); 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/test/chapter_1/TestStringRotation.java: -------------------------------------------------------------------------------- 1 | package chapter_1; 2 | 3 | import static org.junit.Assert.assertEquals; 4 | 5 | import org.junit.AfterClass; 6 | import org.junit.BeforeClass; 7 | import org.junit.Test; 8 | 9 | import datastructures.util.InputUtil; 10 | 11 | public class TestStringRotation { 12 | private static String inputFile = "input_files/chapter_1/string_rotation/test_case"; 13 | private static StringRotation stringRotation; 14 | private static String[] input = null; 15 | 16 | @BeforeClass 17 | public static void setup() { 18 | stringRotation = new StringRotation(); 19 | input = InputUtil.readContents(inputFile); 20 | } 21 | 22 | @AfterClass 23 | public static void teardown() { 24 | stringRotation = null; 25 | input = null; 26 | } 27 | 28 | @Test 29 | public void testStringRotationTestCase1() { 30 | assertStringRotation(input[0]); 31 | } 32 | 33 | @Test 34 | public void testStringRotationTestCase2() { 35 | assertStringRotation(input[1]); 36 | } 37 | 38 | @Test 39 | public void testStringRotationTestCase3() { 40 | assertStringRotation(input[2]); 41 | } 42 | 43 | private void assertStringRotation(String input) { 44 | String[] values = input.split(" "); 45 | assertEquals(Boolean.parseBoolean(values[2]), stringRotation.isStringRotation(values[0], values[1])); 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/test/chapter_1/TestURLify.java: -------------------------------------------------------------------------------- 1 | package chapter_1; 2 | 3 | import static org.junit.Assert.assertEquals; 4 | 5 | import org.junit.AfterClass; 6 | import org.junit.BeforeClass; 7 | import org.junit.Test; 8 | 9 | import datastructures.util.InputUtil; 10 | 11 | public class TestURLify { 12 | private static String inputFile = "input_files/chapter_1/urlify/test_case"; 13 | private static URLify urlify; 14 | private static String[] input = null; 15 | 16 | @BeforeClass 17 | public static void setup() { 18 | urlify = new URLify(); 19 | input = InputUtil.readContents(inputFile); 20 | } 21 | 22 | @AfterClass 23 | public static void teardown() { 24 | urlify = null; 25 | input = null; 26 | } 27 | 28 | @Test 29 | public void testURLifyTestCase1() { 30 | assertURLify(input[0]); 31 | } 32 | 33 | @Test 34 | public void testURLifyTestCase2() { 35 | assertURLify(input[1]); 36 | } 37 | 38 | @Test 39 | public void testURLifyTestCase3() { 40 | assertURLify(input[2]); 41 | } 42 | 43 | private void assertURLify(String input) { 44 | String[] values = input.split(","); 45 | String line = values[0]; 46 | assertEquals(values[1], urlify.getURL(line, line.length())); 47 | assertEquals(values[1], urlify.getURLForward(line, line.length())); 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/test/chapter_5/TestConversion.java: -------------------------------------------------------------------------------- 1 | package chapter_5; 2 | 3 | import static org.junit.Assert.assertEquals; 4 | 5 | import org.junit.AfterClass; 6 | import org.junit.BeforeClass; 7 | import org.junit.Test; 8 | 9 | import datastructures.util.InputUtil; 10 | 11 | public class TestConversion { 12 | private static String inputFile = "input_files/chapter_5/conversion/test_case"; 13 | private static Conversion conversion; 14 | private static String[] input = null; 15 | 16 | @BeforeClass 17 | public static void setup() { 18 | conversion = new Conversion(); 19 | input = InputUtil.readContents(inputFile); 20 | } 21 | 22 | @AfterClass 23 | public static void teardown() { 24 | conversion = null; 25 | input = null; 26 | } 27 | 28 | @Test 29 | public void testConversionTestCase() { 30 | for (String line : input) { 31 | String[] values = line.split(" "); 32 | int n = Integer.parseInt(values[0], 2); 33 | int m = Integer.parseInt(values[1], 2); 34 | int count = Integer.parseInt(values[2]); 35 | assertEquals(count, conversion.numConversionBits(n, m)); 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/test/chapter_5/TestDebugger.java: -------------------------------------------------------------------------------- 1 | package chapter_5; 2 | 3 | import static org.junit.Assert.assertEquals; 4 | 5 | import org.junit.AfterClass; 6 | import org.junit.BeforeClass; 7 | import org.junit.Test; 8 | 9 | import datastructures.util.InputUtil; 10 | 11 | public class TestDebugger { 12 | private static String inputFile = "input_files/chapter_5/debugger/test_case"; 13 | private static Debugger debugger; 14 | private static String[] input = null; 15 | 16 | @BeforeClass 17 | public static void setup() { 18 | debugger = new Debugger(); 19 | input = InputUtil.readContents(inputFile); 20 | } 21 | 22 | @AfterClass 23 | public static void teardown() { 24 | debugger = null; 25 | input = null; 26 | } 27 | 28 | @Test 29 | public void testDebuggerTestCase() { 30 | for (String line : input) { 31 | String[] values = line.split(" "); 32 | assertEquals(Boolean.parseBoolean(values[1]), debugger.powerOfTwo(Integer.parseInt(values[0]))); 33 | } 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/test/chapter_5/TestNextNumber.java: -------------------------------------------------------------------------------- 1 | package chapter_5; 2 | 3 | import static org.junit.Assert.assertEquals; 4 | 5 | import org.junit.AfterClass; 6 | import org.junit.BeforeClass; 7 | import org.junit.Test; 8 | 9 | import datastructures.util.InputUtil; 10 | 11 | public class TestNextNumber { 12 | private static String inputFile = "input_files/chapter_5/next_number/test_case"; 13 | private static NextNumber nextNumber; 14 | private static String[] input = null; 15 | 16 | @BeforeClass 17 | public static void setup() { 18 | nextNumber = new NextNumber(); 19 | input = InputUtil.readContents(inputFile); 20 | } 21 | 22 | @AfterClass 23 | public static void teardown() { 24 | nextNumber = null; 25 | input = null; 26 | } 27 | 28 | @Test 29 | public void testNextNumberTestCase() { 30 | for (String line : input) { 31 | assertNextNumber(line); 32 | } 33 | } 34 | 35 | private void assertNextNumber(String input) { 36 | String[] values = input.split(" "); 37 | int n = Integer.parseInt(values[0]); 38 | assertEquals(Integer.parseInt(values[1]), nextNumber.getNext(n)); 39 | assertEquals(Integer.parseInt(values[1]), nextNumber.getNext2(n)); 40 | assertEquals(Integer.parseInt(values[2]), nextNumber.getPrevious(n)); 41 | assertEquals(Integer.parseInt(values[2]), nextNumber.getPrevious2(n)); 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/test/chapter_5/TestPairwiseSwap.java: -------------------------------------------------------------------------------- 1 | package chapter_5; 2 | 3 | import static org.junit.Assert.assertEquals; 4 | 5 | import org.junit.AfterClass; 6 | import org.junit.BeforeClass; 7 | import org.junit.Test; 8 | 9 | import datastructures.util.InputUtil; 10 | 11 | public class TestPairwiseSwap { 12 | private static String inputFile = "input_files/chapter_5/pairwise_swap/test_case"; 13 | private static PairwiseSwap pairwiseSwap; 14 | private static String[] input = null; 15 | 16 | @BeforeClass 17 | public static void setup() { 18 | pairwiseSwap = new PairwiseSwap(); 19 | input = InputUtil.readContents(inputFile); 20 | } 21 | 22 | @AfterClass 23 | public static void teardown() { 24 | pairwiseSwap = null; 25 | input = null; 26 | } 27 | 28 | @Test 29 | public void testPairwiseSwapTestCase() { 30 | for (String line : input) { 31 | String[] values = line.split(" "); 32 | int n = Integer.parseInt(values[0], 2); 33 | assertEquals(Integer.parseInt(values[1], 2), pairwiseSwap.swap(n)); 34 | } 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /cracking-the-coding-interview/test/chapter_8/additional/TestCombinationsWithDups.java: -------------------------------------------------------------------------------- 1 | package chapter_8.additional; 2 | 3 | public class TestCombinationsWithDups { 4 | 5 | } 6 | -------------------------------------------------------------------------------- /datastructures/.classpath: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /datastructures/.project: -------------------------------------------------------------------------------- 1 | 2 | 3 | datastructures 4 | 5 | 6 | 7 | 8 | 9 | org.eclipse.jdt.core.javabuilder 10 | 11 | 12 | 13 | 14 | 15 | org.eclipse.jdt.core.javanature 16 | org.eclipse.buildship.core.gradleprojectnature 17 | 18 | 19 | -------------------------------------------------------------------------------- /datastructures/build.gradle: -------------------------------------------------------------------------------- 1 | /* 2 | * This build file was generated by the Gradle 'init' task. 3 | * 4 | * This generated file contains a commented-out sample Java project to get you started. 5 | * For more details take a look at the Java Quickstart chapter in the Gradle 6 | * user guide available at https://docs.gradle.org/3.4/userguide/tutorial_java_projects.html 7 | */ 8 | 9 | // Apply the java plugin to add support for Java 10 | apply plugin: 'java' 11 | apply plugin: 'jacoco' 12 | 13 | sourceSets { 14 | main { 15 | java { 16 | srcDir 'src' 17 | } 18 | } 19 | 20 | test { 21 | java { 22 | srcDir 'test' 23 | } 24 | } 25 | } 26 | 27 | repositories { 28 | mavenCentral() 29 | } 30 | 31 | dependencies { 32 | testCompile 'junit:junit:4.12' 33 | testCompile 'org.hamcrest:hamcrest-library:1.3' 34 | } 35 | -------------------------------------------------------------------------------- /datastructures/gradle/wrapper/gradle-wrapper.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/scaffeinate/crack-the-code/b4a12b8c062ca89d033bc48c36ad4f43f7471012/datastructures/gradle/wrapper/gradle-wrapper.jar -------------------------------------------------------------------------------- /datastructures/gradle/wrapper/gradle-wrapper.properties: -------------------------------------------------------------------------------- 1 | #Sun Mar 05 18:38:02 EST 2017 2 | distributionBase=GRADLE_USER_HOME 3 | distributionPath=wrapper/dists 4 | zipStoreBase=GRADLE_USER_HOME 5 | zipStorePath=wrapper/dists 6 | distributionUrl=https\://services.gradle.org/distributions/gradle-3.4-bin.zip 7 | -------------------------------------------------------------------------------- /datastructures/input_files/binary_heap/test_case_1: -------------------------------------------------------------------------------- 1 | insert 10 2 | insert 5 3 | insert 4 4 | insert 1 5 | insert 9 6 | insert 7 7 | insert 0 8 | insert 8 9 | insert 3 10 | insert 2 11 | insert 6 12 | extractAll -------------------------------------------------------------------------------- /datastructures/input_files/binary_heap/test_case_2: -------------------------------------------------------------------------------- 1 | insert 0 2 | insert 0 3 | insert 0 4 | insert 0 5 | insert -1 6 | insert -1 7 | insert -1 8 | insert -1 9 | extractAll -------------------------------------------------------------------------------- /datastructures/input_files/disjoint_sets/test_case_1: -------------------------------------------------------------------------------- 1 | makeSet 1 2 | makeSet 2 3 | makeSet 3 4 | makeSet 4 5 | makeSet 5 6 | makeSet 6 7 | makeSet 7 8 | union 1 2 9 | union 2 3 10 | union 4 5 11 | union 6 7 12 | union 5 6 13 | union 1 7 14 | findSet 2 15 | findSet 3 16 | findSet 7 17 | findSet 6 18 | findSet 4 19 | findSet 1 -------------------------------------------------------------------------------- /datastructures/input_files/disjoint_sets/test_case_2: -------------------------------------------------------------------------------- 1 | makeSet 1 2 | makeSet 2 3 | makeSet 3 4 | makeSet 4 5 | makeSet 5 6 | makeSet 6 7 | makeSet 7 8 | union 1 2 9 | union 2 3 10 | union 4 5 11 | union 6 7 12 | union 5 6 13 | findSet 2 14 | findSet 3 15 | findSet 7 16 | findSet 6 17 | findSet 4 18 | findSet 1 -------------------------------------------------------------------------------- /datastructures/input_files/disjoint_sets/test_case_3: -------------------------------------------------------------------------------- 1 | makeSet 1 2 | makeSet 2 3 | makeSet 3 4 | makeSet 4 5 | makeSet 5 6 | union 1 5 7 | union 2 3 8 | union 3 4 9 | union 2 4 10 | union 5 1 11 | union 3 2 12 | union 4 3 13 | union 1 1 14 | union 5 5 15 | union 4 4 16 | findSet 1 17 | findSet 2 18 | findSet 3 19 | findSet 4 20 | findSet 5 -------------------------------------------------------------------------------- /datastructures/input_files/max_priority_queue/test_case_1: -------------------------------------------------------------------------------- 1 | insert 0 quick_sort 2 | insert 0 insertion_sort 3 | insert 0 bubble_sort 4 | insert 0 heap_sort 5 | insert 0 merge_sort 6 | insert 0 double_pivoted_quick_sort 7 | insert 0 radix_sort 8 | insert 0 tree_sort 9 | increaseKey quick_sort 5 10 | increaseKey bubble_sort 0 11 | increaseKey heap_sort 4 12 | increaseKey merge_sort 8 13 | increaseKey double_pivoted_quick_sort 6 14 | increaseKey tree_sort 3 15 | increaseKey radix_sort 7 16 | increaseKey insertion_sort 2 17 | extractAll -------------------------------------------------------------------------------- /datastructures/input_files/max_priority_queue/test_case_2: -------------------------------------------------------------------------------- 1 | insert 1 prepare_algos 2 | insert 2 practice_hackerrank 3 | increaseKey prepare_algos 8 4 | insert 5 practice_leetcode 5 | increaseKey practice_hackerrank 6 6 | insert 5 do_side_projects 7 | insert 3 network 8 | increaseKey practice_leetcode 7 9 | increaseKey find_job 7 10 | insert 5 find_job 11 | increaseKey do_side_projects 6 12 | increaseKey prepare_algos 8 13 | extractAll 14 | -------------------------------------------------------------------------------- /datastructures/input_files/min_priority_queue/test_case_1: -------------------------------------------------------------------------------- 1 | insert 10 quick_sort 2 | insert 10 insertion_sort 3 | insert 10 bubble_sort 4 | insert 10 heap_sort 5 | insert 10 merge_sort 6 | insert 10 double_pivoted_quick_sort 7 | insert 10 radix_sort 8 | insert 10 tree_sort 9 | decreaseKey quick_sort 3 10 | decreaseKey bubble_sort 7 11 | decreaseKey heap_sort 4 12 | decreaseKey merge_sort 0 13 | decreaseKey double_pivoted_quick_sort 2 14 | decreaseKey tree_sort 5 15 | decreaseKey radix_sort 1 16 | decreaseKey insertion_sort 6 17 | extractAll -------------------------------------------------------------------------------- /datastructures/input_files/min_priority_queue/test_case_2: -------------------------------------------------------------------------------- 1 | insert 10 find_job 2 | insert 10 prepare_algos 3 | insert 10 practice_hackerrank 4 | decreaseKey find_job 7 5 | insert 8 practice_leetcode 6 | decreaseKey practice_hackerrank 7 7 | decreaseKey find_job 5 8 | insert 6 do_side_projects 9 | insert 4 network 10 | extractAll -------------------------------------------------------------------------------- /datastructures/input_files/test_binary_heap: -------------------------------------------------------------------------------- 1 | insert 2:5:10:1:7:7:0:3:4:5:8:12 2 | print 3 | peek 4 | insert 20 5 | extract 6 | insert -2 7 | peek 8 | extractAll 9 | buildHeap 5:13:2:25:7:17:20:8:4 10 | print 11 | extract 12 | print 13 | insert 0 14 | peek 15 | extractAll 16 | sort 7:5:2:9:18:1:0:6:4:5:8:10 -------------------------------------------------------------------------------- /datastructures/input_files/test_binary_search_tree: -------------------------------------------------------------------------------- 1 | insertRoot 15 2 | insertNodes 14,17,10,8,13,6,12,13,5,7,16,18,19,21,20 3 | traversal 4 | search 14 5 | search 5 6 | search 1 7 | minMax 8 | delete 10 9 | delete 20 10 | delete 21 11 | delete 15 12 | delete 8 13 | delete 12 14 | delete 13 15 | delete 12 16 | delete 16 17 | traversal 18 | search 14 19 | search 5 20 | search 1 21 | minMax -------------------------------------------------------------------------------- /datastructures/input_files/test_graph: -------------------------------------------------------------------------------- 1 | vertex Chennai 2 | vertex Banglore 3 | vertex Mumbai 4 | vertex Delhi 5 | vertex London 6 | vertex Berlin 7 | vertex Paris 8 | vertex Qatar 9 | vertex NY 10 | vertex Chicago 11 | vertex Dallas 12 | vertex SF 13 | vertex LA 14 | edge Chennai Banglore 15 | edge Chennai Delhi 16 | edge Chennai London 17 | edge Chennai Berlin 18 | edge Banglore Chennai 19 | edge Banglore Mumbai 20 | edge Banglore Delhi 21 | edge Mumbai Banglore 22 | edge Mumbai Delhi 23 | edge Delhi LA 24 | edge London Berlin 25 | edge London NY 26 | edge London Chicago 27 | edge Berlin London 28 | edge Berlin NY 29 | edge Berlin Dallas 30 | edge Berlin Paris 31 | edge Qatar Chennai 32 | edge Qatar Paris 33 | edge Paris LA 34 | edge NY Chicago 35 | edge NY Dallas 36 | edge NY London 37 | edge NY Qatar 38 | edge Chicago NY 39 | edge Chicago Dallas 40 | edge Chicago Berlin 41 | edge Dallas Chicago 42 | edge Dallas NY 43 | edge Dallas LA 44 | edge SF Dallas 45 | edge SF LA 46 | edge LA SF 47 | print 48 | search Paris London 49 | search Chennai SF 50 | search Mumbai Qatar 51 | search NY LA 52 | search Chicago Chicago 53 | search London Berlin 54 | search Banglore Berlin 55 | search Delhi LA 56 | search Qatar Dallas 57 | search Dallas Chennai 58 | search Chennai Paris 59 | search Paris NY 60 | traverse Paris 61 | -------------------------------------------------------------------------------- /datastructures/input_files/test_graph_set_2: -------------------------------------------------------------------------------- 1 | vertex A 2 | vertex B 3 | vertex C 4 | vertex D 5 | vertex E 6 | vertex F 7 | vertex G 8 | vertex H 9 | vertex I 10 | vertex J 11 | edge A B 12 | edge A E 13 | edge A F 14 | edge B D 15 | edge B C 16 | edge D G 17 | edge C H 18 | edge I H 19 | edge B J 20 | edge J A 21 | edge F E 22 | print 23 | search A I 24 | search D G 25 | search E J 26 | search J C 27 | traverse A 28 | traverse I 29 | traverse B 30 | traverse F -------------------------------------------------------------------------------- /datastructures/input_files/test_hash_table: -------------------------------------------------------------------------------- 1 | put list linkedlist 2 | put table hashtable 3 | put linear array 4 | put sorted bst 5 | put complex graph 6 | get complex 7 | get table 8 | get bilinear 9 | get list 10 | size 11 | remove linear 12 | get linear 13 | size 14 | put linear arraylist 15 | get sorted 16 | size 17 | keys 18 | print -------------------------------------------------------------------------------- /datastructures/input_files/test_max_priority_queue: -------------------------------------------------------------------------------- 1 | insert 10 launch_app 2 | insert 12 garbage_collect 3 | insert 5 launch_terminal 4 | insert 14 monitor_process 5 | insert 3 launch_browser 6 | insert 25 free_unused_memory 7 | print 8 | increaseKey free_unused_memory 25 9 | increaseKey free_unused_memory 40 10 | peek 11 | insert 52 new_critical_process 12 | insert 2 new_browser_tab 13 | insert 20 process_instruction 14 | increaseKey new_critical_process 54 15 | extract 16 | increaseKey process_instruction 1000 17 | insert 24 kill_signal 18 | insert 1 optimize_space 19 | print 20 | increaseKey kill_signal 50 21 | print 22 | extractAll -------------------------------------------------------------------------------- /datastructures/input_files/test_min_priority_queue: -------------------------------------------------------------------------------- 1 | insert 10 quick_sort 2 | insert 6 insertion_sort 3 | peek 4 | decreaseKey quick_sort 2 5 | insert 8 bubble_sort 6 | insert 5 heap_sort 7 | peek 8 | decreaseKey bubble_sort 7 9 | decreaseKey heap_sort 3 10 | insert 1 merge_sort 11 | insert 0 double_pivoted_quick_sort 12 | peek 13 | insert 4 radix_sort 14 | insert 7 tree_sort 15 | decreaseKey merge_sort -1 16 | decreaseKey double_pivoted_quick_sort 3 17 | peek 18 | decreaseKey tree_sort 5 19 | extractAll -------------------------------------------------------------------------------- /datastructures/input_files/trie/test_case_1: -------------------------------------------------------------------------------- 1 | insert Longing Rusted Seventeen Daybreak Furnace Nine Benign Homecoming One FreightCar 2 | print 3 | insert Long Seven Riots Seventy Days Futuristic NinetyNine Home OneWorld Freight Car Zero 4 | print 5 | prefixSearch One 6 | prefixSearch Ninety 7 | prefixSearch Longer 8 | prefixSearch Sewen 9 | prefixSearch Freight 10 | prefixSearch DaysOf 11 | search Ninety 12 | search Benign 13 | search Car 14 | search CarFax 15 | search Freight 16 | search Rusted* 17 | remove Long 18 | remove Seven 19 | remove Riots 20 | remove Seventy 21 | remove NinetyNine 22 | remove Zero 23 | remove DayBreaks 24 | remove Lone 25 | print 26 | prefixRemove Days 27 | prefixRemove Fut 28 | prefixRemove Car 29 | prefixRemove One 30 | prefixRemove Freight 31 | prefixRemove Home 32 | insert FreightCar Homecoming One 33 | print 34 | -------------------------------------------------------------------------------- /datastructures/input_files/trie/test_case_2: -------------------------------------------------------------------------------- 1 | insert Longing Rusted Seventeen Daybreak Furnace Nine Benign Homecoming One FreightCar 2 | print 3 | insert Long Seven Riots Seventy Days Futuristic NinetyNine Home OneWorld Freight Car Zero 4 | print 5 | prefixSearch One 6 | prefixSearch Ninety 7 | prefixSearch Longer 8 | prefixSearch Sewen 9 | prefixSearch Freight 10 | prefixSearch DaysOf 11 | search Ninety 12 | search Benign 13 | search Car 14 | search CarFax 15 | search Freight 16 | search Rusted* 17 | remove Long 18 | remove Seven 19 | remove Riots 20 | remove Seventy 21 | remove NinetyNine 22 | remove Zero 23 | remove DayBreaks 24 | remove Lone 25 | print 26 | prefixRemove Days 27 | prefixRemove Fut 28 | prefixRemove Car 29 | prefixRemove One 30 | prefixRemove Freight 31 | prefixRemove Home 32 | insert FreightCar Homecoming One 33 | print 34 | -------------------------------------------------------------------------------- /datastructures/src/datastructures/disjointsets/DisjointSetList.java: -------------------------------------------------------------------------------- 1 | /** 2 | * 3 | */ 4 | package datastructures.disjointsets; 5 | 6 | /** 7 | * @author Sudharsanan Muralidharan 8 | */ 9 | public class DisjointSetList { 10 | 11 | private DisjointSetListNode head = null; 12 | private DisjointSetListNode tail = null; 13 | private int size = 0; 14 | 15 | public DisjointSetListNode insert(T data) { 16 | DisjointSetListNode setElement = new DisjointSetListNode(data); 17 | head = tail = setElement; 18 | setElement.listRef = this; 19 | this.size++; 20 | return setElement; 21 | } 22 | 23 | public void append(DisjointSetList set) { 24 | this.tail.next = set.head; 25 | this.tail = set.tail; 26 | DisjointSetListNode current = set.head; 27 | while (current != null) { 28 | current.listRef = this; 29 | current = current.next; 30 | } 31 | 32 | this.size += set.size; 33 | } 34 | 35 | public DisjointSetListNode head() { 36 | return this.head; 37 | } 38 | 39 | public int size() { 40 | return this.size; 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /datastructures/src/datastructures/disjointsets/DisjointSetListNode.java: -------------------------------------------------------------------------------- 1 | /** 2 | * 3 | */ 4 | package datastructures.disjointsets; 5 | 6 | /** 7 | * @author Sudharsanan Muralidharan 8 | */ 9 | public class DisjointSetListNode { 10 | 11 | protected T data; 12 | 13 | protected DisjointSetListNode next; 14 | 15 | protected DisjointSetList listRef; 16 | 17 | public DisjointSetListNode(T data) { 18 | this(data, null); 19 | } 20 | 21 | public DisjointSetListNode(T data, DisjointSetList listRef) { 22 | this.data = data; 23 | this.listRef = listRef; 24 | } 25 | } -------------------------------------------------------------------------------- /datastructures/src/datastructures/disjointsets/DisjointSetNode.java: -------------------------------------------------------------------------------- 1 | package datastructures.disjointsets; 2 | 3 | public class DisjointSetNode { 4 | protected T data; 5 | protected DisjointSetNode parent = null; 6 | protected int rank = 0; 7 | 8 | public DisjointSetNode(T data) { 9 | this.data = data; 10 | this.parent = this; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /datastructures/src/datastructures/graph/DirectedGraph.java: -------------------------------------------------------------------------------- 1 | package datastructures.graph; 2 | 3 | public class DirectedGraph extends AbstractGraph { 4 | public DirectedGraph() { 5 | super(GraphType.DIRECTED); 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /datastructures/src/datastructures/graph/Edge.java: -------------------------------------------------------------------------------- 1 | package datastructures.graph; 2 | 3 | public class Edge { 4 | public int weight = 0; 5 | public String label; 6 | public Vertex sourceVertex; 7 | public Vertex destVertex; 8 | 9 | public Edge() { 10 | this(null, null); 11 | } 12 | 13 | public Edge(Vertex sourceVertex, Vertex destVertex) { 14 | this(sourceVertex, destVertex, 0); 15 | } 16 | 17 | public Edge(Vertex sourceVertex, Vertex destVertex, int weight) { 18 | this(sourceVertex, destVertex, weight, ""); 19 | } 20 | 21 | public Edge(Vertex sourceVertex, Vertex destVertex, int weight, String label) { 22 | this.sourceVertex = sourceVertex; 23 | this.destVertex = destVertex; 24 | this.weight = weight; 25 | this.label = label; 26 | } 27 | 28 | @Override 29 | public String toString() { 30 | return "Edge [ sourceVertex=" + sourceVertex + ", destVertex=" + destVertex + ", weight=" + weight + " ]"; 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /datastructures/src/datastructures/graph/GenericGraph.java: -------------------------------------------------------------------------------- 1 | package datastructures.graph; 2 | 3 | import java.util.List; 4 | 5 | public interface GenericGraph { 6 | 7 | public Vertex createVertex(T label); 8 | 9 | public boolean addVertex(Vertex v, T label); 10 | 11 | public boolean addEdge(Vertex sourceVertex, Vertex destVertex); 12 | 13 | public boolean addEdge(Vertex sourceVertex, Vertex destVertex, int weight); 14 | 15 | public boolean removeEdge(Vertex sourceVertex, Vertex destVertex); 16 | 17 | public boolean containsVertex(T label); 18 | 19 | public Vertex getVertex(T label); 20 | 21 | public List> edgesOf(Vertex v); 22 | 23 | public List> neighboursOf(Vertex v); 24 | 25 | public Edge getEdge(Vertex sourceVertex, Vertex destVertex); 26 | 27 | public boolean depthFirstSearch(Vertex sourceVertex, Vertex resultVertex); 28 | 29 | public boolean breadthFirstSearch(Vertex sourceVertex, Vertex resultVertex); 30 | 31 | public void depthFirstTraversal(Vertex sourceVertex); 32 | 33 | public void breadthFirstTraversal(Vertex sourceVertex); 34 | 35 | public String depthFirstPath(Vertex sourceVertex, Vertex resultVertex); 36 | 37 | public int numVertices(); 38 | 39 | public void print(); 40 | } 41 | -------------------------------------------------------------------------------- /datastructures/src/datastructures/graph/GraphType.java: -------------------------------------------------------------------------------- 1 | package datastructures.graph; 2 | 3 | public enum GraphType { 4 | DIRECTED, UNDIRECTED 5 | } 6 | -------------------------------------------------------------------------------- /datastructures/src/datastructures/graph/UndirectedGraph.java: -------------------------------------------------------------------------------- 1 | package datastructures.graph; 2 | 3 | public class UndirectedGraph extends AbstractGraph { 4 | public UndirectedGraph() { 5 | super(GraphType.UNDIRECTED); 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /datastructures/src/datastructures/graph/Vertex.java: -------------------------------------------------------------------------------- 1 | package datastructures.graph; 2 | 3 | import java.util.LinkedList; 4 | import java.util.List; 5 | 6 | public class Vertex { 7 | public T label; 8 | public List> incomingEdges; 9 | public List> outgoingEdges; 10 | public int numberOfIncomingEdges = 0; 11 | public int numberOfOutgoingEdges = 0; 12 | 13 | public Vertex() { 14 | this(null); 15 | } 16 | 17 | public Vertex(T label) { 18 | this.label = label; 19 | this.incomingEdges = new LinkedList>(); 20 | this.outgoingEdges = new LinkedList>(); 21 | } 22 | 23 | @Override 24 | public String toString() { 25 | return "Vertex [" + label + "]"; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /datastructures/src/datastructures/hashtable/HashTableNode.java: -------------------------------------------------------------------------------- 1 | package datastructures.hashtable; 2 | 3 | /** 4 | * HashTableNode class which holds the Tuple K, V 5 | * 6 | * @param 7 | * @param 8 | * @author Sudharsanan Muralidharan 9 | */ 10 | public class HashTableNode { 11 | K key; 12 | V value; 13 | ; 14 | HashTableNode next = null; 15 | 16 | public HashTableNode() { 17 | } 18 | 19 | public HashTableNode(K key, V value) { 20 | this.key = key; 21 | this.value = value; 22 | } 23 | 24 | public K getKey() { 25 | return this.key; 26 | } 27 | 28 | public V getValue() { 29 | return this.value; 30 | } 31 | 32 | } 33 | -------------------------------------------------------------------------------- /datastructures/src/datastructures/heap/BinaryMaxHeap.java: -------------------------------------------------------------------------------- 1 | package datastructures.heap; 2 | 3 | /** 4 | * Binary MaxHeap implementation. 5 | * 6 | * @param 7 | * @author Sudharsanan Muralidharan 8 | * @extends BinaryHeap 9 | */ 10 | public class BinaryMaxHeap extends BinaryHeap { 11 | 12 | /** 13 | * Use clazz to create heapArray of type clazz. InitialCapacity is not set so 14 | * pass -1. 15 | * 16 | * @param clazz 17 | */ 18 | public BinaryMaxHeap(Class clazz) { 19 | this(clazz, -1); 20 | } 21 | 22 | /** 23 | * Use clazz to create heapArray. Set initialCapacity of the heap. 24 | * 25 | * @param clazz 26 | * @param initialCapacity 27 | */ 28 | public BinaryMaxHeap(Class clazz, int initialCapacity) { 29 | super(clazz, initialCapacity, HeapType.MAX_HEAP); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /datastructures/src/datastructures/heap/BinaryMinHeap.java: -------------------------------------------------------------------------------- 1 | package datastructures.heap; 2 | 3 | /** 4 | * Binary MinHeap implementation. 5 | * 6 | * @param 7 | * @author Sudharsanan Muralidharan 8 | * @extends BinaryHeap 9 | */ 10 | public class BinaryMinHeap extends BinaryHeap { 11 | 12 | /** 13 | * Use clazz to create heapArray of type clazz. InitialCapacity is not set so 14 | * pass -1. 15 | * 16 | * @param clazz 17 | */ 18 | public BinaryMinHeap(Class clazz) { 19 | this(clazz, -1); 20 | } 21 | 22 | /** 23 | * Use clazz to create heapArray. Set initialCapacity of the heap. 24 | * 25 | * @param clazz 26 | * @param initialCapacity 27 | */ 28 | public BinaryMinHeap(Class clazz, int initialCapacity) { 29 | super(clazz, initialCapacity, HeapType.MIN_HEAP); 30 | } 31 | } -------------------------------------------------------------------------------- /datastructures/src/datastructures/heap/HeapType.java: -------------------------------------------------------------------------------- 1 | package datastructures.heap; 2 | 3 | /** 4 | * HeapType Enum which contains MIN_HEAP & MAX_HEAP values. 5 | * 6 | * @author Sudharsanan Muralidharan 7 | */ 8 | public enum HeapType { 9 | MIN_HEAP, MAX_HEAP 10 | } 11 | -------------------------------------------------------------------------------- /datastructures/src/datastructures/heap/PriorityQueueElement.java: -------------------------------------------------------------------------------- 1 | package datastructures.heap; 2 | 3 | /** 4 | * PriorityQueueElement class to hold the priority(key) and value 5 | * 6 | * @param

7 | * @param 8 | * @author Sudharsanan Muralidharan 9 | */ 10 | public class PriorityQueueElement { 11 | protected P priority; 12 | protected V value; 13 | 14 | public PriorityQueueElement() { 15 | } 16 | 17 | public PriorityQueueElement(P priority, V value) { 18 | this.priority = priority; 19 | this.value = value; 20 | } 21 | 22 | public P getPriority() { 23 | return priority; 24 | } 25 | 26 | public void setPriority(P priority) { 27 | this.priority = priority; 28 | } 29 | 30 | public V getValue() { 31 | return value; 32 | } 33 | 34 | public void setValue(V value) { 35 | this.value = value; 36 | } 37 | 38 | @Override 39 | public String toString() { 40 | StringBuilder builder = new StringBuilder(); 41 | builder.append(priority).append(":").append(value); 42 | return builder.toString(); 43 | } 44 | 45 | } 46 | -------------------------------------------------------------------------------- /datastructures/src/datastructures/lists/GenericList.java: -------------------------------------------------------------------------------- 1 | package datastructures.lists; 2 | 3 | /** 4 | * Generic List Interface 5 | * 6 | * @param 7 | * @author Sudharsanan Muralidharan 8 | */ 9 | public interface GenericList { 10 | public boolean add(T data); 11 | 12 | public boolean add(int index, T data); 13 | 14 | public boolean addToFront(T data); 15 | 16 | public boolean remove(Object o); 17 | 18 | public boolean remove(int index); 19 | 20 | public boolean removeFirst(); 21 | 22 | public boolean removeLast(); 23 | 24 | public T get(int index); 25 | 26 | public T set(int index, T data); 27 | 28 | public boolean contains(Object o); 29 | 30 | public LinkedListNode head(); 31 | 32 | public void head(LinkedListNode node); 33 | 34 | public LinkedListNode tail(); 35 | 36 | public void tail(LinkedListNode node); 37 | 38 | public Object[] toArray(); 39 | 40 | public int size(); 41 | 42 | public boolean isEmpty(); 43 | } 44 | -------------------------------------------------------------------------------- /datastructures/src/datastructures/lists/LinkedListNode.java: -------------------------------------------------------------------------------- 1 | /** 2 | * 3 | */ 4 | package datastructures.lists; 5 | 6 | /** 7 | * Class LinkedListNode 8 | * 9 | * @author Sudharsanan Muralidharan 10 | * @param 11 | */ 12 | public class LinkedListNode { 13 | public T data; 14 | public LinkedListNode next; 15 | public LinkedListNode prev; 16 | 17 | public LinkedListNode() { 18 | } 19 | 20 | public LinkedListNode(T data) { 21 | this(data, null); 22 | } 23 | 24 | public LinkedListNode(T data, LinkedListNode next) { 25 | this.data = data; 26 | this.next = next; 27 | } 28 | 29 | public LinkedListNode(T data, LinkedListNode next, LinkedListNode prev) { 30 | this.data = data; 31 | this.next = next; 32 | this.prev = prev; 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /datastructures/src/datastructures/stack/GenericStack.java: -------------------------------------------------------------------------------- 1 | package datastructures.stack; 2 | 3 | /** 4 | * AbstractStack Interface which has the basic stack functions. push(), pop() 5 | * and peek() 6 | * 7 | * @param 8 | * @author Sudharsanan Muralidharan 9 | */ 10 | 11 | public interface GenericStack { 12 | 13 | void push(T data); 14 | 15 | T pop(); 16 | 17 | T peek(); 18 | 19 | int size(); 20 | 21 | boolean isEmpty(); 22 | 23 | } -------------------------------------------------------------------------------- /datastructures/src/datastructures/test/TestCircularLinkedList.java: -------------------------------------------------------------------------------- 1 | package datastructures.test; 2 | 3 | import datastructures.lists.CircularLinkedList; 4 | 5 | public class TestCircularLinkedList { 6 | public static void main(String[] args) { 7 | CircularLinkedList list = new CircularLinkedList(); 8 | list.add(1); 9 | list.add(2); 10 | list.add(3); 11 | list.add(4); 12 | list.add(5); 13 | 14 | list.addToFront(15); 15 | list.add(12, 14); 16 | 17 | System.out.println(list.toString()); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /datastructures/src/datastructures/test/TestDoubleLinkedList.java: -------------------------------------------------------------------------------- 1 | package datastructures.test; 2 | 3 | import datastructures.lists.DoubleLinkedList; 4 | 5 | public class TestDoubleLinkedList { 6 | public static void main(String[] args) { 7 | DoubleLinkedList list = new DoubleLinkedList(); 8 | list.add(1); 9 | list.add(2); 10 | list.add(3); 11 | list.add(4); 12 | list.add(5); 13 | 14 | list.remove(4); 15 | 16 | list.addToFront(10); 17 | list.add(11, 0); 18 | list.add(15, 4); 19 | list.add(12, 2); 20 | 21 | System.out.println(list.get(5)); 22 | list.set(29, 5); 23 | 24 | list.print(); 25 | list.printReverse(); 26 | 27 | System.out.println(list.size()); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /datastructures/src/datastructures/tree/AbstractBinaryTree.java: -------------------------------------------------------------------------------- 1 | /** 2 | * 3 | */ 4 | package datastructures.tree; 5 | 6 | import datastructures.util.TreeUtil; 7 | 8 | /** 9 | * @author Sudharsanan Muralidharan 10 | */ 11 | public abstract class AbstractBinaryTree implements GenericBinaryTree { 12 | 13 | protected TreeNode root = null; 14 | 15 | protected boolean linkToParent; 16 | 17 | @Override 18 | public TreeNode insertRoot(T data) { 19 | root = new TreeNode(data); 20 | return root; 21 | } 22 | 23 | @Override 24 | public String breadthFirstTraversal(TreeNode root) { 25 | return TreeUtil.breadthFirstTraversal(root); 26 | } 27 | 28 | @Override 29 | public String depthFirstTraversal(TreeNode root) { 30 | return null; 31 | } 32 | 33 | @Override 34 | public String preOrder(TreeNode root) { 35 | return TreeUtil.preOrder(root); 36 | } 37 | 38 | @Override 39 | public String inOrder(TreeNode root) { 40 | return TreeUtil.inOrder(root); 41 | } 42 | 43 | @Override 44 | public String postOrder(TreeNode root) { 45 | return TreeUtil.postOrder(root); 46 | } 47 | 48 | public TreeNode getRoot() { 49 | return this.root; 50 | } 51 | 52 | public void setRoot(TreeNode root) { 53 | this.root = root; 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /datastructures/src/datastructures/tree/BinaryTree.java: -------------------------------------------------------------------------------- 1 | /** 2 | * 3 | */ 4 | package datastructures.tree; 5 | 6 | /** 7 | * @author Sudharsanan Muralidharan 8 | */ 9 | public class BinaryTree extends AbstractBinaryTree { 10 | 11 | public BinaryTree() { 12 | this(false); 13 | } 14 | 15 | public BinaryTree(boolean linkToParent) { 16 | super.linkToParent = linkToParent; 17 | } 18 | 19 | public TreeNode insert(TreeNode root, TreeNode node, boolean left) { 20 | if (root == null) { 21 | return null; 22 | } 23 | 24 | if (left) { 25 | root.left = node; 26 | } else { 27 | root.right = node; 28 | } 29 | 30 | if (linkToParent) { 31 | node.parent = root; 32 | } 33 | 34 | return node; 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /datastructures/src/datastructures/tree/GenericBinaryTree.java: -------------------------------------------------------------------------------- 1 | /** 2 | * 3 | */ 4 | package datastructures.tree; 5 | 6 | /** 7 | * @author Sudharsanan Muralidharan 8 | */ 9 | public interface GenericBinaryTree { 10 | 11 | public TreeNode insertRoot(T data); 12 | 13 | public String breadthFirstTraversal(TreeNode root); 14 | 15 | public String depthFirstTraversal(TreeNode root); 16 | 17 | public String preOrder(TreeNode root); 18 | 19 | public String inOrder(TreeNode root); 20 | 21 | public String postOrder(TreeNode root); 22 | 23 | public TreeNode getRoot(); 24 | 25 | public void setRoot(TreeNode root); 26 | } 27 | -------------------------------------------------------------------------------- /datastructures/src/datastructures/tree/TreeNode.java: -------------------------------------------------------------------------------- 1 | package datastructures.tree; 2 | 3 | public class TreeNode implements Comparable { 4 | public T data; 5 | public TreeNode parent = null; 6 | public TreeNode left = null; 7 | public TreeNode right = null; 8 | boolean visited = false; 9 | 10 | public TreeNode() { 11 | 12 | } 13 | 14 | public TreeNode(T data) { 15 | this(data, null, null); 16 | } 17 | 18 | public TreeNode(T data, TreeNode left, TreeNode right) { 19 | this.data = data; 20 | this.left = left; 21 | this.right = right; 22 | } 23 | 24 | @Override 25 | public int compareTo(T o) { 26 | if (o instanceof Integer) { 27 | return ((Integer) data).compareTo((Integer) o); 28 | } else if (o instanceof Float) { 29 | return ((Float) data).compareTo((Float) o); 30 | } else if (o instanceof Double) { 31 | return ((Double) data).compareTo((Double) o); 32 | } else if (o instanceof Character) { 33 | return ((Character) data).compareTo((Character) o); 34 | } else if (o instanceof String) { 35 | return ((String) data).compareTo((String) o); 36 | } 37 | 38 | return -1; 39 | } 40 | 41 | @Override 42 | public String toString() { 43 | StringBuilder builder = new StringBuilder(); 44 | builder.append("[").append(this.data).append("]"); 45 | return builder.toString(); 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /datastructures/src/datastructures/tree/TrieNode.java: -------------------------------------------------------------------------------- 1 | package datastructures.tree; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | 6 | public class TrieNode { 7 | Map children; 8 | 9 | public TrieNode() { 10 | children = new HashMap(); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /datastructures/src/datastructures/util/InputUtil.java: -------------------------------------------------------------------------------- 1 | package datastructures.util; 2 | 3 | import java.io.File; 4 | import java.io.FileNotFoundException; 5 | import java.io.FileReader; 6 | import java.util.ArrayList; 7 | import java.util.List; 8 | import java.util.Scanner; 9 | 10 | public class InputUtil { 11 | public static String[] readContents(String filePath) { 12 | FileReader fileReader = null; 13 | List inputList = null; 14 | try { 15 | fileReader = new FileReader(new File(filePath)); 16 | Scanner scanner = new Scanner(fileReader); 17 | inputList = new ArrayList(); 18 | 19 | while (scanner.hasNextLine()) { 20 | String line = scanner.nextLine().trim(); 21 | if (line != null && !line.isEmpty()) { 22 | inputList.add(line); 23 | } 24 | } 25 | scanner.close(); 26 | return (String[]) inputList.toArray(new String[inputList.size()]); 27 | } catch (FileNotFoundException e) { 28 | System.out.println("File Not Found " + e.getMessage()); 29 | } 30 | 31 | return null; 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /datastructures/test/datastructures/trie/TestTrie.java: -------------------------------------------------------------------------------- 1 | package datastructures.trie; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | import org.junit.After; 7 | import org.junit.AfterClass; 8 | import org.junit.Before; 9 | import org.junit.BeforeClass; 10 | import org.junit.Test; 11 | 12 | import datastructures.tree.Trie; 13 | import datastructures.util.InputUtil; 14 | 15 | public class TestTrie { 16 | private static final String basePath = "input_files/trie/"; 17 | private static String[] testCases = new String[]{"test_case_1", "test_case_2"}; 18 | private static List inputList = new ArrayList(); 19 | private Trie trie = null; 20 | 21 | @BeforeClass 22 | public static void setup() { 23 | for (String testCase : testCases) { 24 | String inputFile = basePath + testCase; 25 | inputList.add(InputUtil.readContents(inputFile)); 26 | } 27 | } 28 | 29 | @AfterClass 30 | public static void teardown() { 31 | testCases = null; 32 | inputList = null; 33 | } 34 | 35 | @Before 36 | public void setupTest() { 37 | trie = new Trie(); 38 | } 39 | 40 | @After 41 | public void teardownTest() { 42 | trie = null; 43 | } 44 | 45 | @Test 46 | public void testTrieTestCase1() { 47 | String[] input = inputList.get(0); 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /geeks-for-geeks/.classpath: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /geeks-for-geeks/.project: -------------------------------------------------------------------------------- 1 | 2 | 3 | geeks-for-geeks 4 | 5 | 6 | 7 | 8 | 9 | org.eclipse.jdt.core.javabuilder 10 | 11 | 12 | 13 | 14 | 15 | org.eclipse.jdt.core.javanature 16 | org.eclipse.buildship.core.gradleprojectnature 17 | 18 | 19 | -------------------------------------------------------------------------------- /geeks-for-geeks/build.gradle: -------------------------------------------------------------------------------- 1 | /* 2 | * This build file was generated by the Gradle 'init' task. 3 | * 4 | * This generated file contains a commented-out sample Java project to get you started. 5 | * For more details take a look at the Java Quickstart chapter in the Gradle 6 | * user guide available at https://docs.gradle.org/3.3/userguide/tutorial_java_projects.html 7 | */ 8 | 9 | // Apply the java plugin to add support for Java 10 | apply plugin: 'java' 11 | apply plugin: 'jacoco' 12 | 13 | sourceSets { 14 | main { 15 | java { 16 | srcDir 'src' 17 | } 18 | } 19 | 20 | test { 21 | java { 22 | srcDir 'test' 23 | } 24 | } 25 | } 26 | 27 | repositories { 28 | mavenCentral() 29 | } 30 | 31 | dependencies { 32 | compile project(':datastructures') 33 | } 34 | 35 | dependencies { 36 | testCompile 'junit:junit:4.12' 37 | testCompile 'org.hamcrest:hamcrest-library:1.3' 38 | } -------------------------------------------------------------------------------- /geeks-for-geeks/gradle/wrapper/gradle-wrapper.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/scaffeinate/crack-the-code/b4a12b8c062ca89d033bc48c36ad4f43f7471012/geeks-for-geeks/gradle/wrapper/gradle-wrapper.jar -------------------------------------------------------------------------------- /geeks-for-geeks/gradle/wrapper/gradle-wrapper.properties: -------------------------------------------------------------------------------- 1 | #Sat Apr 01 00:28:23 EDT 2017 2 | distributionBase=GRADLE_USER_HOME 3 | distributionPath=wrapper/dists 4 | zipStoreBase=GRADLE_USER_HOME 5 | zipStorePath=wrapper/dists 6 | distributionUrl=https\://services.gradle.org/distributions/gradle-3.4-bin.zip 7 | -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/array/count_pairs_sorted_less_than_sum/test_case: -------------------------------------------------------------------------------- 1 | 1,3,7,9,10,11 7 1 2 | 1,2,3,4,5,6,7,8 7 6 3 | 0,1,4,7,8,10,12,14 12 10 4 | 1,1,1,1,1,1,1 5 21 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/array/element_occurs_once/test_case: -------------------------------------------------------------------------------- 1 | 1,1,3,3,4,5,5,7,7,8,8 4 2 | 1,1,3,3,4,4,5,5,7,7,8 8 3 | 1,3,3,4,4,5,5,7,7,8,8 1 4 | 1,1,3,3,4,4,5,7,7,8,8 5 5 | 1,1,2,4,4,5,5,6,6 2 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/array/equal_sum_subarray/test_case: -------------------------------------------------------------------------------- 1 | 1,2,3,4,5,5 1,2,3,4 5,5 2 | 1,2,3,4 [] [] 3 | 5,1,2,2 5 1,2,2 4 | 1,1,1,1,1,5 1,1,1,1,1 5 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/array/find_all_pairs_abcd/test_case_1: -------------------------------------------------------------------------------- 1 | 3,4,7,1,2,9,8 2 | 8:4,2 and 1,8 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/array/find_all_pairs_abcd/test_case_2: -------------------------------------------------------------------------------- 1 | 1,6,3,9,2,10 2 | 6:1,6 and 3,2 3 | 18:6,3 and 9,2 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/array/find_all_pairs_abcd/test_case_3: -------------------------------------------------------------------------------- 1 | 1,2,3,4,5,6,7,8 2 | 6:1,6 and 2,3 3 | 8:1,8 and 2,4 4 | 12:2,6 and 3,4 5 | 24:3,8 and 4,6 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/array/find_common_three_sorted_arrays/test_case: -------------------------------------------------------------------------------- 1 | 1,5,10,20,40,80 6,7,20,80,100 3,4,15,20,30,70,80,120 20,80 2 | 1,5,5 3,4,5,5,10 5,5,10,20 5,5 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/array/find_missing_number/test_case: -------------------------------------------------------------------------------- 1 | 4,8,1,3,7 7,4,3,1 8 2 | 12,10,15,23,11,30 15,12,23,11,30 10 3 | 5,5,5,5,5,5 5,5,5,5,5 5 4 | 9,8,7,6,5,4,3,2,1,0 1,2,3,4,5,6,7,8,9 0 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/array/mimum_sum_abs_diff/test_case: -------------------------------------------------------------------------------- 1 | 3,2,1 1,2,3 0 2 | 4,1,8,7 2,3,6,5 6 3 | 1,1,1,1 1,1,1,1 0 4 | 9,8,7,6 1,2,3,4 20 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/array/noble_integers_in_array/test_case: -------------------------------------------------------------------------------- 1 | 7,3,16,10 3 2 | -1,-9,-2,-78,0 0 3 | 5,6,8,9,10,11 5 4 | 1,2,3,4,5 -1 5 | 0,0,0,0,0,0 0 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/array/sum_of_distinct_in_array/test_case: -------------------------------------------------------------------------------- 1 | 12,10,9,45,2,10,10,45,10 78 2 | 1,10,9,4,2,10,10,45,4 71 3 | 4,4,4,4 4 4 | 1 1 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/array/union_and_intersection/test_case: -------------------------------------------------------------------------------- 1 | 1,3,4,5,7 2,3,5,6 1,2,3,4,5,6,7 3,5 2 | 4,5,9 1,2,3,4,5,6,7,8,9,10 1,2,3,4,5,6,7,8,9,10 4,5,9 3 | 1,4,8,9 2,3,6,7,13 1,2,3,4,6,7,8,9,13 -1 4 | 1 1 1 1 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/coin_change/test_case: -------------------------------------------------------------------------------- 1 | 5 1,2,3 5 2 | 6 2,3 2 3 | 5 2,3 1 4 | 4 2,3,1 4 5 | 10 1,5,2,3 20 6 | 20 1,5,2,3,7,12,15 153 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/coin_change_min_coins/test_case: -------------------------------------------------------------------------------- 1 | 8 3,1,2 3 2 | 13 7,2,3,6 2 3 | 11 9,6,5,1 2 4 | 110 9,6,5,1 13 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/count_binary_without_consecutive_ones/test_case: -------------------------------------------------------------------------------- 1 | 3 5 2 | 12 377 3 | 40 267914296 4 | 29 1346269 5 | 16 2584 6 | 1 2 7 | 100 1445263496 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/count_ways_n_stairs/test_case: -------------------------------------------------------------------------------- 1 | 5 5 16 2 | 19 3 66012 3 | 99 3 1087163732 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/egg_dropping_problem/test_case: -------------------------------------------------------------------------------- 1 | 6 2 3 2 | 10 4 4 3 | 15 3 5 4 | 36 2 8 5 | 100 2 14 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/fibonacci_number/test_case: -------------------------------------------------------------------------------- 1 | 6 8 2 | 22 17711 3 | 42 267914296 4 | 37 24157817 5 | 0 0 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/largest_subsquare_xo/test_case: -------------------------------------------------------------------------------- 1 | XOXXX,XOXOX,XXXXX,OXOXO,XOXXX 3 2 | XOXXXX,XOXXOX,XXXOOX,OXXXXX,XXXOXO,OOXOOO 4 3 | XX,XX 2 4 | OX,XX 1 5 | XOXXX,XXXXX,XXOXO,XXXXX,XXXOO 3 6 | XXXX,X00X,X00X,XXXX 4 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/levenshtein/test_case: -------------------------------------------------------------------------------- 1 | Holmes Home 2 2 | add s,add l 3 | Querry Querty 1 4 | modify t to r 5 | kitten sitting 3 6 | delete g,modify i to e,modify s to k 7 | Saturday Sunday 3 8 | modify n to r,add t,add a 9 | Gambol Gumbo 2 10 | add l,modify u to a 11 | Pinnacle Pineapple 3 12 | modify p to c,delete p,modify e to n -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/longest_bitonic_subsequence/test_case: -------------------------------------------------------------------------------- 1 | 2,-1,4,3,5,-1,3,2 5 2 | 0,8,4,12,2,10,6,14,1,9,5,13,3,11,7,15 7 3 | 9,9,9,9 1 4 | 9,8,7,6,5,4,3,2,1 9 5 | 1,2,3,4,5,6,7,8,9 9 6 | 1 1 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/longest_common_subsequence/test_case: -------------------------------------------------------------------------------- 1 | aerodrone airpod 4 arod 2 | aerodrone dronestrike 5 drone 3 | nematode_knowledge empty_bottle 7 emt_ole 4 | acbcf abcdaf 4 abcf 5 | gxtxayb aggrtab 4 gtab 6 | airpodairpodairpod aerodroneaerodroneaerodrone 12 arodarodarod -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/longest_common_substring/test_case: -------------------------------------------------------------------------------- 1 | strikedrone dronestrike 6 strike 2 | geeksforgeeks geeksquiz 5 geeks 3 | interview experience 2 er 4 | python java 0 5 | abcdaf zbcdf 3 bcd 6 | microsoft software 4 soft -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/longest_increasing_subsequence/test_case: -------------------------------------------------------------------------------- 1 | 3,4,-1,0,6,2,3 4 2 | 15,27,14,38,26,55,46,65,85 6 3 | 10,22,9,33,21,50,41,60,80 6 4 | 9,8,7,6,5,4,3,2,1 1 5 | 10,22,9,33,50,60,41,21,25,80,45,62,69,87,78,84 9 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/longest_palindromic_subsequence/test_case: -------------------------------------------------------------------------------- 1 | BBABCBCAB 7 2 | BCBBCBCAB 7 3 | AGBDBA 5 4 | AGBBA 4 5 | GEEKSFORGEEKS 5 6 | ALFALFA 5 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/longest_palindromic_substring/test_case: -------------------------------------------------------------------------------- 1 | forgeeksskeegfor geeksskeeg 2 | abaab baab 3 | abcbabcbabcab abcbabcba 4 | abababa abababa 5 | bananas anana 6 | abra a -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/matrix_multiplication/test_case: -------------------------------------------------------------------------------- 1 | 2,5 5,8 8,4 4,10 224 2 | 2,3 3,6 6,4 4,5 124 3 | 10,20 20,30 30,40 40,30 30000 4 | 40,20 20,30 30,10 10,30 26000 5 | 1,2 2,3 3,4 18 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/maximum_sum_increasing_subsequence/test_case: -------------------------------------------------------------------------------- 1 | 1,101,2,3,100,4,5 106 2 | 4,6,1,3,8,4,6 18 3 | 1,1,1,1,1 1 4 | 9,8,7,6,5,4 9 5 | 1,2,3,4,5,6 21 6 | 0 0 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/maximum_sum_non_adjacent/test_case: -------------------------------------------------------------------------------- 1 | 5,5,10,100,10,5 110 2 | 1,2,3,4,5,6,7,8,9,10 30 3 | 5,5,10,100,10,5,6,7,200 311 4 | 100,-9,8,-7,16,0,-40,0,2,11 135 5 | -3,-6,-1,-10 0 6 | 10,-30,20,-20,30,-10,0 60 7 | 1,2,3,4,5,6,5,4,3,2,1 18 8 | -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/maximum_sum_rectangular_sub_matrix/test_case: -------------------------------------------------------------------------------- 1 | 2:1:-3:-4:-5,0:6:3:4:1,2:-2:-1:4:-5,-3:3:1:0:3 18,1,3,1,3 2 | 1:2:-1:-4:-20,-8:-3:4:2:1,3:8:10:1:3,-4:-1:1:7:-6 29,1,3,1,3 3 | 17 17,0,0,0,0 4 | -1:-2:-3:-4:-5,1:-2:-3:-4:5 5,1,1,4,4 5 | 1:2:-1:-4:-20,-8:-5:4:2:1,4:7:8:2:3,1:-3:10:4:6 42,2,3,0,4 6 | 0:0:0,0:0:0,0:0:-1 0,0,0,0,0 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/min_cost_path/test_case: -------------------------------------------------------------------------------- 1 | 1,2,3 4,8,2 1,5,3 2,2 8 2 | 1,2,1,3 9,6,4,5 7,8,1,2 1,4,1,4 2,1 15 3 | 1,3,5,8 4,2,1,7 4,3,2,3 0,2 9 4 | 1,1,1,1 2,3,4,5 1,2 6 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/min_jumps_to_end/test_case: -------------------------------------------------------------------------------- 1 | 1,3,6,3,2,3,6,8,9,5 4 2 | 1,2,2,4,5,4 3 3 | 2,3,1,1,4 2 4 | 1,1,1,1,1,1,1 6 5 | 1,0,1 2147483647 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/optimal_bst/test_case: -------------------------------------------------------------------------------- 1 | 10,12,16,21 4,2,6,3 26 2 | 10,12,20 34,8,50 142 3 | 4,10,12,20 14,10,2,30 96 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/optimal_strategy_game_picks/test_case: -------------------------------------------------------------------------------- 1 | 1,4,12,8,13,9,14,7 40 2 | 6,2,7,3,10,4,12,5,14,6 49 3 | 2,2,2,2,2,2 6 4 | 20,30,2,2,2,10 42 5 | 3,9,1,2 11 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/palindrome_partitioning/test_case: -------------------------------------------------------------------------------- 1 | aabcbd 2 2 | ababbbabbababa 3 3 | aaaaabaaaaaa 1 4 | aaaaaaaaaaa 0 5 | abaaabaabaa 1 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/rod_cutting/test_case: -------------------------------------------------------------------------------- 1 | 5 13 1,1 2,5 3,8 4,9 5,10 6,17 7,17 8,20 9,24 10,30 2 | 17 48 1,1 2,5 3,8 4,9 5,10 6,17 7,17 8,20 9,24 10,30 11,1 12,5 13,8 14,9 15,10 16,17 17,17 18,20 19,24 20,30 3 | 5 12 1,2 2,5 3,7 4,8 4 | 8 22 1,1 2,5 3,8 4,9 5,10 6,17 7,17 8,20 5 | 7 21 1,3 2,5 3,8 4,9 5,10 6,17 7,17 8,20 6 | -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/subset_sum/test_case: -------------------------------------------------------------------------------- 1 | 22 2,3,7,9,10 true 2 | 13 10,8,7,2,9 false 3 | 11 7,8,2,3,10 true 4 | 13 3,34,4,12,5,2 false 5 | 34 3,34,4,12,5,2 true -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/text_justification/test_case_1: -------------------------------------------------------------------------------- 1 | Geeks,for,Geeks,presents,word,wrap,problem 15 2 | Geeks for Geeks 3 | presents word 4 | wrap problem -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/text_justification/test_case_2: -------------------------------------------------------------------------------- 1 | This,is,an,example,of,text,justification. 16 2 | This is an 3 | example of text 4 | justification. -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/text_justification/test_case_3: -------------------------------------------------------------------------------- 1 | Tushar,Roy,Likes,To,Code 10 2 | Tushar 3 | Roy Likes 4 | To Code -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/text_justification/test_case_4: -------------------------------------------------------------------------------- 1 | Scaffeinate,will,crack,the,code,for,sure 12 2 | Scaffeinate 3 | will crack 4 | the code 5 | for sure -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/text_justification/test_case_5: -------------------------------------------------------------------------------- 1 | Five,Four,Nine,Cube,Time,Sand 4 2 | Five 3 | Four 4 | Nine 5 | Cube 6 | Time 7 | Sand -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/text_justification/test_case_6: -------------------------------------------------------------------------------- 1 | Five,Four,Nine,Cube,Time,Sand 29 2 | Five Four Nine Cube Time Sand -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/total_number_of_bst_nkeys/test_case: -------------------------------------------------------------------------------- 1 | 2 2 2 | 5 42 3 | 7 429 4 | 0 1 5 | 20 6564120420 6 | 30 3814986502092304 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/total_ways_matrix/test_case: -------------------------------------------------------------------------------- 1 | 4 4 20 2 | 3 3 6 3 | 9 7 3003 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/weighted_job_scheduling/test_case: -------------------------------------------------------------------------------- 1 | 1:5:2,3:7:1,6:9:3,6:8:4,2:5:6,8:10:5 15 2:5:6,6:8:4,8:10:5 2 | 1:3:5,2:5:6,4:6:5,6:7:4,5:8:11,7:9:2 17 2:5:6,5:8:11 3 | 3:10:20,1:2:50,6:19:100,2:100:200 250 1:2:50,2:100:200 4 | 1:100:1,2:50:3,3:50:4,4:50:5 5 4:50:5 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/zero_one_knapsack/test_case_1: -------------------------------------------------------------------------------- 1 | 8 2 | 4,5,3,1 3 | 5,7,4,1 4 | 11 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/zero_one_knapsack/test_case_2: -------------------------------------------------------------------------------- 1 | 190 2 | 56,59,80,64,75,17 3 | 50,50,64,46,50,5 4 | 150 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/zero_one_knapsack/test_case_3: -------------------------------------------------------------------------------- 1 | 25 2 | 1,3,4,5,1,2,6,8,1,3,2,15 3 | 1,4,5,7,2,9,15,30,10,14,15,7 4 | 97 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/dp/zero_one_knapsack/test_case_4: -------------------------------------------------------------------------------- 1 | 6404180 2 | 382745,799601,909247,729069,467902,44328,34610,698150,823460,903959,853665,551830,610856,670702,488960,951111,323046,446298,931161,31385,496951,264724,224916,169684 3 | 825594,1677009,1676628,1523970,943972,97426,69666,1296457,1679693,1902996,1844992,1049289,1252836,1319836,953277,2067538,675367,853655,1826027,65731,901489,577243,466257,369261 4 | 13549094 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/graph/all_pairs_shortest_path/test_case_1: -------------------------------------------------------------------------------- 1 | vertex 0 2 | vertex 1 3 | vertex 2 4 | vertex 3 5 | edge 0 1 3 6 | edge 0 3 15 7 | edge 0 2 6 8 | edge 1 2 -2 9 | edge 2 3 2 10 | edge 3 0 1 11 | shortestDistance 0 2 1 12 | shortestDistance 3 2 2 13 | shortestDistance 1 2 -2 14 | shortestDistance 0 3 3 15 | shortestDistance 3 3 0 16 | shortestDistance 3 4 infinity 17 | shortestPath 0 2 2,1,0 18 | shortestPath 3 2 2,1,0,3 19 | shortestPath 3 4 empty -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/graph/all_pairs_shortest_path/test_case_2: -------------------------------------------------------------------------------- 1 | vertex a 2 | vertex b 3 | vertex c 4 | vertex d 5 | vertex e 6 | vertex f 7 | vertex g 8 | vertex h 9 | vertex i 10 | edge a b 7 11 | edge b d -1 12 | edge b c 2 13 | edge d c 3 14 | edge c a 1 15 | edge c d 4 16 | edge c f -4 17 | edge e c 2 18 | edge g h 8 19 | edge g i 10 20 | edge h i 2 21 | edge i g -6 22 | shortestDistance a f 5 23 | shortestDistance f e infinity 24 | shortestDistance e d 6 25 | shortestDistance b g infinity 26 | shortestDistance g i 10 27 | shortestDistance h h 0 28 | shortestPath a f f,c,b,a 29 | shortestPath f e empty 30 | shortestPath e d d,c,e 31 | shortestPath b g empty 32 | shortestPath g i i,g 33 | shortestPath h h h -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/graph/all_pairs_shortest_path/test_case_3: -------------------------------------------------------------------------------- 1 | vertex a 2 | vertex b 3 | vertex c 4 | vertex d 5 | vertex e 6 | edge a b 1 7 | edge b c 2 8 | edge b d -4 9 | edge d e 6 10 | edge e b -7 11 | shortestDistance a b -infinity 12 | shortestDistance b b -infinity 13 | shortestDistance d b -infinity 14 | shortestDistance c a -infinity 15 | shortestPath a b negative_cycle 16 | shortestPath b b negative_cycle 17 | shortestPath d b negative_cycle 18 | shortestPath c a negative_cycle -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/graph/connected_components/test_case_1: -------------------------------------------------------------------------------- 1 | vertex 1 2 | vertex 2 3 | vertex 3 4 | vertex 4 5 | vertex 5 6 | vertex 6 7 | vertex 7 8 | vertex 8 9 | vertex 9 10 | vertex 10 11 | edge 1 2 12 | edge 3 9 13 | edge 9 4 14 | edge 4 5 15 | edge 6 8 16 | sameComponent 1 5 false 17 | sameComponent 2 1 true 18 | sameComponent 3 5 true 19 | sameComponent 7 10 false 20 | sameComponent 6 8 true 21 | sameComponent 4 4 true 22 | -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/graph/connected_components/test_case_2: -------------------------------------------------------------------------------- 1 | vertex 1 2 | vertex 2 3 | vertex 3 4 | vertex 4 5 | vertex 5 6 | vertex 6 7 | vertex 7 8 | vertex 8 9 | vertex 9 10 | vertex 10 11 | edge 1 2 12 | edge 1 3 13 | edge 4 5 14 | edge 7 5 15 | edge 6 8 16 | edge 8 7 17 | edge 6 1 18 | edge 9 10 19 | edge 10 4 20 | sameComponent 1 10 true 21 | sameComponent 9 5 true 22 | sameComponent 6 4 true 23 | sameComponent 5 6 true 24 | sameComponent 5 5 true -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/graph/connected_components/test_case_3: -------------------------------------------------------------------------------- 1 | vertex 1 2 | vertex 2 3 | vertex 3 4 | vertex 4 5 | vertex 5 6 | vertex 6 7 | vertex 7 8 | vertex 8 9 | vertex 9 10 | vertex 10 11 | sameComponent 1 5 false 12 | sameComponent 2 1 false 13 | sameComponent 3 5 false 14 | sameComponent 7 10 false 15 | sameComponent 6 8 false 16 | sameComponent 1 10 false 17 | sameComponent 9 5 false 18 | sameComponent 6 4 false 19 | sameComponent 5 6 false 20 | sameComponent 5 5 true -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/graph/detect_cycle/test_case_1: -------------------------------------------------------------------------------- 1 | vertex a 2 | vertex b 3 | vertex c 4 | vertex d 5 | vertex e 6 | vertex f 7 | edge a f 8 | edge a b 9 | edge b e 10 | edge e d 11 | edge d c 12 | edge c b -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/graph/detect_cycle/test_case_2: -------------------------------------------------------------------------------- 1 | vertex a 2 | vertex b 3 | vertex c 4 | vertex d 5 | vertex e 6 | vertex x 7 | vertex y 8 | edge a e 9 | edge a b 10 | edge b c 11 | edge c d 12 | edge d x 13 | edge x y -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/graph/detect_cycle/test_case_3: -------------------------------------------------------------------------------- 1 | vertex a 2 | vertex b 3 | vertex c 4 | vertex d 5 | vertex e 6 | vertex f 7 | vertex g 8 | edge e f 9 | edge f g 10 | edge g e -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/graph/detect_cycle/test_case_4: -------------------------------------------------------------------------------- 1 | vertex 1 2 | vertex 2 3 | vertex 3 4 | vertex 4 5 | vertex 5 6 | vertex 6 7 | edge 1 2 8 | edge 2 3 9 | edge 1 3 10 | edge 4 1 11 | edge 6 4 12 | edge 4 5 13 | edge 6 5 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/graph/detect_cycle/test_case_5: -------------------------------------------------------------------------------- 1 | vertex 1 2 | vertex 2 3 | vertex 3 4 | vertex 4 5 | vertex 5 6 | vertex 6 7 | edge 1 2 8 | edge 4 1 9 | edge 4 5 10 | edge 5 6 11 | edge 6 4 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/graph/min_steps_knights_tour/test_case: -------------------------------------------------------------------------------- 1 | 0,0 3,4 6 3 2 | 0,0 7,7 8 6 3 | 4,5 4,5 8 0 4 | 7,0 7,7 8 5 5 | 4,4 7,0 8 3 6 | 4,4 5,5 6 4 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/graph/minimum_spanning_tree/test_case_1: -------------------------------------------------------------------------------- 1 | vertex A 2 | vertex B 3 | vertex C 4 | vertex D 5 | edge A B 1 6 | edge B C 2 7 | edge A C 3 8 | edge B D 1 9 | edge D C 1 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/graph/minimum_spanning_tree/test_case_2: -------------------------------------------------------------------------------- 1 | vertex A 2 | vertex B 3 | vertex C 4 | vertex D 5 | vertex E 6 | vertex F 7 | edge A B 3 8 | edge A D 1 9 | edge B C 1 10 | edge B D 3 11 | edge C D 1 12 | edge C E 5 13 | edge C F 4 14 | edge D E 6 15 | edge E F 2 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/graph/minimum_spanning_tree/test_case_3: -------------------------------------------------------------------------------- 1 | vertex A 2 | vertex B 3 | vertex C 4 | vertex D 5 | vertex E 6 | vertex F 7 | vertex G 8 | vertex H 9 | edge A B 2 10 | edge A C 2 11 | edge A D 1 12 | edge A E 4 13 | edge B C 2 14 | edge C D 5 15 | edge C H 3 16 | edge D E 4 17 | edge D F 6 18 | edge D G 7 19 | edge H G 3 20 | edge G F 4 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/graph/minimum_spanning_tree/test_case_4: -------------------------------------------------------------------------------- 1 | vertex A 2 | vertex B 3 | vertex C 4 | vertex D 5 | vertex E 6 | vertex F 7 | edge A B 3 8 | edge A D 1 9 | edge B C 1 10 | edge B D 3 11 | edge C D 1 12 | edge C E 5 13 | edge C F 4 14 | edge D E 6 15 | edge E F 2 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/graph/shortest_path/test_case_1: -------------------------------------------------------------------------------- 1 | vertex A 2 | vertex B 3 | vertex C 4 | vertex D 5 | vertex E 6 | vertex F 7 | edge A B 5 8 | edge B C 2 9 | edge C D 3 10 | edge A D 9 11 | edge A E 2 12 | edge E F 3 13 | edge F D 2 14 | compute A 15 | shortestPath C C,B,A 16 | shortestDistance C 7 17 | shortestPath D D,F,E,A 18 | shortestDistance D 7 19 | shortestPath E E,A 20 | shortestDistance E 2 21 | shortestPath G empty 22 | shortestDistance G infinity 23 | shortestPath A A 24 | shortestDistance A 0 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/graph/shortest_path/test_case_2: -------------------------------------------------------------------------------- 1 | vertex A 2 | vertex B 3 | vertex C 4 | vertex D 5 | vertex E 6 | vertex F 7 | vertex G 8 | vertex H 9 | edge A B 2 10 | edge B C 4 11 | edge C F 3 12 | edge A F 4 13 | edge A D 5 14 | edge D E 1 15 | edge F D 2 16 | edge G H 4 17 | compute F 18 | shortestPath E E,D,F 19 | shortestDistance E 3 20 | shortestPath B B,A,F 21 | shortestDistance B 6 22 | shortestPath G empty 23 | shortestDistance G infinity 24 | shortestPath H empty 25 | shortestDistance H infinity 26 | compute A 27 | shortestPath E E,D,A 28 | shortestDistance E 6 29 | shortestPath B B,A 30 | shortestDistance B 2 31 | shortestPath G empty 32 | shortestDistance G infinity 33 | shortestPath H empty 34 | shortestDistance H infinity -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/graph/shortest_path/test_case_3: -------------------------------------------------------------------------------- 1 | vertex 0 2 | vertex 1 3 | vertex 2 4 | vertex 3 5 | edge 0 1 1 6 | edge 1 2 3 7 | edge 2 3 2 8 | edge 3 1 -6 9 | compute 0 10 | shortestDistance 2 -infinity 11 | shortestDistance 3 -infinity 12 | shortestDistance 1 -infinity 13 | shortestPath 2 negative_cycle 14 | shortestPath 3 negative_cycle -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/graph/shortest_path/test_case_4: -------------------------------------------------------------------------------- 1 | vertex 0 2 | vertex 4 3 | vertex 1 4 | vertex 2 5 | vertex 3 6 | edge 0 4 1 7 | edge 1 2 3 8 | edge 2 3 2 9 | edge 3 1 -6 10 | compute 0 11 | shortestDistance 2 infinity 12 | shortestDistance 3 infinity 13 | shortestDistance 1 infinity 14 | shortestPath 2 empty 15 | shortestPath 3 empty 16 | shortestPath 4 4,0 17 | shortestDistance 4 1 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/graph/shortest_path_dag/test_case_1: -------------------------------------------------------------------------------- 1 | vertex A 2 | vertex B 3 | vertex C 4 | vertex D 5 | edge A B 1 6 | edge B C 3 7 | edge C D 2 8 | edge B D 2 9 | compute A 10 | shortestDistance C 4 11 | shortestDistance B 1 12 | shortestDistance D 3 13 | shortestPath D D,B,A 14 | shortestPath B B,A 15 | shortestPath C C,B,A -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/graph/shortest_path_dag/test_case_2: -------------------------------------------------------------------------------- 1 | vertex A 2 | vertex B 3 | vertex C 4 | vertex D 5 | vertex F 6 | vertex G 7 | edge A B 2 8 | edge B C 1 9 | edge C D 4 10 | edge F G 0 11 | compute A 12 | shortestDistance C 3 13 | shortestDistance D 7 14 | shortestDistance G infinity 15 | shortestDistance F infinity 16 | shortestPath D D,C,B,A 17 | shortestPath B B,A 18 | shortestPath G empty 19 | shortestPath F empty 20 | compute F 21 | shortestDistance A infinity 22 | shortestDistance G 0 23 | 24 | -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/graph/strongly_connected_components/test_case_1: -------------------------------------------------------------------------------- 1 | vertex a 2 | vertex b 3 | vertex c 4 | vertex d 5 | vertex e 6 | vertex f 7 | vertex g 8 | vertex h 9 | vertex i 10 | vertex j 11 | edge a c 12 | edge b a 13 | edge b d 14 | edge c b 15 | edge c e 16 | edge d g 17 | edge e d 18 | edge e j 19 | edge f c 20 | edge g h 21 | edge h i 22 | edge i e 23 | edge j i -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/graph/strongly_connected_components/test_case_2: -------------------------------------------------------------------------------- 1 | vertex a 2 | vertex b 3 | vertex c 4 | vertex d 5 | vertex e 6 | vertex f 7 | vertex g 8 | vertex h 9 | vertex i 10 | vertex j 11 | vertex k 12 | edge a b 13 | edge b c 14 | edge b d 15 | edge c a 16 | edge d e 17 | edge e f 18 | edge f d 19 | edge g f 20 | edge g h 21 | edge h i 22 | edge i j 23 | edge j g 24 | edge j k 25 | -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/graph/strongly_connected_components/test_case_3: -------------------------------------------------------------------------------- 1 | vertex a 2 | vertex b 3 | vertex c 4 | vertex d 5 | vertex e 6 | vertex f 7 | vertex g 8 | vertex h 9 | vertex i 10 | vertex j 11 | edge a b 12 | edge b c 13 | edge c d 14 | edge d a 15 | edge a j 16 | edge a e 17 | edge e f 18 | edge f g 19 | edge g h 20 | edge h i 21 | edge i e 22 | edge e a 23 | edge j a -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/graph/topological_sort/test_case_1: -------------------------------------------------------------------------------- 1 | vertex undershorts 2 | vertex pants 3 | vertex belt 4 | vertex shirt 5 | vertex tie 6 | vertex jacket 7 | vertex shoes 8 | vertex socks 9 | vertex watch 10 | edge undershorts pants 11 | edge undershorts shoes 12 | edge pants shoes 13 | edge pants belt 14 | edge belt jacket 15 | edge socks shoes 16 | edge shirt belt 17 | edge shirt tie 18 | edge tie jacket 19 | check belt->jacket true 20 | check shirt->belt true 21 | check pants->shoes true 22 | check socks->shoes true 23 | check undershorts->shoes true 24 | check belt->undershorts false 25 | check tie->shirt false -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/greedy/activity_selection/test_case: -------------------------------------------------------------------------------- 1 | 1:2,3:4,0:6,5:7,8:9,5:9 4 2 | 5:9,1:2,3:4,0:6,5:7,8:9 4 3 | 4:6,0:5,5:10 2 4 | 0:10,1:2,2:3,3:4,4:5,5:6,6:7,8:9,9:10 8 5 | 1:4,3:5,4:10,3:5,3:5,3:5,3:5,3:5,9:11,9:11,9:11,9:11,12:15 3 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/greedy/fractional_knapsack/test_case: -------------------------------------------------------------------------------- 1 | 20:100,40:50,10:20,30:140 65 266.25 2 | 10:50,10:40,10:60,10:70,10:80 50 300 3 | 160:10,100:20,120:30 160 38 4 | 20:100,40:50,10:20,30:140 165 310 5 | 3:10,6:20,9:30,12:40 1 3.33 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/greedy/huffman_coding/test_case: -------------------------------------------------------------------------------- 1 | aaaaabbbbbbbbbccccccccccccdddddddddddddeeeeeeeeeeeeeeeefffffffffffffffffffffffffffffffffffffffffffff 2 | abcdefghij 3 | abcabcabcabcabcabc 4 | xxxxxxxxxxxxxxxxxxxxxxxxxxxx 5 | a b c d -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/greedy/job_sequencing/test_case: -------------------------------------------------------------------------------- 1 | 1:30,4:20,1:40,1:10 60 2 | 2:100,1:19,2:27,1:25,3:15 142 3 | 1:10,2:20,3:30 60 4 | 8:20,10:29,5:10 59 5 | 1:10,1:20,1:30,1:40,1:50 50 6 | 1:30,3:40,1:70,2:100,2:80,2:75,3:75,4:60,4:90 345 7 | 1:30,2:70,10:50,2:80,3:40,2:100,2:75 270 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/linked_list/add_polynomials_linked_list/test_case_1: -------------------------------------------------------------------------------- 1 | 5x^2 + 4x^1 + 2x^0 2 | 5x^1 + 5x^0 3 | 5x^2 + 9x^1 + 7x^0 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/linked_list/add_polynomials_linked_list/test_case_2: -------------------------------------------------------------------------------- 1 | 5x^3 + 4x^2 + 2x^0 2 | 5x^1 + 5x^0 3 | 5x^3 + 4x^2 + 5x^1 + 7x^0 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/linked_list/add_polynomials_linked_list/test_case_3: -------------------------------------------------------------------------------- 1 | 7x^3 + 4x^2 + 3x^1 + 0x^0 2 | 49x^3 + 16x^2 + 0x^1 3 | 56x^3 + 20x^2 + 3x^1 + 0x^0 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/linked_list/clone_linked_list_pseudo/test_case_1: -------------------------------------------------------------------------------- 1 | insert 0->1->2->3->4->5 2 | psuedoLink 0 1 3 | psuedoLink 1 4 4 | psuedoLink 2 4 5 | psuedoLink 3 5 6 | psuedoLink 4 2 7 | psuedoLink 5 1 8 | -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/linked_list/clone_linked_list_pseudo/test_case_2: -------------------------------------------------------------------------------- 1 | insert 1->2->3->4->5 2 | psuedoLink 1 3 3 | psuedoLink 2 1 4 | psuedoLink 3 5 5 | psuedoLink 4 3 6 | psuedoLink 5 2 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/linked_list/clone_linked_list_pseudo/test_case_3: -------------------------------------------------------------------------------- 1 | insert 1->2->3->4->5 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/linked_list/clone_linked_list_pseudo/test_case_4: -------------------------------------------------------------------------------- 1 | insert 1->2->3->4->5 2 | psuedoLink 2 1 3 | psuedoLink 3 2 4 | psuedoLink 4 3 5 | psuedoLink 5 1 6 | psuedoLink 1 5 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/linked_list/merge_sorted_linked_list_reverse/test_case_1: -------------------------------------------------------------------------------- 1 | 5 10 15 40 2 | 2 3 20 3 | 40 20 15 10 5 3 2 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/linked_list/merge_sorted_linked_list_reverse/test_case_2: -------------------------------------------------------------------------------- 1 | NULL 2 | 2 3 20 3 | 20 3 2 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/linked_list/merge_sorted_linked_list_reverse/test_case_3: -------------------------------------------------------------------------------- 1 | NULL 2 | NULL 3 | NULL -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/linked_list/merge_sorted_linked_list_reverse/test_case_4: -------------------------------------------------------------------------------- 1 | 2 3 4 5 6 10 11 13 14 2 | 1 7 8 9 12 15 3 | 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/linked_list/move_all_occurances_to_end/test_case: -------------------------------------------------------------------------------- 1 | 1 2 2 4 3, 2 2 | 6 6 7 6 3 10, 6 3 | 1 2 3 4 5 6, 4 4 | 1 4 5 2 3 8 7 7 7, 7 5 | 1, 1 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/linked_list/pairwise_swap/test_case: -------------------------------------------------------------------------------- 1 | 1 2 3 4 5 6 2 | 1 2 3 4 5 6 7 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/matrix/circular_matrix/test_case: -------------------------------------------------------------------------------- 1 | 4 4 2 | 3 4 3 | 1 1 4 | 10 4 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/matrix/sparse_matrix/test_case_1: -------------------------------------------------------------------------------- 1 | 0 1 0 0 1 0 0 2 2 | 0 0 0 7 0 0 0 1 3 | 0 0 1 0 0 0 0 0 4 | 0 0 0 0 0 0 0 2 5 | 9 1 0 0 0 0 0 0 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/matrix/sparse_matrix/test_case_2: -------------------------------------------------------------------------------- 1 | 0 0 0 0 0 2 | 0 0 0 0 0 3 | 0 0 0 0 0 4 | 0 0 0 0 0 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/matrix/sparse_matrix/test_case_3: -------------------------------------------------------------------------------- 1 | 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 | 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 3 | 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 4 | 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 5 | 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6 | 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 7 | 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 8 | 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 9 | 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 10 | 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 11 | 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 12 | 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/random/cartesian_product/test_case_1: -------------------------------------------------------------------------------- 1 | green red yellow 2 | cricket hockey soccer tennis 3 | monday tuesday wednesday 4 | 0 1 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/random/cartesian_product/test_case_2: -------------------------------------------------------------------------------- 1 | a b 2 | i j 3 | x y 4 | -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/random/cartesian_product/test_case_3: -------------------------------------------------------------------------------- 1 | a -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/random/cartesian_product/test_case_4: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/scaffeinate/crack-the-code/b4a12b8c062ca89d033bc48c36ad4f43f7471012/geeks-for-geeks/input_files/random/cartesian_product/test_case_4 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/random/count_inversions/test_case_1: -------------------------------------------------------------------------------- 1 | 9 8 7 6 5 4 3 2 1 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/random/count_inversions/test_case_2: -------------------------------------------------------------------------------- 1 | 1 2 3 4 5 6 7 8 9 10 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/random/count_inversions/test_case_3: -------------------------------------------------------------------------------- 1 | 1111111 1111111 1111111 1111111 1111111 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/random/count_inversions/test_case_4: -------------------------------------------------------------------------------- 1 | 9 5 1 3 8 2 1 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/random/is_digit_frequency_less_than_digit/test_case: -------------------------------------------------------------------------------- 1 | 51241 2 | 1425243 3 | 999999999 4 | 0 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/random/longest_palindromic_substring/test_case: -------------------------------------------------------------------------------- 1 | forgeeksskeegfor geeksskeeg 2 | abaab baab 3 | abcbabcbabcab abcbabcba 4 | abababa abababa 5 | bananas anana 6 | abra a -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/random/second_smallest/test_case_1: -------------------------------------------------------------------------------- 1 | 1 2 3 4 5 6 7 8 9 10 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/random/second_smallest/test_case_2: -------------------------------------------------------------------------------- 1 | 10 9 8 7 6 5 4 3 2 1 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/random/second_smallest/test_case_3: -------------------------------------------------------------------------------- 1 | 1 3 4 5 6 7 8 9 2 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/random/second_smallest/test_case_4: -------------------------------------------------------------------------------- 1 | 2 2 2 2 2 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/sort/test_case_1: -------------------------------------------------------------------------------- 1 | 9 8 7 6 5 4 3 2 1 2 | -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/sort/test_case_2: -------------------------------------------------------------------------------- 1 | 8 17 4 6 10 9 33 45 5 99 22 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/sort/test_case_3: -------------------------------------------------------------------------------- 1 | -1000 999 -888 1000 -777 1001 -666 1002 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/string/count_substrings_first_last/test_case: -------------------------------------------------------------------------------- 1 | abcab 7 2 | aba 4 3 | abc 3 4 | ababababab 30 5 | a 1 6 | aaaaaaaaaa 55 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/check_bst_has_dead_end/test_case_1: -------------------------------------------------------------------------------- 1 | insertRoot 8 2 | insert 5 3 | insert 9 4 | insert 2 5 | insert 7 6 | insert 1 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/check_bst_has_dead_end/test_case_2: -------------------------------------------------------------------------------- 1 | insertRoot 8 2 | insert 7 3 | insert 10 4 | insert 2 5 | insert 9 6 | insert 13 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/check_bst_has_dead_end/test_case_3: -------------------------------------------------------------------------------- 1 | insertRoot 5 2 | insert 2 3 | insert 6 4 | insert 3 5 | insert 7 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/check_bst_has_dead_end/test_case_4: -------------------------------------------------------------------------------- 1 | insertRoot 3 2 | insert 2 3 | insert 4 4 | -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/check_cousins_binary_tree/test_case_1: -------------------------------------------------------------------------------- 1 | insertRoot 6 2 | insertLeft 6 3 3 | insertRight 6 5 4 | insertLeft 3 7 5 | insertRight 3 8 6 | insertLeft 5 1 7 | insertRight 5 4 8 | checkCousins 7 1 true 9 | checkCousins 3 5 false 10 | checkCousins 7 5 false 11 | checkCousins 8 1 true 12 | checkCousins 8 4 true 13 | checkCousins 7 4 true 14 | checkCousins 7 8 false 15 | checkCousins 1 4 false 16 | checkCousins 3 5 false 17 | checkCousins 7 6 false 18 | -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/check_cousins_binary_tree/test_case_2: -------------------------------------------------------------------------------- 1 | insertRoot 2 2 | insertLeft 2 7 3 | insertRight 7 6 4 | insertLeft 6 1 5 | insertRight 6 11 6 | insertRight 2 5 7 | insertRight 5 9 8 | insertLeft 9 4 9 | checkCousins 1 4 true 10 | checkCousins 9 6 true 11 | checkCousins 5 7 false 12 | checkCousins 2 5 false -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/check_sorted_subsequence_bst/test_case_1: -------------------------------------------------------------------------------- 1 | insertRoot 8 2 | insert 3 3 | insert 1 4 | insert 6 5 | insert 4 6 | insert 7 7 | insert 10 8 | insert 14 9 | insert 13 10 | checkSeq 4,6,8,14 true 11 | checkSeq 1,2,3,8 false -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/check_sorted_subsequence_bst/test_case_2: -------------------------------------------------------------------------------- 1 | insertRoot 5 2 | checkSeq 5 true 3 | checkSeq 1 false 4 | checkSeq 5,10 false -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/check_sorted_subsequence_bst/test_case_3: -------------------------------------------------------------------------------- 1 | insertRoot 1 2 | insert 2 3 | insert 3 4 | insert 4 5 | insert 5 6 | insert 6 7 | insert 7 8 | insert 8 9 | insert 9 10 | insert 10 11 | checkSeq 1,4,6,8,10 true 12 | checkSeq 10 true 13 | checkSeq 5,8,9,10,11 false 14 | checkSeq 3,6,8,9,10 true 15 | checkSeq 1,1,1,1 false 16 | checkSeq 3,8,7,5,10 false -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/convert_binary_tree_doubly_linked_list/test_case_1: -------------------------------------------------------------------------------- 1 | insertRoot 10 2 | insertLeft 10 12 3 | insertRight 10 15 4 | insertLeft 12 25 5 | insertRight 12 30 6 | insertLeft 15 36 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/convert_binary_tree_doubly_linked_list/test_case_2: -------------------------------------------------------------------------------- 1 | insertRoot 5 2 | insertLeft 5 2 3 | insertRight 5 8 4 | insertLeft 2 1 5 | insertRight 2 3 6 | insertLeft 1 0 7 | insertRight 3 4 8 | insertLeft 8 6 9 | insertRight 8 9 10 | insertRight 6 7 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/convert_binary_tree_doubly_linked_list/test_case_3: -------------------------------------------------------------------------------- 1 | insertRoot 8 2 | insertLeft 8 3 3 | insertLeft 3 1 4 | insertRight 1 6 5 | insertLeft 6 4 6 | insertRight 6 7 7 | insertRight 8 10 8 | insertRight 10 14 9 | insertLeft 14 13 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/count_half_nodes/test_case_1: -------------------------------------------------------------------------------- 1 | insertRoot 2 2 | insertLeft 2 7 3 | insertRight 7 6 4 | insertLeft 6 1 5 | insertRight 6 11 6 | insertRight 2 5 7 | insertRight 5 9 8 | insertLeft 9 4 9 | count 3 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/count_half_nodes/test_case_2: -------------------------------------------------------------------------------- 1 | insertRoot 8 2 | insertLeft 8 5 3 | insertLeft 5 3 4 | insertLeft 3 2 5 | insertLeft 2 1 6 | count 4 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/count_half_nodes/test_case_3: -------------------------------------------------------------------------------- 1 | insertRoot 5 2 | insertLeft 5 4 3 | count 1 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/count_half_nodes/test_case_4: -------------------------------------------------------------------------------- 1 | insertRoot 5 2 | insertLeft 5 3 3 | insertRight 5 6 4 | insertLeft 3 2 5 | insertRight 3 4 6 | count 0 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/deepest_node_binary_tree/test_case_1: -------------------------------------------------------------------------------- 1 | insertRoot 2 2 | insertLeft 2 1 3 | insertLeft 1 5 4 | insertRight 1 6 5 | insertLeft 5 8 6 | insertRight 5 3 7 | insertRight 6 9 8 | insertLeft 9 11 9 | insertRight 9 10 10 | insertRight 10 12 11 | insertRight 4 2 12 | insertLeft 4 0 13 | insertRight 4 7 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/deepest_node_binary_tree/test_case_2: -------------------------------------------------------------------------------- 1 | insertRoot 1 2 | insertLeft 1 2 3 | insertLeft 2 4 4 | insertRight 1 3 5 | insertLeft 3 5 6 | insertRight 3 6 7 | insertRight 5 7 8 | insertLeft 7 9 9 | insertRight 6 8 10 | insertRight 8 10 11 | -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/deepest_node_binary_tree/test_case_3: -------------------------------------------------------------------------------- 1 | insertRoot 5 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/deepest_node_binary_tree/test_case_4: -------------------------------------------------------------------------------- 1 | insertRoot 2 2 | insertLeft 2 1 3 | insertRight 2 4 4 | insertLeft 1 15 5 | insertRight 1 6 6 | insertLeft 4 12 7 | insertRight 4 7 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/full_nodes/test_case_1: -------------------------------------------------------------------------------- 1 | insertRoot 10 2 | insertLeft 10 8 3 | insertRight 10 2 4 | insertLeft 8 3 5 | insertRight 8 5 6 | insertLeft 2 7 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/full_nodes/test_case_2: -------------------------------------------------------------------------------- 1 | insertRoot 1 2 | insertLeft 1 2 3 | insertRight 1 3 4 | insertLeft 3 4 5 | insertRight 3 6 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/full_nodes/test_case_3: -------------------------------------------------------------------------------- 1 | insertRoot 1 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/full_nodes/test_case_4: -------------------------------------------------------------------------------- 1 | insertRoot 1 2 | insertLeft 1 2 3 | insertLeft 2 3 4 | insertLeft 3 4 5 | insertLeft 4 6 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/largest_bst/test_case_1: -------------------------------------------------------------------------------- 1 | insertRoot 25 2 | insertLeft 25 18 3 | insertRight 25 50 4 | insertLeft 18 19 5 | insertRight 18 20 6 | insertRight 19 15 7 | insertLeft 20 18 8 | insertRight 20 25 9 | insertLeft 50 35 10 | insertRight 50 60 11 | insertLeft 35 20 12 | insertRight 35 40 13 | insertRight 20 25 14 | insertLeft 60 55 15 | insertRight 60 70 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/largest_bst/test_case_2: -------------------------------------------------------------------------------- 1 | insertRoot 8 2 | insertLeft 8 2 3 | insertRight 8 10 4 | insertLeft 2 1 5 | insertRight 2 5 6 | insertLeft 5 3 7 | insertRight 5 6 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/lca/test_case_1: -------------------------------------------------------------------------------- 1 | insertRoot 4 2 | insertLeft 4 2 3 | insertRight 4 7 4 | insertLeft 2 1 5 | insertRight 2 3 6 | insertLeft 7 6 7 | lca 1 7 4 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/lca/test_case_2: -------------------------------------------------------------------------------- 1 | insertRoot 1 2 | insertLeft 1 2 3 | insertRight 1 3 4 | insertLeft 2 4 5 | insertRight 2 5 6 | insertLeft 3 6 7 | inserRight 3 7 8 | lca 4 5 2 9 | lca 4 6 1 10 | lca 3 4 1 11 | lca 2 4 2 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/lca/test_case_3: -------------------------------------------------------------------------------- 1 | insertRoot 3 2 | insertLeft 3 5 3 | insertRight 3 1 4 | insertLeft 5 6 5 | insertRight 5 2 6 | insertLeft 2 7 7 | insertRight 2 4 8 | insertLeft 1 0 9 | insertRight 1 8 10 | lca 5 1 3 11 | lca 5 4 5 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/lca/test_case_4: -------------------------------------------------------------------------------- 1 | insertRoot 20 2 | insertLeft 20 8 3 | insertRight 20 22 4 | insertLeft 8 4 5 | insertRight 8 12 6 | insertLeft 12 10 7 | insertRight 12 14 8 | lca 10 14 12 9 | lca 8 14 8 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/max_diff_node_ancestor/test_case_1: -------------------------------------------------------------------------------- 1 | insertRoot 8 2 | insertLeft 8 3 3 | insertLeft 3 1 4 | insertRight 3 6 5 | insertLeft 6 4 6 | insertRight 6 7 7 | insertRight 8 10 8 | insertRight 10 14 9 | insertLeft 14 13 10 | maxDiff 7 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/max_diff_node_ancestor/test_case_2: -------------------------------------------------------------------------------- 1 | insertRoot 1 2 | insertLeft 1 3 3 | insertLeft 3 11 4 | insertLeft 11 4 5 | insertRight 11 2 6 | insertRight 1 5 7 | insertRight 5 2 8 | insertLeft 5 7 9 | insertRight 7 9 10 | maxDiff 9 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/max_diff_node_ancestor/test_case_3: -------------------------------------------------------------------------------- 1 | insertRoot 1 2 | insertLeft 1 2 3 | insertLeft 2 3 4 | insertLeft 3 4 5 | insertLeft 4 5 6 | insertLeft 5 6 7 | insertLeft 6 7 8 | maxDiff -1 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/max_diff_node_ancestor/test_case_4: -------------------------------------------------------------------------------- 1 | insertRoot 0 2 | insertLeft 0 -5 3 | insertRight 0 5 4 | insertLeft -5 10 5 | insertLeft 10 20 6 | insertRight 10 -20 7 | insertRight 5 -10 8 | insertLeft -10 -30 9 | insertRight -10 30 10 | maxDiff 35 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/non_matching_leaves/test_case_1.1: -------------------------------------------------------------------------------- 1 | insertRoot 5 2 | insertLeft 5 2 3 | insertRight 5 7 4 | insertLeft 2 10 5 | insertRight 2 11 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/non_matching_leaves/test_case_1.2: -------------------------------------------------------------------------------- 1 | insertRoot 6 2 | insertLeft 6 10 3 | insertRight 6 15 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/non_matching_leaves/test_case_2.1: -------------------------------------------------------------------------------- 1 | insertRoot 5 2 | insertLeft 5 2 3 | insertRight 5 8 4 | insertLeft 2 10 5 | insertRight 2 11 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/non_matching_leaves/test_case_2.2: -------------------------------------------------------------------------------- 1 | insertRoot 6 2 | insertLeft 6 9 3 | insertRight 6 8 4 | insertLeft 9 10 5 | insertRight 9 11 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/non_matching_leaves/test_case_3.1: -------------------------------------------------------------------------------- 1 | insertRoot 2 2 | insertLeft 2 3 3 | insertRight 3 4 4 | insertLeft 4 5 5 | insertLeft 5 7 6 | insertLeft 7 8 7 | insertLeft 8 9 8 | insertLeft 9 10 9 | insertRight 2 14 -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/non_matching_leaves/test_case_3.2: -------------------------------------------------------------------------------- 1 | insertRoot 6 2 | insertRight 6 7 3 | insertLeft 7 10 4 | insertRight 7 11 5 | -------------------------------------------------------------------------------- /geeks-for-geeks/input_files/tree/smallest_sub_tree_deepest_nodes/test_case: -------------------------------------------------------------------------------- 1 | 1,1:2,1:3,2:4,4:5,4:6,5:7,6:8|4,5,6,7,8 2 | 1,1:2,1:3,1:4,2:5,2:6,2:7,5:8,6:9,7:10,8:11,8:12,9:13,9:14,9:15,9:16,10:17,10:18,10:19,13:20,14:21,14:22,14:23,19:24,4:25,4:26,4:27,26:28,28:29|2,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24 3 | 1,1:2,1:3,1:4,2:5,2:6,2:7,5:8,6:9,7:10,8:11,8:12,9:13,9:14,9:15,9:16,10:17,10:18,10:19,13:20,14:21,14:22,14:23,4:25,4:26,4:27,26:28,28:29|9,13,14,15,16,20,21,22,23 4 | 1,1:2,1:3,1:4,2:5,2:6,4:7,5:8,6:9,6:10|2,5,6,8,9,10 5 | 1,1:2,2:3,3:4,4:5,5:6,6:7,7:8|8 6 | 1,1:2,1:3,1:4,2:5,2:6,2:7,3:8,3:9,3:10,4:11,4:12,4:13,5:14,5:15,5:16,6:17,6:18,6:19,7:20,7:21,7:22,8:23,8:24,8:25,9:26,9:27,9:28,10:29,10:30,10:31,11:32,11:33,11:34,12:35,12:36,12:37,13:38,13:39,13:40|1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40 -------------------------------------------------------------------------------- /geeks-for-geeks/src/array/CountPairsSortedLessThanSum.java: -------------------------------------------------------------------------------- 1 | package array; 2 | 3 | /** 4 | * Question: http://www.geeksforgeeks.org/count-pairs-array-whose-sum-less-x/ 5 | * 6 | * @author Sudharsanan Muralidharan 7 | */ 8 | public class CountPairsSortedLessThanSum { 9 | 10 | public int countPairs(int[] arr, int result) { 11 | int count = 0; 12 | for (int i = 0; i < arr.length && arr[i] < result; i++) { 13 | int j = i + 1; 14 | while (j < arr.length && (arr[i] + arr[j]) < result) { 15 | count++; 16 | j++; 17 | } 18 | } 19 | return count; 20 | } 21 | 22 | public int countPairs2(int[] arr, int result) { 23 | int count = 0, i = 0, j = arr.length - 1; 24 | while (i < j) { 25 | if (arr[i] + arr[j] < result) { 26 | count += (j - i); 27 | i++; 28 | } else { 29 | j--; 30 | } 31 | } 32 | return count; 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/array/ElementOccursOnce.java: -------------------------------------------------------------------------------- 1 | package array; 2 | 3 | /** 4 | * Question: http://www.geeksforgeeks.org/?p=135094 5 | * 6 | * @author Sudharsanan Muralidharan 7 | */ 8 | public class ElementOccursOnce { 9 | public static int findElement(int[] arr) { 10 | for (int i = 0; i < arr.length - 1; i += 2) { 11 | if (arr[i] != arr[i + 1]) { 12 | return arr[i]; 13 | } 14 | } 15 | return arr[arr.length - 1]; 16 | } 17 | 18 | public static int findElement2(int[] arr) { 19 | return findElement2(arr, 0, arr.length); 20 | } 21 | 22 | private static int findElement2(int[] arr, int start, int end) { 23 | if (start == end) { 24 | return arr[start]; 25 | } 26 | 27 | int middle = (start + end) / 2; 28 | if (middle != arr.length - 1 && arr[middle] == arr[middle + 1]) { 29 | return findElement2(arr, ((middle % 2 != 0) ? start : middle + 1), ((middle % 2 != 0) ? middle : end)); 30 | } else if (middle != 0 && arr[middle] == arr[middle - 1]) { 31 | return findElement2(arr, ((middle % 2 != 0) ? middle + 1 : start), ((middle % 2 != 0) ? end : middle)); 32 | } else { 33 | return arr[middle]; 34 | } 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/array/EqualSumSubArrays.java: -------------------------------------------------------------------------------- 1 | package array; 2 | 3 | import java.util.Arrays; 4 | import java.util.Scanner; 5 | 6 | /** 7 | * Question: http://www.geeksforgeeks.org/split-array-two-equal-sum-subarrays/ 8 | * 9 | * @author Sudharsanan Muralidharan 10 | */ 11 | public class EqualSumSubArrays { 12 | public Result subArrays(int[] arr) { 13 | Result result = new Result(); 14 | 15 | int sum = 0, leftSum = 0, index = -1; 16 | for (int i = 0; i < arr.length; i++) { 17 | sum += arr[i]; 18 | } 19 | 20 | Scanner s; 21 | 22 | for (int i = 0; i < arr.length; i++) { 23 | leftSum += arr[i]; 24 | sum -= arr[i]; 25 | if (leftSum == sum) { 26 | index = i; 27 | break; 28 | } 29 | } 30 | 31 | if (index != -1) { 32 | result.leftArr = Arrays.copyOfRange(arr, 0, index + 1); 33 | result.rightArr = Arrays.copyOfRange(arr, index + 1, arr.length); 34 | } else { 35 | result.leftArr = new int[]{}; 36 | result.rightArr = new int[]{}; 37 | } 38 | 39 | return result; 40 | } 41 | 42 | class Result { 43 | int[] leftArr; 44 | int[] rightArr; 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/array/FindAllPairsABCD.java: -------------------------------------------------------------------------------- 1 | package array; 2 | 3 | import java.util.ArrayList; 4 | import java.util.HashMap; 5 | import java.util.List; 6 | import java.util.Map; 7 | import java.util.Map.Entry; 8 | 9 | /** 10 | * Question: http://www.geeksforgeeks.org/find-pairs-ab-cd-array-satisfy-ab-cd/ 11 | * 12 | * @author Sudharsanan Muralidharan 13 | */ 14 | public class FindAllPairsABCD { 15 | 16 | public Map> findAllPairs(int[] arr) { 17 | Map> resultMap = new HashMap>(); 18 | Map> productMap = new HashMap>(); 19 | 20 | for (int i = 0; i < arr.length; i++) { 21 | for (int j = i + 1; j < arr.length; j++) { 22 | int product = arr[i] * arr[j]; 23 | List tupleList = new ArrayList(); 24 | if (productMap.containsKey(product)) { 25 | tupleList = productMap.get(product); 26 | } 27 | 28 | tupleList.add(new Integer[]{arr[i], arr[j]}); 29 | productMap.putIfAbsent(product, tupleList); 30 | } 31 | } 32 | 33 | for (Entry> entry : productMap.entrySet()) { 34 | if (entry.getValue().size() > 1) { 35 | resultMap.put(entry.getKey(), entry.getValue()); 36 | } 37 | } 38 | 39 | return resultMap; 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/array/FindCommonThreeSortedArrays.java: -------------------------------------------------------------------------------- 1 | package array; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | /** 7 | * Question: http://www.geeksforgeeks.org/find-common-elements-three-sorted-arrays/ 8 | */ 9 | public class FindCommonThreeSortedArrays { 10 | public List findCommon(Integer[] arr, Integer[] arr2, Integer[] arr3) { 11 | List result = new ArrayList<>(); 12 | int i = 0, j = 0, k = 0; 13 | while (i < arr.length && j < arr2.length && k < arr3.length) { 14 | if (arr[i] == arr2[j] && arr2[j] == arr3[k]) { 15 | result.add(arr[i]); 16 | i++; 17 | j++; 18 | k++; 19 | } else if (arr[i] < arr2[j]) { 20 | if (arr[i] < arr3[k]) { 21 | i++; 22 | } else { 23 | k++; 24 | } 25 | } else { 26 | if (arr2[j] < arr3[k]) { 27 | j++; 28 | } else { 29 | k++; 30 | } 31 | } 32 | } 33 | return result; 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/array/FindMissingNumber.java: -------------------------------------------------------------------------------- 1 | package array; 2 | 3 | /** 4 | * Question: http://www.geeksforgeeks.org/?p=146802 5 | * 6 | * @author Sudharsanan Muralidharan 7 | */ 8 | public class FindMissingNumber { 9 | public int findNumber(int[] arr, int[] copy) { 10 | int sum = 0; 11 | for (int num : arr) { 12 | sum += num; 13 | } 14 | 15 | for (int num : copy) { 16 | sum -= num; 17 | } 18 | 19 | return sum; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/array/MinimumSumAbsDiffTwoArrays.java: -------------------------------------------------------------------------------- 1 | package array; 2 | 3 | import java.util.Arrays; 4 | 5 | /** 6 | * Question: http://www.geeksforgeeks.org/minimum-sum-absolute-difference-pairs-two-arrays/ 7 | * 8 | * @author Sudharsanan Muralidharan 9 | */ 10 | public class MinimumSumAbsDiffTwoArrays { 11 | 12 | public int getMinimumSum(int[] a, int[] b) { 13 | int sum = 0; 14 | Arrays.sort(a); 15 | Arrays.sort(b); 16 | 17 | for (int i = 0; i < a.length; i++) { 18 | sum += Math.abs(b[i] - a[i]); 19 | } 20 | return sum; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/array/NobleIntegersInArray.java: -------------------------------------------------------------------------------- 1 | package array; 2 | 3 | import java.util.Arrays; 4 | 5 | /** 6 | * Question: 7 | * http://www.geeksforgeeks.org/noble-integers-in-an-array-count-of-greater-elements-is-equal-to-value/ 8 | * 9 | * @author Sudharsanan Muralidharan 10 | */ 11 | public class NobleIntegersInArray { 12 | 13 | public int nobleInteger(int[] arr) { 14 | Arrays.sort(arr); 15 | for (int i = 0; i < arr.length; i++) { 16 | if ((arr.length - 1 - i) == arr[i]) { 17 | return arr[i]; 18 | } 19 | } 20 | 21 | return -1; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/array/SumOfDistinctInArray.java: -------------------------------------------------------------------------------- 1 | package array; 2 | 3 | import java.util.Arrays; 4 | import java.util.HashSet; 5 | import java.util.Set; 6 | 7 | /** 8 | * Question: http://www.geeksforgeeks.org/find-sum-non-repeating-distinct-elements-array/ 9 | * 10 | * @author Sudharsanan Muralidharan 11 | */ 12 | public class SumOfDistinctInArray { 13 | 14 | public int getSum(int[] arr) { 15 | int sum = 0; 16 | Set numbersSet = new HashSet(); 17 | 18 | for (int i = 0; i < arr.length; i++) { 19 | if (!numbersSet.contains(arr[i])) { 20 | numbersSet.add(arr[i]); 21 | sum += arr[i]; 22 | } 23 | } 24 | 25 | return sum; 26 | } 27 | 28 | public int getSum2(int[] arr) { 29 | int i = 0, sum = 0; 30 | Arrays.sort(arr); 31 | 32 | for (i = 0; i < arr.length - 1; i++) { 33 | if (arr[i] != arr[i + 1]) { 34 | sum += arr[i]; 35 | } 36 | } 37 | 38 | return (sum += arr[i]); 39 | } 40 | 41 | public int getSum3(int[] arr) { 42 | int i = 0, sum = 0; 43 | 44 | for (i = 0; i < arr.length; i++) { 45 | if (arr[i] != 0) { 46 | for (int j = i + 1; j < arr.length; j++) { 47 | if (arr[i] == arr[j]) { 48 | arr[j] = 0; 49 | } 50 | } 51 | sum += arr[i]; 52 | } 53 | } 54 | 55 | return sum; 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/dp/CountBinaryWithoutConsecutiveOnes.java: -------------------------------------------------------------------------------- 1 | package dp; 2 | 3 | /** 4 | * Question: http://www.geeksforgeeks.org/count-number-binary-strings-without-consecutive-1s/ 5 | */ 6 | public class CountBinaryWithoutConsecutiveOnes { 7 | public int count(int N) { 8 | int[][] memo = new int[N + 1][2]; 9 | for (int i = 0; i < memo.length; i++) { 10 | for (int j = 0; j < memo[i].length; j++) { 11 | memo[i][j] = -1; 12 | } 13 | } 14 | return countBinary(N, false, memo); 15 | } 16 | 17 | private int countBinary(int N, boolean prevSet, int[][] memo) { 18 | if (N == 0) return 1; 19 | int i = (prevSet) ? 1 : 0; 20 | if (memo[N][i] == -1) { 21 | memo[N][i] = countBinary(N - 1, false, memo); 22 | if (!prevSet) { 23 | memo[N][i] += countBinary(N - 1, true, memo); 24 | } 25 | } 26 | return memo[N][i]; 27 | } 28 | 29 | public int countBottomUp(int N) { 30 | int a = 1, b = 1, c = 0; 31 | for (int i = 1; i <= N; i++) { 32 | c = a + b; 33 | a = b; 34 | b = c; 35 | } 36 | return c; 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/dp/CountWaysToReachNStairs.java: -------------------------------------------------------------------------------- 1 | package dp; 2 | 3 | /** 4 | * Question: http://www.geeksforgeeks.org/count-ways-reach-nth-stair/ 5 | * 6 | * @author Sudharsanan Muralidharan 7 | */ 8 | public class CountWaysToReachNStairs { 9 | public int countWays(int n, int m) { 10 | return countWays(n, m, new int[n + 1]); 11 | } 12 | 13 | private int countWays(int n, int m, int[] results) { 14 | if (n < 0) { 15 | return 0; 16 | } else if (n == 0) { 17 | return 1; 18 | } else if (results[n] == 0) { 19 | for (int i = 1; i <= m; i++) { 20 | results[n] += countWays((n - i), m, results); 21 | } 22 | } 23 | return results[n]; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/dp/EggDroppingProblem.java: -------------------------------------------------------------------------------- 1 | package dp; 2 | 3 | /** 4 | * Question: http://www.geeksforgeeks.org/dynamic-programming-set-11-egg-dropping-puzzle/ 5 | */ 6 | public class EggDroppingProblem { 7 | public int minAttemptsRecursive(int floors, int eggs) { 8 | if (floors == 0 || eggs == 1 || eggs > floors) { 9 | return floors; 10 | } else { 11 | int min = Integer.MAX_VALUE; 12 | for (int i = 1; i <= floors; i++) { 13 | min = Math.min(min, Math.max(1 + minAttemptsRecursive(i - 1, eggs - 1), 14 | 1 + minAttemptsRecursive(floors - i, eggs))); 15 | } 16 | return min; 17 | } 18 | } 19 | 20 | public int minAttemptsDP(int floors, int eggs) { 21 | int[][] results = new int[eggs + 1][floors + 1]; 22 | for (int i = 1; i < results[0].length; i++) { 23 | results[1][i] = i; 24 | } 25 | 26 | for (int i = 2; i < (eggs + 1); i++) { 27 | for (int j = 1; j < (floors + 1); j++) { 28 | if (i > j) { 29 | results[i][j] = j; 30 | } else { 31 | int min = Integer.MAX_VALUE; 32 | for (int k = 1; k <= j; k++) { 33 | min = Math.min(min, Math.max((1 + results[i - 1][k - 1]), (1 + results[i][j - k]))); 34 | } 35 | results[i][j] = min; 36 | } 37 | } 38 | } 39 | 40 | return results[eggs][floors]; 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/dp/FibonacciNumber.java: -------------------------------------------------------------------------------- 1 | package dp; 2 | 3 | public class FibonacciNumber { 4 | 5 | public long fib(int n) { 6 | if (n == 0 || n == 1) { 7 | return n; 8 | } else { 9 | return fib(n - 1) + fib(n - 2); 10 | } 11 | } 12 | 13 | public long fibMemoized(int n) { 14 | return fibMemoized(n, new long[n + 1]); 15 | } 16 | 17 | private long fibMemoized(int n, long[] results) { 18 | if (n == 0 || n == 1) { 19 | results[n] = n; 20 | } else if (results[n] == 0) { 21 | results[n] = fibMemoized(n - 1, results) + fibMemoized(n - 2, results); 22 | } 23 | 24 | return results[n]; 25 | } 26 | 27 | public long fibTabulated(int n) { 28 | 29 | if (n == 0 || n == 1) { 30 | return n; 31 | } 32 | 33 | long[] results = new long[n + 1]; 34 | results[0] = 0; 35 | results[1] = 1; 36 | for (int i = 2; i <= n; i++) { 37 | results[i] = results[i - 1] + results[i - 2]; 38 | } 39 | 40 | return results[n]; 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/dp/Job.java: -------------------------------------------------------------------------------- 1 | package dp; 2 | 3 | /** 4 | * Created by sudharti on 6/27/17. 5 | */ 6 | public class Job { 7 | int start = 0, end = 0, profit = 0; 8 | 9 | public Job(int start, int end, int profit) { 10 | this.start = start; 11 | this.end = end; 12 | this.profit = profit; 13 | } 14 | 15 | @Override 16 | public String toString() { 17 | return start + ":" + end + ":" + profit; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/dp/LargestSubsquareXO.java: -------------------------------------------------------------------------------- 1 | package dp; 2 | 3 | /** 4 | * Question: http://www.geeksforgeeks.org/given-matrix-o-x-find-largest-subsquare-surrounded-x/ 5 | * Solution: https://www.youtube.com/watch?v=vi_1eHCsR9A 6 | */ 7 | public class LargestSubsquareXO { 8 | public int maxSquare(char[][] matrix) { 9 | int max = 0; 10 | if (matrix.length == 0) return max; 11 | 12 | int[][][] memo = new int[matrix.length][matrix[0].length][2]; 13 | for (int i = 0; i < matrix.length; i++) { 14 | for (int j = 0; j < matrix[i].length; j++) { 15 | if (matrix[i][j] == 'X') { 16 | memo[i][j][0] = ((i == 0) ? 0 : memo[i - 1][j][0]) + 1; 17 | memo[i][j][1] = ((j == 0) ? 0 : memo[i][j - 1][1]) + 1; 18 | } 19 | } 20 | } 21 | 22 | for (int i = matrix.length - 1; i >= 0; i--) { 23 | for (int j = matrix[i].length - 1; j >= 0; j--) { 24 | int size = Math.min(memo[i][j][0], memo[i][j][1]); 25 | while (size > max) { 26 | if ((i - size + 1 >= 0 && memo[i - size + 1][j][1] >= size) && 27 | (j - size + 1 >= 0 && memo[i][j - size + 1][0] >= size)) { 28 | max = size; 29 | } 30 | size--; 31 | } 32 | } 33 | } 34 | 35 | return max; 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/dp/LongestBitonicSubsequence.java: -------------------------------------------------------------------------------- 1 | package dp; 2 | 3 | /** 4 | * Question: http://www.geeksforgeeks.org/dynamic-programming-set-15-longest-bitonic-subsequence/ 5 | * Solution: https://www.youtube.com/watch?v=TWHytKnOPaQ 6 | */ 7 | public class LongestBitonicSubsequence { 8 | public int longest(int[] arr) { 9 | int longest = 1; 10 | int[] memo = new int[arr.length]; 11 | int[] reverseMemo = new int[arr.length]; 12 | 13 | for (int i = 0; i < memo.length; i++) { 14 | memo[i] = 1; 15 | reverseMemo[memo.length - i - 1] = 1; 16 | } 17 | 18 | for (int i = 1; i < arr.length; i++) { 19 | for (int j = 0; j < i; j++) { 20 | if (arr[j] < arr[i]) { 21 | memo[i] = Math.max(memo[i], memo[j] + 1); 22 | } 23 | } 24 | } 25 | 26 | for (int i = arr.length - 1; i >= 0; i--) { 27 | for (int j = arr.length - 1; j > i; j--) { 28 | if (arr[j] < arr[i]) { 29 | reverseMemo[i] = Math.max(reverseMemo[i], reverseMemo[j] + 1); 30 | } 31 | } 32 | } 33 | 34 | for (int i = 0; i < memo.length; i++) { 35 | longest = Math.max(longest, memo[i] + reverseMemo[i] - 1); 36 | } 37 | 38 | return longest; 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/dp/LongestCommonSubstring.java: -------------------------------------------------------------------------------- 1 | package dp; 2 | 3 | /** 4 | * Question: http://www.geeksforgeeks.org/longest-common-substring/ 5 | * 6 | * @author Sudharsanan Muralidharan 7 | */ 8 | public class LongestCommonSubstring { 9 | 10 | public String lcsTabulated(String s1, String s2) { 11 | int[][] table = new int[s1.length() + 1][s2.length() + 1]; 12 | int longest = table[0][0]; 13 | for (int i = 1; i < table.length; i++) { 14 | for (int j = 1; j < table[0].length; j++) { 15 | if (s1.charAt(i - 1) == s2.charAt(j - 1)) { 16 | table[i][j] = table[i - 1][j - 1] + 1; 17 | } 18 | } 19 | } 20 | 21 | int[] longestTuple = new int[2]; 22 | 23 | for (int i = 1; i < table.length; i++) { 24 | for (int j = 1; j < table[0].length; j++) { 25 | if (table[i][j] > longest) { 26 | longest = table[i][j]; 27 | longestTuple[0] = i; 28 | longestTuple[1] = j; 29 | } 30 | } 31 | } 32 | 33 | return lcsString(s1, table, longestTuple[0], longestTuple[1]); 34 | } 35 | 36 | private String lcsString(String s1, int[][] table, int i, int j) { 37 | StringBuilder builder = new StringBuilder(); 38 | while (table[i][j] != 0) { 39 | builder.append(s1.charAt(i - 1)); 40 | i--; 41 | j--; 42 | } 43 | 44 | return builder.reverse().toString(); 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/dp/LongestPalindromicSubstring.java: -------------------------------------------------------------------------------- 1 | package dp; 2 | 3 | /** 4 | * Question: http://www.geeksforgeeks.org/?p=25463 5 | */ 6 | public class LongestPalindromicSubstring { 7 | public String longestPS(String input) { 8 | StringBuilder outputBuilder = new StringBuilder(); 9 | String reverse = new StringBuilder(input).reverse().toString(); 10 | int[][] matrix = new int[input.length() + 1][input.length() + 1]; 11 | Tuple max = new Tuple(0, 0, Integer.MIN_VALUE); 12 | 13 | for (int i = 1; i < matrix.length; i++) { 14 | for (int j = 1; j < matrix[0].length; j++) { 15 | if (input.charAt(i - 1) == reverse.charAt(j - 1)) { 16 | matrix[i][j] = matrix[i - 1][j - 1] + 1; 17 | if (matrix[i][j] > max.val) { 18 | max.i = i; 19 | max.j = j; 20 | max.val = matrix[i][j]; 21 | } 22 | } 23 | } 24 | } 25 | 26 | for (int i = max.i, j = max.j; matrix[i][j] > 0; i--, j--) { 27 | outputBuilder.append(input.charAt(i - 1)); 28 | } 29 | 30 | return outputBuilder.toString(); 31 | } 32 | 33 | class Tuple { 34 | int i, j; 35 | int val; 36 | 37 | public Tuple(int i, int j, int val) { 38 | this.i = i; 39 | this.j = j; 40 | this.val = val; 41 | } 42 | 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/dp/MatrixMultiplication.java: -------------------------------------------------------------------------------- 1 | package dp; 2 | 3 | /** 4 | * Question: http://www.geeksforgeeks.org/dynamic-programming-set-8-matrix-chain-multiplication/ 5 | * Solution: https://www.youtube.com/watch?v=vgLJZMUfnsU 6 | */ 7 | public class MatrixMultiplication { 8 | public int minOperations(int[][] matrices) { 9 | int[][] memo = new int[matrices.length][matrices.length]; 10 | int len = 2; 11 | 12 | while (len <= matrices.length) { 13 | for (int start = 0, end = start + len - 1; end < matrices.length; start++, end++) { 14 | int min = Integer.MAX_VALUE; 15 | for (int r = start; r < end; r++) { 16 | int total = memo[start][r] + memo[r + 1][end] + (matrices[start][0] * matrices[r][1] * matrices[end][1]); 17 | min = Math.min(min, total); 18 | } 19 | memo[start][end] = min; 20 | } 21 | len++; 22 | } 23 | 24 | return memo[0][matrices.length - 1]; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/dp/MaximumSumNonAdjacent.java: -------------------------------------------------------------------------------- 1 | package dp; 2 | 3 | /** 4 | * Question: http://www.geeksforgeeks.org/maximum-sum-such-that-no-two-elements-are-adjacent/ 5 | * Solution: https://www.youtube.com/watch?v=UtGtF6nc35g 6 | */ 7 | public class MaximumSumNonAdjacent { 8 | public int maxSum(int[] arr) { 9 | int[][] memo = new int[arr.length + 1][arr.length]; 10 | for (int i = 0; i < memo.length; i++) { 11 | for (int j = 0; j < memo[i].length; j++) { 12 | memo[i][j] = -1; 13 | } 14 | } 15 | return maxSum(arr, 0, arr.length, memo); 16 | } 17 | 18 | public int maxSumBottomUp(int[] arr) { 19 | int[] memo = new int[arr.length + 1]; 20 | memo[1] = Math.max(0, arr[0]); 21 | for (int i = 2; i < memo.length; i++) { 22 | memo[i] = Math.max(arr[i - 1], Math.max(memo[i - 1], arr[i - 1] + memo[i - 2])); 23 | } 24 | return memo[arr.length]; 25 | } 26 | 27 | private int maxSum(int[] arr, int index, int prev, int[][] memo) { 28 | if (index == arr.length) return 0; 29 | if (memo[prev][index] == -1) { 30 | int max = maxSum(arr, index + 1, prev, memo); 31 | if ((index) != prev + 1) { 32 | max = Math.max(max, maxSum(arr, index + 1, index, memo) + arr[index]); 33 | } 34 | memo[prev][index] = max; 35 | } 36 | return memo[prev][index]; 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/dp/OptimalStrategyGamePicks.java: -------------------------------------------------------------------------------- 1 | package dp; 2 | 3 | /** 4 | * Question: http://www.geeksforgeeks.org/dynamic-programming-set-31-optimal-strategy-for-a-game/ 5 | * Solution: https://www.youtube.com/watch?v=WxpIHvsu1RI 6 | */ 7 | public class OptimalStrategyGamePicks { 8 | public int maxValue(int[] arr) { 9 | int n = arr.length, len = 2; 10 | int[][][] memo = new int[n][n][2]; 11 | for (int i = 0; i < n; i++) memo[i][i][0] = arr[i]; 12 | while (len <= n) { 13 | for (int start = 0, end = start + len - 1; end < n; start++, end++) { 14 | int p1 = memo[start][start][0] + memo[start + 1][end][1]; 15 | int p2 = memo[start + 1][end][0] + memo[start][start][1]; 16 | 17 | if ((memo[end][end][0] + memo[start][end - 1][1]) > p1) { 18 | p1 = memo[end][end][0] + memo[start][end - 1][1]; 19 | p2 = memo[start][end - 1][0] + memo[end][end][1]; 20 | } 21 | memo[start][end][0] = p1; 22 | memo[start][end][1] = p2; 23 | } 24 | len++; 25 | } 26 | 27 | return memo[0][n - 1][0]; 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/dp/PalindromePartitioning.java: -------------------------------------------------------------------------------- 1 | package dp; 2 | 3 | /** 4 | * Question: http://www.geeksforgeeks.org/dynamic-programming-set-17-palindrome-partitioning/ 5 | * Solution: https://www.youtube.com/watch?v=lDYIvtBVmgo 6 | */ 7 | public class PalindromePartitioning { 8 | public int minCuts(String s) { 9 | if (s.length() == 0) return 0; 10 | int[][] memo = new int[s.length()][s.length()]; 11 | int len = 2; 12 | while (len <= s.length()) { 13 | for (int start = 0, end = start + len - 1; end < s.length(); start++, end++) { 14 | if (s.charAt(start) == s.charAt(end) && memo[start + 1][end - 1] == 0) { 15 | memo[start][end] = 0; 16 | } else { 17 | int min = Integer.MAX_VALUE; 18 | for (int r = start; r < end; r++) { 19 | min = Math.min(min, (memo[start][r] + memo[r + 1][end] + 1)); 20 | } 21 | memo[start][end] = min; 22 | } 23 | } 24 | len++; 25 | } 26 | return memo[0][s.length() - 1]; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/dp/RodCutting.java: -------------------------------------------------------------------------------- 1 | package dp; 2 | 3 | import java.util.Map; 4 | 5 | /** 6 | * Question: http://www.geeksforgeeks.org/dynamic-programming-set-13-cutting-a-rod/ 7 | * Solution: https://www.youtube.com/watch?v=IRwVmTmN6go 8 | */ 9 | public class RodCutting { 10 | public int maxProfit(Map costsMap, int n) { 11 | int[] memo = new int[n + 1]; 12 | 13 | for (int i = 1; i < memo.length; i++) memo[i] = costsMap.getOrDefault(i, 0); 14 | 15 | for (int i = 2; i <= n; i++) { 16 | int max = 0; 17 | for (int j = 1; j <= i; j++) { 18 | max = Math.max(max, memo[j] + memo[i - j]); 19 | } 20 | memo[i] = max; 21 | } 22 | 23 | return memo[n]; 24 | } 25 | 26 | 27 | public int maxProfitTopDown(Map costsMap, int n) { 28 | int[] memo = new int[n + 1]; 29 | for (int i = 1; i < memo.length; i++) memo[i] = -1; 30 | return maxProfitTopDown(costsMap, n, memo); 31 | } 32 | 33 | private int maxProfitTopDown(Map costsMap, int n, int[] memo) { 34 | if (n <= 0) return 0; 35 | if (memo[n] == -1) { 36 | int max = 0; 37 | for (int i = 1; i <= n; i++) { 38 | max = Math.max(max, costsMap.getOrDefault(i, 0) + maxProfitTopDown(costsMap, n - i, memo)); 39 | } 40 | memo[n] = max; 41 | } 42 | 43 | return memo[n]; 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/dp/SubsetSum.java: -------------------------------------------------------------------------------- 1 | package dp; 2 | 3 | /** 4 | * Question: http://www.geeksforgeeks.org/dynamic-programming-subset-sum-problem/ 5 | * Solution: https://www.youtube.com/watch?v=s6FhG--P7z0 6 | */ 7 | public class SubsetSum { 8 | public boolean subsetSum(int n, int[] set) { 9 | return subsetSum(n, set, 0); 10 | } 11 | 12 | private boolean subsetSum(int n, int[] set, int index) { 13 | if (n == 0) { 14 | return true; 15 | } else if (n < 0 || index >= set.length) { 16 | return false; 17 | } else { 18 | return subsetSum(n - set[index], set, index + 1) || subsetSum(n, set, index + 1); 19 | } 20 | } 21 | 22 | public boolean subsetSumDP(int n, int[] set) { 23 | boolean[][] memo = new boolean[set.length + 1][n + 1]; 24 | for (int i = 0; i < set.length + 1; i++) { 25 | memo[i][0] = true; 26 | } 27 | 28 | for (int i = 1; i < memo.length; i++) { 29 | int val = set[i - 1]; 30 | for (int j = 1; j < memo[0].length; j++) { 31 | if (j >= val) { 32 | memo[i][j] = memo[i - 1][j] || memo[i - 1][j - val]; 33 | } else { 34 | memo[i][j] = memo[i - 1][j]; 35 | } 36 | } 37 | } 38 | 39 | return memo[set.length][n]; 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/dp/TotalNumberOfBSTNKeys.java: -------------------------------------------------------------------------------- 1 | package dp; 2 | 3 | /** 4 | * Question: http://www.geeksforgeeks.org/total-number-of-possible-binary-search-trees-with-n-keys/ 5 | * Solution: https://www.youtube.com/watch?v=YDf982Lb84o 6 | */ 7 | public class TotalNumberOfBSTNKeys { 8 | public long totalWays(int N) { 9 | long[] memo = new long[N + 1]; 10 | memo[0] = 1; 11 | for (int i = 1; i <= N; i++) { 12 | long sum = 0; 13 | for (int j = 1; j <= i; j++) { 14 | sum += (memo[j - 1] * memo[i - j]); 15 | } 16 | memo[i] = sum; 17 | } 18 | 19 | return memo[N]; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/dp/TotalWaysMatrix.java: -------------------------------------------------------------------------------- 1 | package dp; 2 | 3 | /** 4 | * Question: http://www.geeksforgeeks.org/count-possible-paths-top-left-bottom-right-nxm-matrix/ 5 | * Solution: https://www.youtube.com/watch?v=GO5QHC_BmvM 6 | */ 7 | public class TotalWaysMatrix { 8 | public int totalWays(int m, int n) { 9 | int[][] memo = new int[m][n]; 10 | for (int i = 0; i < m; i++) { 11 | for (int j = 0; j < n; j++) { 12 | memo[i][j] = -1; 13 | } 14 | } 15 | 16 | return totalWays(m, n, 0, 0, memo); 17 | } 18 | 19 | public int totalWaysBottomUp(int m, int n) { 20 | int[][] memo = new int[m][n]; 21 | for (int i = m - 1; i >= 0; i--) { 22 | for (int j = n - 1; j >= 0; j--) { 23 | if (i == m - 1 && j == n - 1) { 24 | memo[i][j] = 1; 25 | } else { 26 | memo[i][j] = ((i < m - 1) ? memo[i + 1][j] : 0) + 27 | ((j < n - 1) ? memo[i][j + 1] : 0); 28 | } 29 | } 30 | } 31 | 32 | return memo[0][0]; 33 | } 34 | 35 | private int totalWays(int m, int n, int i, int j, int[][] memo) { 36 | if (i == m - 1 && j == n - 1) { 37 | return 1; 38 | } else if (i >= m || i < 0 || j >= n || j < 0) { 39 | return 0; 40 | } else if (memo[i][j] == -1) { 41 | memo[i][j] = totalWays(m, n, i + 1, j, memo) + totalWays(m, n, i, j + 1, memo); 42 | } 43 | 44 | return memo[i][j]; 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/graph/MinStepsKnightsTour.java: -------------------------------------------------------------------------------- 1 | package graph; 2 | 3 | import java.util.LinkedList; 4 | import java.util.Queue; 5 | 6 | /** 7 | * Question: http://www.geeksforgeeks.org/minimum-steps-reach-target-knight/ 8 | */ 9 | public class MinStepsKnightsTour { 10 | public int minSteps(int[] position, int[] target, int N) { 11 | int[][] board = new int[N][N]; 12 | for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) board[i][j] = -1; 13 | board[position[0]][position[1]] = 0; 14 | Queue queue = new LinkedList<>(); 15 | queue.offer(new Integer[]{position[0], position[1]}); 16 | int[][] directions = {{2, 1}, {1, 2}, {-1, 2}, {-2, 1}, {-2, -1}, {-1, -2}, {1, -2}, {2, -1}}; 17 | while (!queue.isEmpty()) { 18 | Integer[] current = queue.poll(); 19 | int x = current[0], y = current[1]; 20 | if (x == target[0] && y == target[1]) return board[x][y]; 21 | for (int[] direction : directions) { 22 | int i = x + direction[0], j = y + direction[1]; 23 | if (i >= 0 && i < N && j >= 0 && j < N && board[i][j] == -1) { 24 | board[i][j] = 1 + board[x][y]; 25 | queue.offer(new Integer[]{i, j}); 26 | } 27 | } 28 | } 29 | return Integer.MAX_VALUE; 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/greedy/ActivitySelection.java: -------------------------------------------------------------------------------- 1 | package greedy; 2 | 3 | import java.util.Arrays; 4 | import java.util.Comparator; 5 | 6 | /** 7 | * Question: http://www.geeksforgeeks.org/greedy-algorithms-set-1-activity-selection-problem/ 8 | * Solution: http://www.geeksforgeeks.org/greedy-algorithms-set-1-activity-selection-problem/ 9 | */ 10 | public class ActivitySelection { 11 | public static int maxActivities(Integer[][] activities) { 12 | int count = 1, current = 0; 13 | Arrays.sort(activities, Comparator.comparing(o -> o[1])); 14 | for (int i = 1; i < activities.length; i++) { 15 | if (activities[i][0] >= activities[current][1]) { 16 | count++; 17 | current = i; 18 | } 19 | } 20 | return count; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/greedy/FractionalKnapsack.java: -------------------------------------------------------------------------------- 1 | package greedy; 2 | 3 | import java.util.*; 4 | 5 | /** 6 | * Question: http://www.geeksforgeeks.org/fractional-knapsack-problem/ 7 | * Solution: http://www.geeksforgeeks.org/fractional-knapsack-problem/ 8 | */ 9 | public class FractionalKnapsack { 10 | public static double maxValue(Integer[][] items, int W) { 11 | int currentCapacity = 0; 12 | double maxValue = 0; 13 | Arrays.sort(items, (o1, o2) -> Double.valueOf(((double) o2[1] / o2[0])).compareTo((double) o1[1] / o1[0])); 14 | 15 | for (int i = 0; i < items.length; i++) { 16 | int numPounds = items[i][0]; 17 | if ((currentCapacity + numPounds) <= W) { 18 | currentCapacity += numPounds; 19 | maxValue += (items[i][1]); 20 | } else { 21 | maxValue += (((double) items[i][1]/items[i][0]) * (W - currentCapacity)); 22 | break; 23 | } 24 | } 25 | 26 | return Math.round(maxValue * 100d) / 100d; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/greedy/JobSequencing.java: -------------------------------------------------------------------------------- 1 | package greedy; 2 | 3 | import java.util.Arrays; 4 | import java.util.Comparator; 5 | import java.util.PriorityQueue; 6 | 7 | /** 8 | * Question: http://www.geeksforgeeks.org/job-sequencing-problem-set-1-greedy-algorithm/ 9 | */ 10 | public class JobSequencing { 11 | public static int maxProfit(Integer[][] jobs) { 12 | int profit = 0; 13 | Arrays.sort(jobs, Comparator.comparing(o -> o[0])); 14 | PriorityQueue queue = new PriorityQueue<>(Comparator.comparing(o -> o[1])); 15 | for (int i = 0; i < jobs.length; i++) { 16 | int k = jobs[i][0]; 17 | if (queue.size() >= k && jobs[i][1] > queue.peek()[1]) { 18 | queue.poll(); 19 | queue.offer(jobs[i]); 20 | } else if (queue.size() < k) { 21 | queue.offer(jobs[i]); 22 | } 23 | } 24 | 25 | while (!queue.isEmpty()) { 26 | profit += queue.poll()[1]; 27 | } 28 | 29 | return profit; 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/linked_list/PairwiseSwapLinkedList.java: -------------------------------------------------------------------------------- 1 | package linked_list; 2 | 3 | import datastructures.lists.CustomLinkedList; 4 | import datastructures.lists.LinkedListNode; 5 | 6 | public class PairwiseSwapLinkedList { 7 | private CustomLinkedList linkedList = null; 8 | 9 | public void constructLinkedList(String input) { 10 | linkedList = new CustomLinkedList(); 11 | String[] elements = input.split(" "); 12 | 13 | for (String e : elements) { 14 | if (e != null && !e.trim().isEmpty()) { 15 | linkedList.add(Integer.parseInt(e.toString())); 16 | } 17 | } 18 | } 19 | 20 | public CustomLinkedList pairwiseSwap() { 21 | LinkedListNode current = linkedList.head(); 22 | LinkedListNode runner = current.next; 23 | LinkedListNode prev = null; 24 | 25 | while (runner != null) { 26 | current.next = runner.next; 27 | if (prev != null) { 28 | prev.next = runner; 29 | } 30 | runner.next = current; 31 | if (current.equals(linkedList.head())) { 32 | linkedList.head(runner); 33 | } 34 | 35 | prev = current; 36 | current = current.next; 37 | runner = (current != null) ? current.next : null; 38 | } 39 | 40 | return linkedList; 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/matrix/CircularMatrix.java: -------------------------------------------------------------------------------- 1 | package matrix; 2 | 3 | /** 4 | * Question: http://www.geeksforgeeks.org/?p=141853 5 | * 6 | * @author Sudharsanan Muralidharan 7 | */ 8 | public class CircularMatrix { 9 | public static int[][] constructMatrix(int m, int n) { 10 | int[][] result = new int[m][n]; 11 | int product = m * n; 12 | int num = 1, startRow = 0, endRow = m, startColumn = 0, endColumn = n; 13 | 14 | while (num <= product) { 15 | for (int j = startColumn; j < endColumn && num <= product; j++) { 16 | result[startRow][j] = num++; 17 | } 18 | 19 | for (int i = startRow + 1; i < endRow && num <= product; i++) { 20 | result[i][endColumn - 1] = num++; 21 | } 22 | 23 | for (int j = endColumn - 2; j >= startColumn && num <= product; j--) { 24 | result[endRow - 1][j] = num++; 25 | } 26 | 27 | for (int i = endRow - 2; i > startRow && num <= product; i--) { 28 | result[i][startColumn] = num++; 29 | } 30 | 31 | startColumn++; 32 | startRow++; 33 | endColumn--; 34 | endRow--; 35 | 36 | } 37 | 38 | return result; 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/random/CartesianProduct.java: -------------------------------------------------------------------------------- 1 | /** 2 | * 3 | */ 4 | package random; 5 | 6 | import java.util.ArrayList; 7 | import java.util.List; 8 | import java.util.Stack; 9 | 10 | /** 11 | * @author Sudharsanan Muralidharan 12 | */ 13 | public class CartesianProduct { 14 | 15 | private List> listOfLists = null; 16 | 17 | public CartesianProduct() { 18 | listOfLists = new ArrayList>(); 19 | } 20 | 21 | public void addList(String[] values) { 22 | List inputList = new ArrayList(); 23 | for (int i = 0; i < values.length; i++) { 24 | inputList.add(values[i]); 25 | } 26 | listOfLists.add(inputList); 27 | } 28 | 29 | public List> product() { 30 | List> results = new ArrayList>(); 31 | product(listOfLists, new Stack(), results, 0); 32 | return results; 33 | } 34 | 35 | @SuppressWarnings("unchecked") 36 | private void product(List> lists, Stack temp, List> results, int index) { 37 | if (index >= lists.size()) { 38 | results.add((List) temp.clone()); 39 | return; 40 | } 41 | 42 | List list = lists.get(index); 43 | for (int i = 0; i < list.size(); i++) { 44 | temp.push(list.get(i)); 45 | product(lists, temp, results, index + 1); 46 | temp.pop(); 47 | } 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/random/IsDigitFrequencyLessThanDigit.java: -------------------------------------------------------------------------------- 1 | package random; 2 | 3 | /** 4 | * Question: http://www.geeksforgeeks.org/check-frequency-digit-less-digit/ 5 | * 6 | * @author Sudharsanan Muralidharan 7 | */ 8 | public class IsDigitFrequencyLessThanDigit { 9 | 10 | public boolean isFrequencyLessThanDigit(int n) { 11 | if (n == 0) { 12 | return false; 13 | } 14 | 15 | int digit = 0; 16 | int[] arr = new int[10]; 17 | while (n > 0) { 18 | digit = (n % 10); 19 | n /= 10; 20 | arr[digit]++; 21 | if (arr[digit] > digit) { 22 | return false; 23 | } 24 | } 25 | 26 | return true; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/random/LongestPalindromicSubstring.java: -------------------------------------------------------------------------------- 1 | package random; 2 | 3 | /** 4 | * Question: http://www.geeksforgeeks.org/?p=25714 5 | */ 6 | public class LongestPalindromicSubstring { 7 | public String longestPS(String input) { 8 | int maxLength = 1, start = 0; 9 | for (int i = 0; i < input.length(); i++) { 10 | for (int x = i - 1, y = i + 1; x >= 0 && y < input.length() && input.charAt(x) == input.charAt(y); x--, y++) { 11 | int length = y - x + 1; 12 | if (length > maxLength) { 13 | maxLength = length; 14 | start = x; 15 | } 16 | } 17 | 18 | for (int x = i, y = i + 1; x >= 0 && y < input.length() && input.charAt(x) == input.charAt(y); x--, y++) { 19 | int length = y - x + 1; 20 | if (length > maxLength) { 21 | maxLength = length; 22 | start = x; 23 | } 24 | } 25 | } 26 | 27 | return input.substring(start, (start + maxLength)); 28 | } 29 | } -------------------------------------------------------------------------------- /geeks-for-geeks/src/random/SecondSmallest.java: -------------------------------------------------------------------------------- 1 | package random; 2 | 3 | public class SecondSmallest { 4 | public int fetchSecondSmallest(int[] arr) { 5 | if (arr.length < 2) { 6 | return -1; 7 | } 8 | 9 | int smallest, smallest2; 10 | 11 | smallest = Math.min(arr[0], arr[1]); 12 | smallest2 = Math.max(arr[0], arr[1]); 13 | 14 | for (int i = 2; i < arr.length; i++) { 15 | if (arr[i] < smallest) { 16 | smallest2 = smallest; 17 | smallest = arr[i]; 18 | } else if (arr[i] < smallest2) { 19 | smallest2 = arr[i]; 20 | } 21 | } 22 | 23 | return smallest2; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/sort/BubbleSort.java: -------------------------------------------------------------------------------- 1 | package sort; 2 | 3 | /** 4 | * Question: http://www.geeksforgeeks.org/bubble-sort/ 5 | * 6 | * @param 7 | */ 8 | public class BubbleSort extends Sort { 9 | 10 | @Override 11 | public T[] sort(T[] arr) { 12 | for (int i = 0; i < arr.length; i++) { 13 | for (int j = 0; j < arr.length - 1; j++) { 14 | if (compare(arr[j], arr[j + 1]) > 0) { 15 | swap(arr, j, j + 1); 16 | } 17 | } 18 | } 19 | 20 | return arr; 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/sort/HeapSort.java: -------------------------------------------------------------------------------- 1 | package sort; 2 | 3 | import datastructures.heap.BinaryMaxHeap; 4 | 5 | /** 6 | * Question: http://www.geeksforgeeks.org/heap-sort/ 7 | * 8 | * @param 9 | */ 10 | public class HeapSort extends Sort { 11 | 12 | private BinaryMaxHeap binaryMaxHeap = null; 13 | 14 | public HeapSort(Class clazz) { 15 | binaryMaxHeap = new BinaryMaxHeap(clazz); 16 | } 17 | 18 | @Override 19 | public T[] sort(T[] arr) { 20 | return binaryMaxHeap.sort(arr); 21 | } 22 | 23 | } -------------------------------------------------------------------------------- /geeks-for-geeks/src/sort/InsertionSort.java: -------------------------------------------------------------------------------- 1 | package sort; 2 | 3 | /** 4 | * Question: http://www.geeksforgeeks.org/insertion-sort/ 5 | * 6 | * @param 7 | */ 8 | public class InsertionSort extends Sort { 9 | 10 | @Override 11 | public T[] sort(T[] arr) { 12 | for (int i = 0; i < arr.length; i++) { 13 | int j = i; 14 | while (j > 0) { 15 | if (compare(arr[j], arr[j - 1]) < 0) { 16 | swap(arr, j, j - 1); 17 | } 18 | j--; 19 | } 20 | } 21 | return arr; 22 | } 23 | 24 | } 25 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/sort/SelectionSort.java: -------------------------------------------------------------------------------- 1 | package sort; 2 | 3 | /** 4 | * Question: http://www.geeksforgeeks.org/selection-sort/ 5 | * 6 | * @param 7 | */ 8 | public class SelectionSort extends Sort { 9 | 10 | @Override 11 | public T[] sort(T[] arr) { 12 | for (int i = 0; i < arr.length; i++) { 13 | for (int j = i + 1; j < arr.length; j++) { 14 | if (compare(arr[i], arr[j]) > 0) { 15 | swap(arr, i, j); 16 | } 17 | } 18 | } 19 | return arr; 20 | } 21 | 22 | } -------------------------------------------------------------------------------- /geeks-for-geeks/src/sort/Sort.java: -------------------------------------------------------------------------------- 1 | package sort; 2 | 3 | public abstract class Sort { 4 | 5 | public abstract T[] sort(T[] arr); 6 | 7 | protected void swap(T[] arr, int i, int j) { 8 | T temp = arr[j]; 9 | arr[j] = arr[i]; 10 | arr[i] = temp; 11 | } 12 | 13 | protected int compare(T a, T b) { 14 | if (a instanceof Integer && b instanceof Integer) { 15 | return ((Integer) a).compareTo((Integer) b); 16 | } else if (a instanceof Float) { 17 | return ((Float) a).compareTo((Float) b); 18 | } else if (a instanceof Double) { 19 | return ((Double) a).compareTo((Double) b); 20 | } else if (a instanceof Character) { 21 | return ((Character) a).compareTo((Character) b); 22 | } else if (a instanceof String) { 23 | return ((String) a).compareTo((String) b); 24 | } 25 | return -1; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/tree/MultiTree.java: -------------------------------------------------------------------------------- 1 | package tree; 2 | 3 | import java.util.LinkedList; 4 | import java.util.List; 5 | import java.util.Queue; 6 | 7 | /** 8 | * Created by sudharti on 8/6/17. 9 | */ 10 | public class MultiTree { 11 | MultiTreeNode root = null; 12 | 13 | public MultiTreeNode insertRoot(int val) { 14 | this.root = new MultiTreeNode(val); 15 | return root; 16 | } 17 | 18 | public MultiTreeNode insert(MultiTreeNode parent, int val) { 19 | MultiTreeNode node = null; 20 | if (parent != null) { 21 | node = new MultiTreeNode(val); 22 | parent.children.add(node); 23 | } 24 | return node; 25 | } 26 | 27 | public static String bfs(MultiTreeNode root) { 28 | StringBuilder builder = new StringBuilder(); 29 | Queue queue = new LinkedList<>(); 30 | queue.add(root); 31 | while (!queue.isEmpty()) { 32 | MultiTreeNode current = queue.poll(); 33 | builder.append(current.val); 34 | List children = current.children; 35 | for (MultiTreeNode child : children) { 36 | queue.offer(child); 37 | } 38 | builder.append(","); 39 | } 40 | 41 | return builder.substring(0, builder.length() - 1).toString(); 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/tree/MultiTreeNode.java: -------------------------------------------------------------------------------- 1 | package tree; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | /** 7 | * Created by sudharti on 8/6/17. 8 | */ 9 | public class MultiTreeNode { 10 | public int val = 0; 11 | public List children; 12 | 13 | public MultiTreeNode() { 14 | this(0, new ArrayList<>()); 15 | } 16 | 17 | public MultiTreeNode(int val) { 18 | this(val, new ArrayList<>()); 19 | } 20 | 21 | public MultiTreeNode(int val, List children) { 22 | this.val = val; 23 | this.children = children; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /geeks-for-geeks/src/tree/SmallestSubTreeDeepestNodes.java: -------------------------------------------------------------------------------- 1 | package tree; 2 | 3 | import java.util.List; 4 | 5 | /** 6 | * Question: https://www.glassdoor.com/Interview/Find-the-shortest-subtree-that-consist-of-all-the-deepest-nodes-The-tree-is-not-binary-QTN_1409104.htm 7 | */ 8 | public class SmallestSubTreeDeepestNodes { 9 | public MultiTreeNode smallestSubTree(MultiTreeNode root) { 10 | int maxHeight = maxHeight(root) - 1; 11 | return smallestSubTree(root, 0, maxHeight); 12 | } 13 | 14 | private int maxHeight(MultiTreeNode root) { 15 | if (root == null) return 0; 16 | int max = 0; 17 | List children = root.children; 18 | for (MultiTreeNode child : children) { 19 | max = Math.max(max, maxHeight(child)); 20 | } 21 | return max + 1; 22 | } 23 | 24 | private MultiTreeNode smallestSubTree(MultiTreeNode root, int currentHeight, int maxHeight) { 25 | if (root == null) return null; 26 | if (currentHeight == maxHeight) return root; 27 | List children = root.children; 28 | int count = 0; 29 | MultiTreeNode result = null; 30 | for (MultiTreeNode child : children) { 31 | MultiTreeNode res = smallestSubTree(child, currentHeight + 1, maxHeight); 32 | if (res != null) { 33 | count++; 34 | result = res; 35 | } 36 | } 37 | 38 | return (count == 0) ? null : ((count > 1) ? root : result); 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/scaffeinate/crack-the-code/b4a12b8c062ca89d033bc48c36ad4f43f7471012/gradle/wrapper/gradle-wrapper.jar -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.properties: -------------------------------------------------------------------------------- 1 | #Thu May 18 00:05:00 EDT 2017 2 | distributionBase=GRADLE_USER_HOME 3 | distributionPath=wrapper/dists 4 | zipStoreBase=GRADLE_USER_HOME 5 | zipStorePath=wrapper/dists 6 | distributionUrl=https\://services.gradle.org/distributions/gradle-3.4-all.zip 7 | -------------------------------------------------------------------------------- /settings.gradle: -------------------------------------------------------------------------------- 1 | /* 2 | * This settings file was generated by the Gradle 'init' task. 3 | * 4 | * The settings file is used to specify which projects to include in your build. 5 | * In a single project build this file can be empty or even removed. 6 | * 7 | * Detailed information about configuring a multi-project build in Gradle can be found 8 | * in the user guide at https://docs.gradle.org/3.4/userguide/multi_project_builds.html 9 | */ 10 | 11 | /* 12 | // To declare projects as part of a multi-project build use the 'include' method 13 | include 'shared' 14 | include 'api' 15 | include 'services:webservice' 16 | */ 17 | 18 | include 'algorithms' 19 | include 'datastructures' 20 | include 'cracking-the-coding-interview' 21 | include 'geeks-for-geeks' 22 | 23 | rootProject.name = 'cracking-the-code' 24 | --------------------------------------------------------------------------------