# 【Leetcode 做题学算法周刊】第九期

mcchen

• 题目分析设想
• 编写代码验证
• 查阅他人解法
• 思考总结

## Easy

### 171.Excel表列序号

#### 题目描述

``````    A -> 1
B -> 2
C -> 3
...
Z -> 26
AA -> 27
AB -> 28
...``````

``````输入: "A"

#### 编写代码验证

Ⅰ.正序转换

``````/**
* @param {string} s
* @return {number}
*/
var titleToNumber = function(s) {
let res = 0
for(let i = 0; i < s.length; i++) {
res = res * 26 + (s.charCodeAt(i) - 'A'.charCodeAt() + 1)
}
return res
};``````

• 1000/1000 cases passed (84 ms)
• Your runtime beats 69.77 % of javascript submissions
• Your memory usage beats 33.33 % of javascript submissions (36.1 MB)
• 时间复杂度： `O(n)`

Ⅱ.倒序转换

``````/**
* @param {string} s
* @return {number}
*/
var titleToNumber = function(s) {
let res = 0
let mul = 1
for(let i = s.length - 1; i >= 0; i--) {
res += (s.charCodeAt(i) - 'A'.charCodeAt() + 1) * mul
mul *= 26
}
return res
};``````

• 1000/1000 cases passed (100 ms)
• Your runtime beats 20.5 % of javascript submissions
• Your memory usage beats 100 % of javascript submissions (34.7 MB)
• 时间复杂度： `O(n)`

### 172.阶乘后的零

#### 题目描述

``````输入: 3

#### 编写代码验证

Ⅰ.累加5的每个幂的个数

``````/**
* @param {number} n
* @return {number}
*/
var trailingZeroes = function(n) {
let res = 0
while (n) {
n = n / 5 | 0
res += n
}
return res
};``````

• 502/502 cases passed (76 ms)
• Your runtime beats 55.62 % of javascript submissions
• Your memory usage beats 100 % of javascript submissions (34.5 MB)
• 时间复杂度： `O(log(n))`

``````/**
* @param {number} n
* @return {number}
*/
var trailingZeroes = function(n) {
let res = 0
let num = 5
while (n >= num) {
res += n / num | 0
num *= 5
}
return res
};``````

• 502/502 cases passed (76 ms)
• Your runtime beats 55.62 % of javascript submissions
• Your memory usage beats 100 % of javascript submissions (34.3 MB)
• 时间复杂度： `O(log(n))`

#### 查阅他人解法

Ⅰ.枚举

``````/**
* @param {number} n
* @return {number}
*/
var trailingZeroes = function(n) {
return (n/5 | 0)+(n/25 | 0)+(n/125 | 0)+(n/625 | 0)+(n/3125 | 0)+(n/15625 | 0)+(n/78125 | 0)+(n/390625 | 0)
+(n/1953125 | 0)+(n/9765625 | 0)+(n/48828125 | 0)+(n/244140625 | 0)+(n/1220703125 | 0);
};``````

• 502/502 cases passed (80 ms)
• Your runtime beats 37.95 % of javascript submissions
• Your memory usage beats 100 % of javascript submissions (34.4 MB)
• 时间复杂度： `O(log(n))`

### 190.颠倒二进制位

#### 题目描述

``````输入: 00000010100101000001111010011100

因此返回 964176192，其二进制表示形式为 00111001011110000010100101000000。

因此返回 3221225471 其二进制表示形式为 10111111111111111111111111111111 。``````

• 请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。
• 在 Java 中，编译器使用二进制补码记法来表示有符号整数。因此，在上面的 示例 2 中，输入表示有符号整数 -3，输出表示有符号整数 -1073741825。

#### 编写代码验证

Ⅰ.位运算

``````/**
* @param {number} n - a positive integer
* @return {number} - a positive integer
*/
var reverseBits = function(n) {
let t = 32, r = 0;
while(t--) {
r = (r << 1) + (n & 1); // 输出结果左移并加上最后一位
n >>= 1 // 待处理数字右移
}
return r >>> 0;
};``````

• 600/600 cases passed (100 ms)
• Your runtime beats 49.62 % of javascript submissions
• Your memory usage beats 70.65 % of javascript submissions (39.4 MB)
• 时间复杂度： `O(1)`

Ⅱ.字符串处理

``````/**
* @param {number} n - a positive integer
* @return {number} - a positive integer
*/
var reverseBits = function(n) {
return parseInt(
2
)
};``````

