@@ -0,0 +1,22 @@
+class Solution:
+def reverseList(self, head):
+prev = None
+cur = head
+
+while cur:
+temp = cur.next
+cur.next = prev
+prev = cur
+cur = temp
+
+return prev
+
+class Solution2:
+def reverseList(self, head):
+if not head or not head.next: return head
+
+reversed_node = self.reverseList(head.next)
+head.next.next = head
+head.next = None
+
+return reversed_node

@@ -0,0 +1,28 @@
+class Solution:
+def reverseBetween(self, head, m, n):
+if m == n: return head
+
+prev = None
+cur = head
+for _ in range(m-1):
+prev = cur
+cur = cur.next
+
+last_node_left_part = prev
+last_node_sub_list = cur
+
+next_node = None
+for _ in range(n-m+1):
+next_node = cur.next
+cur.next = prev
+prev = cur
+cur = next_node
+
+if last_node_left_part:
+last_node_left_part.next = prev
+else:
+head = prev
+
+last_node_sub_list.next = cur
+
+return head

@@ -0,0 +1,33 @@
+class Solution:
+def reverseKGroup(self, head, k):
+if not head or not head.next or k == 1: return head
+
+n = 0
+cur = head
+while cur:
+n += 1
+cur = cur.next
+
+prev = None
+next = None
+newHead = None
+t1 = None
+t2 = head
+cur = head
+
+while (n >= k):
+for _ in range(k):
+next = cur.next
+cur.next = prev
+prev = cur
+cur = next
+
+if not newHead: newHead = prev
+if t1: t1.next = prev
+t2.next = cur
+t1 = t2
+t2 = cur
+prev = None
+n -= k
+
+return newHead

@@ -0,0 +1,22 @@
+import random
+
+class Solution:
+
+def __init__(self, nums):
+self.original = nums
+
+def reset(self):
+"""
+Resets the array to its original configuration and return it.
+"""
+return self.original
+
+def shuffle(self):
+"""
+Returns a random shuffling of the array.
+"""
+arr = self.original.copy()
+for i in range(len(arr)):
+swap_idx = random.randrange(i, len(arr))
+arr[i], arr[swap_idx] = arr[swap_idx], arr[i]
+return arr

@@ -0,0 +1,36 @@
+class Node:
+def __init__(self, val, min):
+self.val = val
+self.min = min
+
+class MinStack:
+
+def __init__(self):
+"""
+initialize your data structure here.
+"""
+self.data = []
+
+
+def push(self, x: int) -> None:
+if len(self.data) == 0:
+self.data.append(Node(x, x))
+else:
+top = self.top_node()
+
+if x < top.min:
+self.data.append(Node(x, x))
+else:
+self.data.append(Node(x, top.min))
+
+def pop(self) -> None:
+self.data.pop().val
+
+def top(self) -> int:
+return self.top_node().val
+
+def top_node(self):
+return self.data[len(self.data)-1]
+
+def getMin(self) -> int:
+return self.top_node().min

@@ -0,0 +1,15 @@
+class Solution:
+def fizzBuzz(self, n: int):
+res = []
+
+for num in range(1, n+1):
+if num % 15 == 0:
+res.append("FizzBuzz")
+elif num % 3 == 0:
+res.append("Fizz")
+elif num % 5 == 0:
+res.append("Buzz")
+else:
+res.append(str(num))
+
+return res

@@ -0,0 +1,19 @@
+class Solution:
+def countPrimes(self, n: int) -> int:
+if n < 2: return 0
+
+count = 0
+arr = [True for _ in range(n)]
+arr[0] = arr[1] = False
+p = 2
+
+while p * p < n:
+if arr[p]:
+for i in range(p*p, n, p):
+arr[i] = False
+p += 1
+
+for val in arr:
+if val: count += 1
+
+return count

@@ -0,0 +1,4 @@
+class Solution:
+def isPowerOfThree(self, n: int) -> bool:
+maxPowerOfThree = 1162261467
+return n > 0 and maxPowerOfThree % n == 0

@@ -0,0 +1,17 @@
+class Solution:
+def romanToInt(self, s: str) -> int:
+mapping = {'I': 1,'V': 5,'X': 10,'L': 50,'C': 100,'D': 500,'M': 1000}
+prev = 0
+cur = 0
+total = 0
+
+for char in s[::-1]:
+cur = mapping[char]
+if prev > cur:
+total -= cur
+else:
+total += cur
+prev = cur
+
+return total
+