Day 70 - 3 leet code problems

Author: mandliya

README.md

@@ -6,9 +6,9 @@
 
 | Current Status|     Stats     |
 | :------------: | :----------: |
-| Total Problems | 98 |
-| Current Streak | 69 days |
-| Longest Streak | 69 ( August 17, 2015 - October 24, 2015 ) |
+| Total Problems | 101 |
+| Current Streak | 70 days |
+| Longest Streak | 70 ( August 17, 2015 - October 25, 2015 ) |
 
 </center>
 
@@ -175,3 +175,6 @@ Include contains single header implementation of data structures and some algori
 |Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1 as one sorted array.You may assume that nums1 has enough space (size that is greater or equal to m + n) to hold additional elements from nums2. The number of elements initialized in nums1 and nums2 are m and n respectively.| [mergeArrays.cpp](leet_code_problems/mergeArrays.cpp)
 |Given an array of non-negative integers, you are initially positioned at the first index of the array. Each element in the array represents your maximum jump length at that position. Determine if you are able to reach the last index. For example: <ul><li>A = [2,3,1,1,4], return true.</li></ul><ul><li>A = [3,2,1,0,4], return false.</li></ul>| [jumpGame.cpp](leet_code_problems/jumpGame.cpp)|
 |Given a positive integer, return its corresponding column title as appear in an Excel sheet. For example 1 -> A, 2 -> B,...26 -> Z, 27 -> AA, 28 -> AB, ...705 -> AAC | [excelColSheetTitle.cpp](leet_code_problems/excelColSheetTitle.cpp)|
+|Given an array nums, write a function to move all 0's to the end of it while maintaining the relative order of the non-zero elements. For example, given nums = [0, 1, 0, 3, 12], after calling your function, nums should be [1, 3, 12, 0, 0].| [moveZeroes.cpp](leet_code_problems/moveZeroes.cpp)|
+|Given an array of integers, find if the array contains any duplicates. Function should return true if any value appears at least twice in the array, and it should return false if every element is distinct.| [containsDuplicate.cpp](leet_code_problems/containsDuplicate.cpp)|
+| Given a list, rotate the list to the right by k places, where k is non-negative. For example: <ul><li>Given 1->2->3->4->5->NULL and k = 2, return 4->5->1->2->3->NULL</li></ul>| [rotateList.cpp](leet_code_problems/rotateList.cpp)|

leet_code_problems/containsDuplicate.cpp

@@ -0,0 +1,43 @@
+/**
+ * Given an array of integers, find if the array contains any duplicates.
+ * Your function should return true if any value appears at least twice in the array,
+ * and it should return false if every element is distinct.
+ *
+ * Approach : sort and check for adjacent elements for duplicates.
+ *
+ */
+
+
+#include <iostream>
+#include <vector>
+#include <algorithm>
+
+
+bool containsDuplicate(std::vector<int>& nums) {
+	std::sort( nums.begin(), nums.end());
+	for ( size_t i = 1; i < nums.size(); ++i ) {
+		if ( nums[i-1] == nums[i] ) {
+			return true;
+		}
+	}
+	return false;
+}
+
+void printVect( std::vector<int> & vec ) {
+	std::cout << "VEC:";
+	for ( auto & i : vec ) {
+		std::cout << i << " ";
+	}
+	std::cout << std::endl;
+}
+
+int main() {
+	std::vector<int> vec1{ 1, 99, 99, 4, 8, 98, 96, 3, 5, 19, 23, 17, 84, 23 };
+	printVect(vec1);
+	if ( containsDuplicate(vec1) ) {
+		std::cout << "Above vector contains duplicates\n";
+	} else {
+		std::cout << "Above vector does not contain duplicates\n";
+	}
+	return 0;
+}

leet_code_problems/moveZeroes.cpp

@@ -0,0 +1,38 @@
+/**
+ * Given an array nums, write a function to move all 0's to the end of it while maintaining the relative order of the non-zero elements.
+ * For example, given nums = [0, 1, 0, 3, 12], after calling your function, nums should be [1, 3, 12, 0, 0].
+ *
+ * Approach: start putting all non zero elements from at the start, We will fill in all non zero elements in order.
+ */
+
+#include <iostream>
+#include <vector>
+#include <algorithm>
+
+void moveZeroes(std::vector<int>& nums) {
+	size_t j = 0;
+	for ( size_t i = 0; i < nums.size(); ++i ) {
+		if ( nums[i] != 0 ) {
+			std::swap(nums[i], nums[j]);
+			++j;
+		}
+	}
+}
+
+void printVec(std::vector<int> & vec) {
+	std::cout << "Vec:";
+	for( auto & v : vec ) {
+		std::cout << v << " ";
+	}
+	std::cout << std::endl;
+}
+
+int main() {
+	std::vector<int> nums{ 0, 1, 0, 3, 12 };
+	std::cout << "Before ";
+	printVec(nums);
+	moveZeroes(nums);
+	std::cout << "After ";
+	printVec(nums);
+	return 0;
+}

leet_code_problems/rotateList.cpp

@@ -0,0 +1,91 @@
+/**
+ * Given a list, rotate the list to the right by k places, where k is non-negative.
+ * For example:
+ * Given 1->2->3->4->5->NULL and k = 2,
+ * return 4->5->1->2->3->NULL
+ */
+
+#include <iostream>
+
+struct ListNode {
+	int val;
+	ListNode * next;
+	ListNode(int x) : val(x), next(NULL) {}
+};
+
+
+void printList(ListNode * node) {
+	std::cout << "List: ";
+	while( node ) {
+		std::cout << node->val << " ";
+		node = node->next;
+	}
+	std::cout << std::endl;
+}
+
+void insert(ListNode* &  head, int data ) {
+
+	ListNode * newNode = new ListNode(data);
+	if ( head == nullptr ) {
+		head = newNode;
+	} else {
+		ListNode * curr = head;
+		while ( curr->next != nullptr ) {
+			curr = curr->next;
+		}
+		curr->next = newNode;
+	}
+}
+
+int length(ListNode * head) {
+	int count = 0;
+	while( head ) {
+		head = head->next;
+		++count;
+	}
+	return count;
+}
+
+
+ListNode* rotateRight(ListNode* head, int k) {
+	if ( head == nullptr ||  head->next == nullptr) {
+		return head;
+	}
+	int len = length(head);
+	k = k % len;
+	if ( k == 0) {
+		return head;
+	}
+	ListNode * ptr1 = head;
+	ListNode * ptr2 = head;
+	int c = 0;
+	while( ptr1 && c < k ) {
+		ptr1 = ptr1->next;
+		c++;
+	}
+	if (!ptr1) {
+		return nullptr;
+	}
+	while( ptr1 && ptr1->next != nullptr ) {
+		ptr1 = ptr1->next;
+		ptr2 = ptr2->next;
+	}
+	ListNode * newHead = ptr2->next;
+	ptr2->next = nullptr;
+	ptr1->next = head;
+	return newHead;
+}
+
+
+int main() {
+	ListNode * head = nullptr;
+	insert( head, 1);
+	insert( head, 2);
+	insert( head, 3);
+	insert( head, 4);
+	insert( head, 5);
+	printList(head);
+	head = rotateRight(head, 2);
+	printList(head);
+	return 0;
+}