update at 2019-02-18

Author: bonfy

024-swap-nodes-in-pairs/swap-nodes-in-pairs.py

@@ -3,16 +3,14 @@
 
 # Given a linked list, swap every two adjacent nodes and return its head.
 #
-# Example:
-#
+# You may not modify the values in the list's nodes, only nodes itself may be changed.
 #
-# Given 1->2->3->4, you should return the list as 2->1->4->3.
+#  
 #
-# Note:
+# Example:
 #
 #
-# 	Your algorithm should use only constant extra space.
-# 	You may not modify the values in the list's nodes, only nodes itself may be changed.
+# Given 1->2->3->4, you should return the list as 2->1->4->3.
 #
 #
 

071-simplify-path/simplify-path.py

@@ -1,23 +1,57 @@
 # -*- coding:utf-8 -*-
 
 
-# Given an absolute path for a file (Unix-style), simplify it. 
+# Given an absolute path for a file (Unix-style), simplify it. Or in other words, convert it to the canonical path.
 #
-# For example,
-# path = "/home/", => "/home"
-# path = "/a/./b/../../c/", => "/c"
-# path = "/a/../../b/../c//.//", => "/c"
-# path = "/a//b////c/d//././/..", => "/a/b/c"
+# In a UNIX-style file system, a period . refers to the current directory. Furthermore, a double period .. moves the directory up a level. For more information, see: Absolute path vs relative path in Linux/Unix
 #
-# In a UNIX-style file system, a period ('.') refers to the current directory, so it can be ignored in a simplified path. Additionally, a double period ("..") moves up a directory, so it cancels out whatever the last directory was. For more information, look here: https://en.wikipedia.org/wiki/Path_(computing)#Unix_style
+# Note that the returned canonical path must always begin with a slash /, and there must be only a single slash / between two directory names. The last directory name (if it exists) must not end with a trailing /. Also, the canonical path must be the shortest string representing the absolute path.
 #
-# Corner Cases:
+#  
 #
+# Example 1:
 #
-# 	Did you consider the case where path = "/../"?
-# 	In this case, you should return "/".
-# 	Another corner case is the path might contain multiple slashes '/' together, such as "/home//foo/".
-# 	In this case, you should ignore redundant slashes and return "/home/foo".
+#
+# Input: "/home/"
+# Output: "/home"
+# Explanation: Note that there is no trailing slash after the last directory name.
+#
+#
+# Example 2:
+#
+#
+# Input: "/../"
+# Output: "/"
+# Explanation: Going one level up from the root directory is a no-op, as the root level is the highest level you can go.
+#
+#
+# Example 3:
+#
+#
+# Input: "/home//foo/"
+# Output: "/home/foo"
+# Explanation: In the canonical path, multiple consecutive slashes are replaced by a single one.
+#
+#
+# Example 4:
+#
+#
+# Input: "/a/./b/../../c/"
+# Output: "/c"
+#
+#
+# Example 5:
+#
+#
+# Input: "/a/../../b/../c//.//"
+# Output: "/c"
+#
+#
+# Example 6:
+#
+#
+# Input: "/a//b////c/d//././/.."
+# Output: "/a/b/c"
 #
 #
 

237-delete-node-in-a-linked-list/delete-node-in-a-linked-list.py

@@ -6,27 +6,27 @@
 # Given linked list -- head = [4,5,1,9], which looks like following:
 #
 #
-#     4 -> 5 -> 1 -> 9
 #
+#  
 #
 # Example 1:
 #
 #
 # Input: head = [4,5,1,9], node = 5
 # Output: [4,1,9]
-# Explanation: You are given the second node with value 5, the linked list
-#              should become 4 -> 1 -> 9 after calling your function.
+# Explanation: You are given the second node with value 5, the linked list should become 4 -> 1 -> 9 after calling your function.
 #
 #
 # Example 2:
 #
 #
 # Input: head = [4,5,1,9], node = 1
 # Output: [4,5,9]
-# Explanation: You are given the third node with value 1, the linked list
-#              should become 4 -> 5 -> 9 after calling your function.
+# Explanation: You are given the third node with value 1, the linked list should become 4 -> 5 -> 9 after calling your function.
 #
 #
+#  
+#
 # Note:
 #
 #

526-beautiful-arrangement/beautiful-arrangement.py

@@ -1,36 +1,46 @@
 # -*- coding:utf-8 -*-
 
 
-#
 # Suppose you have N integers from 1 to N. We define a beautiful arrangement as an array that is constructed by these N numbers successfully if one of the following is true for the ith position (1 <= i <= N) in this array:
 #
-# The number at the ith position is divisible by i.
-# i is divisible by the number at the ith position.
 #
+# 	The number at the ith position is divisible by i.
+# 	i is divisible by the number at the ith position.
 #
 #
+#  
 #
 # Now given N, how many beautiful arrangements can you construct?
 #
-#
 # Example 1:
 #
+#
 # Input: 2
 # Output: 2
 # Explanation: 
+#
 # The first beautiful arrangement is [1, 2]:
+#
 # Number at the 1st position (i=1) is 1, and 1 is divisible by i (i=1).
+#
 # Number at the 2nd position (i=2) is 2, and 2 is divisible by i (i=2).
+#
 # The second beautiful arrangement is [2, 1]:
+#
 # Number at the 1st position (i=1) is 2, and 2 is divisible by i (i=1).
+#
 # Number at the 2nd position (i=2) is 1, and i (i=2) is divisible by 1.
 #
 #
+#  
 #
 # Note:
 #
-# N is a positive integer and will not exceed 15.
 #
+# 	N is a positive integer and will not exceed 15.
+#
+#
+#  
 #