rearrage string problem

Author: Narahari-Sundaragopalan

exercises/linkedlist/checkPalindromeLinkedList.js

@@ -1,4 +1,19 @@
-// Implement a function to check if a linked list is a palindrome.
+/**
+ * Given a singly linked list, determine if it is a palindrome.
+
+Example 1:
+
+Input: 1->2
+Output: false
+Example 2:
+
+Input: 1->2->2->1
+Output: true
+Follow up:
+Could you do it in O(n) time and O(1) space?
+ * @param {LinkedList} list 
+ * @return {boolean}
+ */
 
 function checkPalindrome(list) {
   // Find the midpoint of the linked list
@@ -42,3 +57,39 @@ function reverseList(node) {
 
   return previous;
 }
+
+/**
+ * Time Complexity: O(N)
+ * Space Complexity: O(1)
+ */
+
+// Approach 2
+const checkPalindrome = list => {
+	if (!list.head) {
+		return false;
+	}
+
+	const arrayList = [];
+	let node = list.head;
+	while (node) {
+		arrayList.push(node.val);
+		node = node.next;
+	}
+
+	let start = 0, end = arrayList.length - 1;
+
+	while (start <= end) {
+		if (arrayList[start] !== arrayList[end]) {
+			return false;
+		}
+		start++;
+		end--;
+	}
+
+	return true;
+}
+
+/**
+ * Time Complexity: O(N)
+ * Space Complexity: O(N)
+ */

exercises/linkedlist/hasCycle.js

@@ -0,0 +1,50 @@
+/**
+ * Given a linked list, determine if it has a cycle in it.
+
+To represent a cycle in the given linked list, we use an integer pos which represents the position (0-indexed) in the linked list where tail connects to. If pos is -1, then there is no cycle in the linked list.
+
+ 
+
+Example 1:
+
+Input: head = [3,2,0,-4], pos = 1
+Output: true
+Explanation: There is a cycle in the linked list, where tail connects to the second node.
+
+Input: head = [1,2], pos = 0
+Output: true
+Explanation: There is a cycle in the linked list, where tail connects to the first node.
+
+Input: head = [1], pos = -1
+Output: false
+Explanation: There is no cycle in the linked list.
+
+function ListNode(val) {
+	this.val = val;
+	this.next = null;
+}
+@param {ListNode} (head)
+@return {boolean}
+ */
+const hasCycle = head => {
+	if (!head || !head.next) {
+		return false;
+	}
+
+	let slow = head;
+	let fast = head.next;
+
+	while (slow !== fast) {
+		if (fast === null || fast.next === null) {
+			return false;
+		}
+		slow = slow.next;
+		fast = fast.next.next;
+	}
+
+	return true;
+}
+/**
+ * Time Complexity: O(N)
+ * Space Complexity: O(1)
+ */

exercises/linkedlist/intersectionLinkedList.js

@@ -8,4 +8,8 @@ const getIntersectionNode = (headA, headB) => {
 	}
 
 	return (ptrA === ptrB && ptrA !== null) ? ptrA : null;
-}
+}
+/**
+ * Time Complexity: O (m + n);
+ * Space Complexity: O(1)
+ */

exercises/strings/rearrangeString.js

@@ -0,0 +1,31 @@
+/**
+ * Given a string with lowercase, uppercase and numbers, rearrange it so that uppercase letters are first, 
+ * then lowercase and then numbers. It should maintain the original order.
+
+Input- "cdBnC52c" output - "BCcdnc52"
+Input - "123abA" output - "Aab123"
+
+Rearrange it in o(n) in one pass without using extra space.
+ */
+
+const rearrangeString = str => {
+	let lower = '';
+	let upper = '';
+	let num = '';
+
+	let index = 0;
+
+	while (index < str.length) {
+		if (!isNaN(str[index] * 1)) {
+			num = num + str[index];
+		} else if (str[index] == str[index].toUpperCase()) {
+			upper += str[index];
+		} else if (str[index] == str[index].toLowerCase()) {
+			lower += str[index];
+		}
+
+		index++;
+	}
+
+	return upper + lower + num;
+}