Adding solution of 92, 93 problems

Author: Garvit244

92.py

@@ -0,0 +1,47 @@
+'''
+	Reverse a linked list from position m to n. Do it in one-pass.
+
+	Note: 1 ≤ m ≤ n ≤ length of list.
+
+	Example:
+
+	Input: 1->2->3->4->5->NULL, m = 2, n = 4
+	Output: 1->4->3->2->5->NULL
+'''
+
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def reverseBetween(self, head, m, n):
+        """
+        :type head: ListNode
+        :type m: int
+        :type n: int
+        :rtype: ListNode
+        """
+        if m == n :
+        	return head
+
+        result = ListNode(0)
+        result.next = head
+
+        prev = result
+
+        for index in range(m-1):
+        	prev = prev.next
+
+        reverse = None
+        curr = prev.next
+        for i in range(n-m+1):
+        	temp = curr.next
+        	curr.next = reverse
+        	reverse = curr
+        	curr = temp
+
+        prev.next.next = curr
+        prev.next = reverse
+        return result.next

93.py

@@ -0,0 +1,34 @@
+'''
+    Given a string containing only digits, restore it by returning all possible valid IP address combinations.
+
+    Example:
+
+    Input: "25525511135"
+    Output: ["255.255.11.135", "255.255.111.35"]
+'''
+
+class Solution(object):
+    def restoreIpAddresses(self, s):
+        """
+        :type s: str
+        :rtype: List[str]
+        """
+        result = []
+
+        def dfs(s, temp, count):
+            if count == 4:
+                if not s:
+                    result.append(temp[:-1])
+                    return
+
+            for index in range(1, 4):
+                if index <= len(s):
+                    if index == 1:
+                        dfs(s[index:], temp + s[:index] + ".", count+1)
+                    elif index ==2 and s[0] != '0':
+                        dfs(s[index:], temp + s[:index] + ".", count+1)
+                    elif index == 3 and s[0] != '0' and int(s[:3]) <= 255:
+                        dfs(s[index:], temp + s[:index] + ".", count+1)
+
+        dfs(s, "", 0)
+        return result