Day - 91 work

Author: mandliya

README.md

@@ -6,9 +6,9 @@
 
 | Current Status|     Stats     |
 | :------------: | :----------: |
-| Total Problems | 129 |
-| Current Streak | 90 days |
-| Longest Streak | 90 ( August 17, 2015 - November 14, 2015 ) |
+| Total Problems | 130 |
+| Current Streak | 91 days |
+| Longest Streak | 91 ( August 17, 2015 - November 15, 2015 ) |
 
 </center>
 
@@ -129,11 +129,12 @@ Include contains single header implementation of data structures and some algori
 ### Common Data Structure and logic problems
 | Problem | Solution |
 | :------------ | :----------: |
-| Print the contents of matrix in a spiral order | [matrix_spiral_print.cpp](common_ds_problems/matrix_spiral_print.cpp)
-| Given a M x N matrix, rotate it by R rotations anticlockwise, and show the resulting matrix. | [rotate_matrix.cpp](common_ds_problems/rotate_matrix.cpp)|
-| Rotate an array by r elements ( left or right ) | [array_rotation.cpp](common_ds_problems/array_rotation.cpp)
-| Given an array of repeating/non-repeating intergeres, determine the first non-repeating int in this array | [first_non_repeating_int.cpp](common_ds_problems/first_non_repeating_int.cpp)|
-| In Quantumland, there are n cities numbered from 1 to n. Here, c<sub>i</sub> denotes the i<sup>th</sup> city. There are n−1 roads in Quantumland. Here, c<sub>i</sub> and c<sub>i+1</sub> have a bidirectional road between them for each i < n.There is a rumor that Flatland is going to attack Quantumland, and the queen wants to keep her land safe. The road between c<sub>i</sub> and c<sub>i+1</sub> is safe if there is a guard in c<sub>i</sub> or c<sub>i+1</sub>. The queen has already placed a few guards in some of the cities, but she is not sure if they are enough to keep the roads safe. She wants to know the minimum number of new guards she needs to hire. See comments in solution for input/output details. | [save_quantamland.cpp](common_ds_problems/save_quantumland.cpp)|
+| Print the contents of matrix in a spiral order | [matrix_spiral_print.cpp](common_ds_algo_problems/matrix_spiral_print.cpp)
+| Given a M x N matrix, rotate it by R rotations anticlockwise, and show the resulting matrix. | [rotate_matrix.cpp](common_ds_algo_problems/rotate_matrix.cpp)|
+| Rotate an array by r elements ( left or right ) | [array_rotation.cpp](common_ds_algo_problems/array_rotation.cpp)
+| Given an array of repeating/non-repeating intergeres, determine the first non-repeating int in this array | [first_non_repeating_int.cpp](common_ds_algo_problems/first_non_repeating_int.cpp)|
+| In Quantumland, there are n cities numbered from 1 to n. Here, c<sub>i</sub> denotes the i<sup>th</sup> city. There are n−1 roads in Quantumland. Here, c<sub>i</sub> and c<sub>i+1</sub> have a bidirectional road between them for each i < n.There is a rumor that Flatland is going to attack Quantumland, and the queen wants to keep her land safe. The road between c<sub>i</sub> and c<sub>i+1</sub> is safe if there is a guard in c<sub>i</sub> or c<sub>i+1</sub>. The queen has already placed a few guards in some of the cities, but she is not sure if they are enough to keep the roads safe. She wants to know the minimum number of new guards she needs to hire. See comments in solution for input/output details. | [save_quantamland.cpp](common_ds_algo_problems/save_quantumland.cpp)|
+| You are given an integer N. Find the digits in this number that exactly divide N (division that leaves 0 as remainder) and display their count. For N=24, there are 2 digits (2 & 4). Both of these digits exactly divide 24. So our answer is 2. See more details in header comment of the solution file. | [findDigits.cpp](common_ds_algo_problems/findDigits.cpp]|
 
 ### Math Problems
 | Problem | Solution |

common_ds_problems/array_rotation.cpp renamed to common_ds_algo_problems/array_rotation.cpp

@@ -0,0 +1,59 @@
+/**
+ * You are given an integer N. Find the digits in this number that exactly divide N (division that leaves 0 as remainder) and display their count.
+ * For N=24, there are 2 digits (2 & 4). Both of these digits exactly divide 24. So our answer is 2.
+ *
+ * Note
+ *
+ * If the same number is repeated twice at different positions, it should be counted twice,
+ * e.g., For N=122, 2 divides 122 exactly and occurs at ones' and tens' position. So for this case, our answer is 3.
+ * Division by 0 is undefined.
+ *
+ *
+ * Input Format
+ * The first line contains T (the number of test cases), followed by T lines (each containing an integer N).
+ *
+ * Constraints
+ * 1≤T≤15
+ * 0<N<1010
+ * Output Format
+ *
+ * For each test case, display the count of digits in N that exactly divide N in a separate line.
+ *
+ * Sample Input
+ *
+ * 2
+ * 12
+ * 1012
+ *
+ * Sample Output
+ * 2
+ * 3
+ */
+
+#include <cmath>
+#include <cstdio>
+#include <vector>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+
+
+int main() {
+    int T, num;
+    cin >> T;
+    for (int t = 0; t < T; ++t) {
+        cin >> num;
+        int c = 0, d =0;
+        int x = num;
+        while(x > 0) {
+            d = x % 10;
+            if ( d != 0 && num % d == 0) {
+                ++c;
+            }
+            x = x/10;
+        }
+        cout << c << endl;
+    }
+    return 0;
+}
+

common_ds_algo_problems/findDigits.cpp

@@ -0,0 +1,35 @@
+#include <iostream>
+#include <vector>
+
+template <typename T>
+class Heap {
+	T * arr;
+	size_t capacity;
+	size_t heap_size;
+
+public:
+	Heap( T * arr, size_t heap_size );
+	T left( size_t i ) { return ( i - 1 )/2; }
+	T right( size_t i ) { return (2 * i + 1); }
+	T parent( size_t i ) { return ( 2 * i + 2 ); }
+	void minHeapify( size_t i );
+	T getMin() { return arr[0]; }
+	int extractMin();
+};
+
+Heap::Heap(T * harr, size_t heapSize ) {
+	heap_size = heapSize;
+	arr = harr;
+	size_t i = ( heap_size - 1 )/ 2;
+	while ( i >= 0 ) {
+		minHeapify(i);
+		i--;
+	}
+}
+
+template <typename T>
+T Heap::extractMin() {
+	if (heap_size == 0 ) {
+		
+	}
+}