feat: update solutions to lcof questions

更新剑指 Offer 题解描述

Author: yanglbme

lcof/面试题58 - I. 翻转单词顺序/README.md

@@ -37,6 +37,8 @@
 **注意：** 此题对比原题有改动
 
 ## 解法
+按空格分割字符串后逆序。
+
 ### Python3
 ```python
 class Solution:

lcof/面试题60. n个骰子的点数/README.md

@@ -32,15 +32,15 @@
 
 假设 `dp[i][j]` 表示扔 i 个骰子，出现点数之和 j 的次数。n 个骰子，所以 i 的范围在 `1~n`，j 的范围在 `[1, 6n]`。
 
-单看第 n 枚骰子，它的点数可能为 `1,2,3,...,6`，因此扔完 n 枚骰子后点数之和 j 出现的次数，可以由扔完 n-1 枚骰子后，对应点数 j−1,j−2,j−3,...,j−6 出现的次数之和转化过来。即：
+单看第 n 枚骰子，它的点数可能为 `1,2,3,...,6`，因此扔完 n 枚骰子后点数之和 j 出现的次数，可以由扔完 n-1 枚骰子后，对应点数 `j−1,j−2,j−3,...,j−6` 出现的次数之和转化过来。即：
 
 ```
 for (第n枚骰子的点数 i = 1; i <= 6; i ++) {
     dp[n][j] += dp[n-1][j - i]
 }
 ```
 
-扔 1 枚骰子，点数可能是 1,2,3,4,5,6，且每个点数出现的次数均为 1。所以初始化如下：
+扔 1 枚骰子，点数可能是 `1,2,3,4,5,6`，且每个点数出现的次数均为 1。所以初始化如下：
 
 ```
 for (int j = 1; j <= 6; ++j) {

lcof/面试题64. 求1+2+…+n/README.md

@@ -22,6 +22,8 @@
 - `1 <= n <= 10000`
 
 ## 解法
+递归，结合**逻辑与**短路运算符求解。
+
 ### Python3
 ```python
 class Solution:

lcof/面试题65. 不用加减乘除做加法/README.md

@@ -18,11 +18,13 @@
 
 ## 解法
 <!-- 这里可写通用的实现逻辑 -->
-对两数进行 `^` 异或运算，得到不进位的和；对两数进行 `&` 与运算，得到进位。循环，直至进位为 0。
+- 对两数进行按位 `^` 异或运算，得到不进位的和；
+- 对两数进行按位 `&` 与运算，然后左移一位，得到进位；
+- 循环，直至进位为 0。
 
 ### Python3
 <!-- 这里可写当前语言的特殊实现逻辑 -->
-由于 python int 是无限长整型，左移不会自动溢出，因此需要特殊处理。
+由于 python `int` 是无限长整型，左移不会自动溢出，因此需要特殊处理。
 
 ```python
 class Solution:

lcof/面试题68 - II. 二叉树的最近公共祖先/README.md

@@ -52,11 +52,7 @@ class Solution:
             return root
         left = self.lowestCommonAncestor(root.left, p, q)
         right = self.lowestCommonAncestor(root.right, p, q)
-        if left is None:
-            return right
-        if right is None:
-            return left
-        return root
+        return right if left is None else (left if right is None else root)
 ```
 
 ### Java

lcof/面试题68 - II. 二叉树的最近公共祖先/Solution.py

@@ -5,15 +5,10 @@
 #         self.left = None
 #         self.right = None
 
-
 class Solution:
     def lowestCommonAncestor(self, root: TreeNode, p: TreeNode, q: TreeNode) -> TreeNode:
         if root is None or root == p or root == q:
             return root
         left = self.lowestCommonAncestor(root.left, p, q)
         right = self.lowestCommonAncestor(root.right, p, q)
-        if left is None:
-            return right
-        if right is None:
-            return left
-        return root
+        return right if left is None else (left if right is None else root)