ARTS打卡：第二十周

发表于 | 分类于 | 本文总阅读量 次

ARTS打卡：第二十周

每周完成一个ARTS：

  1. Algorithm：每周至少做一个 leetcode 的算法题
  2. Review：阅读并点评至少一篇英文技术文章
  3. Tip：学习至少一个技术技巧
  4. Share：分享一篇有观点和思考的技术文章

Algorithm

38. 报数

报数序列是一个整数序列，按照其中的整数的顺序进行报数，得到下一个数。其前五项如下：

1
2
3
4
5
1.     1
2.     11
3.     21
4.     1211
5.     111221

1 被读作 "one 1" ("一个一") , 即 11。
11 被读作 "two 1s" ("两个一"）, 即 21。
21 被读作 "one 2", "one 1" （"一个二" , "一个一"), 即 1211。

给定一个正整数 n（1 ≤ n ≤ 30），输出报数序列的第 n 项。

注意：整数顺序将表示为一个字符串。

示例 1:

1
2
输入: 1
输出: "1"

示例 2:

1
2
输入: 4
输出: "1211"

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/count-and-say

解题思路

这道题其实并不难，只要理解了题目的意思，这道题就很容易解出来了。

仔细阅读题目，你会发现从报数序列1开始，往后的序列，都是基于上一个报数序列来得出结果的；报数结果可以拆分两个数，一个是要报的数字，假设为：say，一个是要报数的个数，假设为 count，比如说1 被读作 "one 1" ("一个一")，那么 say = 1，count = 1，以此类推即可。

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
class Solution {
    public String countAndSay(int n) {
        // 边界条件，当序列为1时，直接返回结果“1”
        if (n == 1) {
            return "1";
        }
        // 初始化序列
        StringBuilder currSequence = new StringBuilder("1");
        for (int i = 1; i < n; i++) {
            // 初始化个数
            int count = 1;
            // 要报数的序列
            char[] sequence = currSequence.toString().toCharArray();
            // 重置结果序列
            currSequence = new StringBuilder();
            // 遍历要进行报数的序列，逐一报数
            for (int j = 0; j < sequence.length; j++) {
                // sequence[j] 可以看做是要报的数
                // 报数完毕
                if (j == sequence.length - 1) {
                    currSequence.append(count).append(sequence[j]);
                    break;
                }
                // 下一个要报的数，与当前报的数一样，数量 count+1
                // 比如 11 ，say 为 1，count 为 2
                if (sequence[j] == sequence[j + 1]) {
                    ++count;
                } else {
                    // 报下一个数
                    currSequence.append(count).append(sequence[j]);
                    // 重置要报的数的个数
                    count = 1;
                }
            }
        }
        return currSequence.toString();
    }    
}

执行结果：

执行用时 :3 ms, 在所有 Java 提交中击败了94.08%的用户

内存消耗 :34.9 MB, 在所有 Java 提交中击败了85.08%的用户

Review

这周分享：《Java Memory Management》

作者在文中深入的介绍了 Java的 内存管理机制，大致可以概括为以下几点：

  1. 介绍了Java 内存通常可分为 堆栈（Stack）和 堆（Heap）两块，且分别进行了说明
  2. 介绍了堆中对象引用的类型，可分为强引用（Strong Reference）、弱引用（Weak Reference）、软引用（Soft Reference）、幻想引用（Phantom Reference）。
  3. 结合图文，详细的说明了垃圾回收的过程。
  4. 介绍了垃圾收集器的类型，可分为：
    1. 串行化GC（Serial GC）：一个单线程垃圾收集器，适用于数据量小的小型应用。启用选项：-XX:+UseSerialGC
    2. 并行化GC（Parallel GC）：与 Serial GC 最大的区别在于 Parallel GC 是多线程进行垃圾回收的。启用选项：-XX:+UseParallelGC
    3. 高并发GC（ Mostly concurrent GC），主要分为以下两种：
      1. Garbage First：具有高吞吐量和合理的应用程序暂停时间。启用选项：-XX:+UseG1GC
      2. Concurrent Mark Sweep：应用程序暂停时间保持在最小值。可以通过指定选项：-XX:+UseConcMarkSweepGC来使用它。JDK9开始，这种GC类型被声明为deprecated，不再推荐使用。

Tip

这周分享一些 Linux 命令：

  1. ulimit -n：查看系统默认的最大文件句柄数，系统默认是1024
  2. lsof -n|awk '{print $2}'|sort|uniq -c|sort -nr|more：查看当前进程打开了多少句柄数
  3. ulimit -HSn 4096：以root用户运行，H指定了硬性大小，S指定了软性大小，n表示设定单个进程最大的打开文件句柄数量。
  4. 设定句柄数量后，系统重启后，又会恢复默认值。如果想永久保存下来，可以修改.bash_profile文件，可以修改 /etc/profile 把上面命令加到最后。

应用场景：解决Linux系统报出 “too many open files” 的错误。

参考链接：

https://blog.csdn.net/lastsweetop/article/details/6440136

https://blog.csdn.net/lck5602/article/details/79670147

Share

本周继续分享simviso团队带来的优质翻译学习视频：《国外精选翻译课程之编译原理入门》