• 600/600 cases passed (104 ms)
• Your runtime beats 33.27 % of javascript submissions
• Your memory usage beats 88.8 % of javascript submissions (39.1 MB)
• 时间复杂度： `O(1)`

#### 查阅他人解法

Ⅰ.位移+换位

``````/**
* @param {number} n - a positive integer
* @return {number} - a positive integer
*/
var reverseBits = function(n) {
let t = 32, r = 0;
while(t--) {
r = (r << 1) | (n & 1); // 输出结果左移并末位替换
n >>= 1 // 待处理数字右移
}
return r >>> 0;
};``````

• 600/600 cases passed (96 ms)
• Your runtime beats 61.41 % of javascript submissions
• Your memory usage beats 91.5 % of javascript submissions (39 MB)
• 时间复杂度： `O(1)`

### 191.位1的个数

#### 题目描述

``````输入：00000000000000000000000000001011

• 请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。
• 在 Java 中，编译器使用二进制补码记法来表示有符号整数。因此，在上面的 示例 2 中，输入表示有符号整数 -3，输出表示有符号整数 -1073741825。

#### 编写代码验证

Ⅰ.位运算

``````/**
* @param {number} n - a positive integer
* @return {number}
*/
var hammingWeight = function(n) {
let t = 32, r = 0;
while(t--) {
if (n & 1 === 1) r++; // 判断最后一位
n >>= 1 // 待处理数字右移
}
return r;
};``````

• 601/601 cases passed (88 ms)
• Your runtime beats 84.03 % of javascript submissions
• Your memory usage beats 91.49 % of javascript submissions (38.8 MB)
• 时间复杂度： `O(1)`

Ⅱ.字符串处理

``````/**
* @param {number} n - a positive integer
* @return {number}
*/
var hammingWeight = function(n) {
return n.toString(2).replaceAll('0', '').length
};``````

• 601/601 cases passed (92 ms)
• Your runtime beats 68.73 % of javascript submissions
• Your memory usage beats 88.54 % of javascript submissions (38.9 MB)
• 时间复杂度： `O(1)`

#### 查阅他人解法

Ⅰ.位运算-1左移

``````/**
* @param {number} n - a positive integer
* @return {number} - a positive integer
*/
var reverseBits = function(n) {
let t = 32, r = 0;
while(t--) {
if ((n & (1 << (32 - t))) != 0) {
r++;
}
}
return r;
};``````

• 601/601 cases passed (104 ms)
• Your runtime beats 21.48 % of javascript submissions
• Your memory usage beats 82.75 % of javascript submissions (39 MB)
• 时间复杂度： `O(1)`

### 198.打家劫舍

#### 题目描述

``````输入：[1,2,3,1]

偷窃到的最高金额 = 1 + 3 = 4 。

偷窃到的最高金额 = 2 + 9 + 1 = 12 。``````

• 0 <= nums.length <= 100
• 0 <= nums[i] <= 400

#### 编写代码验证

Ⅰ.分别求和

``````/**
* @param {number[]} nums
* @return {number}
*/
var rob = function(nums) {
let evenTotal = 0, oddTotal = 0;
for(let i = 0; i < nums.length; i++) {
if (i & 1) {
evenTotal += nums[i]
evenTotal = Math.max(evenTotal, oddTotal) // 取两种方式的更大值
} else {
oddTotal += nums[i]
oddTotal = Math.max(evenTotal, oddTotal) // 取两种方式的更大值
}
}
return Math.max(evenTotal, oddTotal)
};``````

• 69/69 cases passed (84 ms)
• Your runtime beats 53.82 % of javascript submissions
• Your memory usage beats 61.74 % of javascript submissions (37.6 MB)
• 时间复杂度： `O(n)`

Ⅱ.动态规划

``````/**
* @param {number[]} nums
* @return {number}
*/
var rob = function(nums) {
const len = nums.length;
if (len === 0) return 0
if (len === 1) return nums[0]
if (len === 2) return Math.max(nums[0], nums[1])
// dp[i] 表示偷i+1间的最大收益
let dp = [nums[0], Math.max(nums[0], nums[1])]
for(let i = 2; i < len; i++) {
dp[i] = Math.max(dp[i-1], dp[i-2] + nums[i])
}
return dp[nums.length - 1]
};``````

• 69/69 cases passed (72 ms)
• Your runtime beats 95.68 % of javascript submissions
• Your memory usage beats 26.94 % of javascript submissions (37.9 MB)
• 时间复杂度： `O(n)`

#### 思考总结

（完）

(转载请注明出处：https://chenjiahao.xyz)

492 声望
16 粉丝