灯的个人博客

forever young,forever weeping.

0%

发表于 更新于 分类于

原来，有你陪着已经这么开心
房间里，没有你，这么空旷
一边流泪，一边收拾衣服的感觉确实不好
有点怀疑，自己为什么会劝你回到哪里
我果然是个傻逼

一直在身边的，才是最容易被忽视的。
有一天突然不见了。
原来是这么难受。

嗯。

有些不知所措

跟自己想的那种情况 不太一样

哭成了傻逼

我以为我能很平静的接受这件事

回到家里，看着熟悉的房间，总是感觉她在那里

还没有离开

一边写 一边哭

不写了

发表于 更新于 分类于

外观数列

题目

给定一个正整数 n ，输出外观数列的第 n 项。

「外观数列」是一个整数序列，从数字 1 开始，序列中的每一项都是对前一项的描述。

你可以将其视作是由递归公式定义的数字字符串序列：

  • countAndSay(1) = “1”
  • countAndSay(n) 是对 countAndSay(n-1) 的描述，然后转换成另一个数字字符串。
    前五项如下：
    1. 1
    2. 11
    3. 21
    4. 1211
    5. 111221

    第一项是数字 1

    描述前一项，这个数是 1 即 “ 一 个 1 ”，记作 “11”

    描述前一项，这个数是 11 即 “ 二 个 1 ” ，记作 “21”

    描述前一项，这个数是 21 即 “ 一 个 2 + 一 个 1 ” ，记作 “1211”

    描述前一项，这个数是 1211 即 “ 一 个 1 + 一 个 2 + 二 个 1 ” ，记作 “111221”

    要 描述 一个数字字符串，首先要将字符串分割为 最小 数量的组，每个组都由连续的最多 相同字符 组成。然后对于每个组，先描述字符的数量，然后描述字符，形成一个描述组。要将描述转换为数字字符串，先将每组中的字符数量用数字替换，再将所有描述组连接起来。
  • 示例 1：

输入：n = 1

输出：”1”

解释：这是一个基本样例。

  • 示例 2：

输入：n = 4

输出：”1211”

解释：

countAndSay(1) = “1”

countAndSay(2) = 读 “1” = 一 个 1 = “11”

countAndSay(3) = 读 “11” = 二 个 1 = “21”

countAndSay(4) = 读 “21” = 一 个 2 + 一 个 1 = “12” + “11” = “1211”

题解

  • 普通做法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    function countAndSay(n: number): string {
      const getNextNum = (num: string) => {
        let i = 0;
        let result = "";
        let counter = 1;
        while (i < num.length) {
          if (num[i] === num[i + 1]) {
            counter++;
          } else {
            result += `${counter}${num[i]}`;
            counter = 1;
          }
          i++;
        }
        return result;
      };
      let current = "1";
      for (let i = 1; i < n; i++) {
        current = getNextNum(current);
      }
      return current;
    }

  • 递归做法

    感觉性能会比较差

来源

发表于 更新于 分类于

实现 strStr() 函数。

题目

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串出现的第一个位置（下标从 0 开始）。如果不存在，则返回 -1 。

说明：

当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。

对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与 C 语言的 strstr() 以及 Java 的 indexOf() 定义相符。

  • 示例 1：

输入：haystack = “hello”, needle = “ll”
输出：2
示例 2：

输入：haystack = “aaaaa”, needle = “bba”
输出：-1
示例 3：

输入：haystack = “”, needle = “”
输出：0

提示：

  • 0 <= haystack.length, needle.length <= 5 * 104
  • haystack 和 needle 仅由小写英文字符组成

题解

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
// 不使用字符串原型方法
function strStr(haystack: string, needle: string): number {
  if (needle.length > haystack.length) {
    return -1;
  }
  if (!needle.length) {
    return 0;
  }
  for (let i = 0; i < haystack.length; i++) {
    if (haystack[i] !== needle[0]) {
      continue;
    }
    let temp = false;
    for (let j = 0; j < needle.length; j++) {
      if (haystack[j + i] !== needle[j]) {
        temp = false;
        break;
      }
      temp = true;
    }
    if (temp) {
      return i;
    }
  }
  return -1;
}
// 原生方法
function strStr(haystack: string, needle: string): number {
  return haystack.indexOf(needle);
}

来源

作者：力扣 (LeetCode)
链接：https://leetcode-cn.com/leetbook/read/top-interview-questions-easy/xnr003/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

发表于 更新于 分类于

验证回文数

题目

给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。

说明：本题中，我们将空字符串定义为有效的回文串。

  • 示例 1:

输入: “A man, a plan, a canal: Panama”
输出: true
解释：”amanaplanacanalpanama” 是回文串

  • 示例 2:

输入: “race a car”
输出: false
解释：”raceacar” 不是回文串

提示：

  • 1 <= s.length <= 2 * 105
  • 字符串 s 由 ASCII 字符组成

答案

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
function isPalindrome(s: string): boolean {
  let leftIndex = 0;
  let rightIndex = s.length - 1;
  const lowS = s.toLowerCase();
  const isSmaller = (s: string) =>
    (s.charCodeAt(0) >= 97 && s.charCodeAt(0) <= 122) ||
    (s.charCodeAt(0) >= 48 && s.charCodeAt(0) <= 57);
  while (leftIndex < rightIndex) {
    if (!isSmaller(lowS[leftIndex])) {
      leftIndex++;
      continue;
    }
    if (!isSmaller(lowS[rightIndex])) {
      rightIndex--;
      continue;
    }
    if (lowS[leftIndex] !== lowS[rightIndex]) {
      return false;
    } else {
      leftIndex++;
      rightIndex--;
    }
  }
  return true;
}

版权声明

发表于 更新于 分类于

有效的字母异位词

题目

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

示例 1:

输入: s = “anagram”, t = “nagaram”

输出: true

示例 2:

输入: s = “rat”, t = “car”

输出: false

提示:

1 <= s.length, t.length <= 5 * 104

s 和 t 仅包含小写字母

题解

  • 两个map比较字母数是否相同

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    function isAnagram(s: string, t: string): boolean {
      const strToMap = (s: string) => {
        const strMap = new Map<string, number>();
        for (let i = 0; i < s.length; i++) {
          strMap.set(s[i], (strMap.get(s[i]) || 0) + 1);
        }
        return strMap;
      };
      const sMap = strToMap(s);
      const tMap = strToMap(t);
      if (sMap.size !== tMap.size) {
        return false;
      }
      for (let i of sMap.keys()) {
        if (sMap.get(i) !== tMap.get(i)) {
          return false;
        }
      }
      return true;
    }

  • 便利第一个字符串为map，便利第二个字符串，如果第一个map有，就减去1，最后看smap的数字是否都是0

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    function isAnagram(s: string, t: string): boolean {
      const strToMap = (s: string) => {
        const strMap = new Map<string, number>();
        for (let i = 0; i < s.length; i++) {
          strMap.set(s[i], (strMap.get(s[i]) || 0) + 1);
        }
        return strMap;
      };
      const sMap = strToMap(s);
      for (let i = 0; i < t.length; i++) {
        if (!sMap.get(t[i])) {
          return false;
        }
        sMap.set(t[i], sMap.get(t[i])! - 1);
      }
      for (let [, v] of sMap) {
        if (v !== 0) {
          return false;
        }
      }
      return true;
    }

  • 排序后遍历

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    function isAnagram(s: string, t: string): boolean {
      if (s.length !== t.length) {
        return false;
      }
      const sArr = s.split("").sort();
      const tArr = t.split("").sort();
      for (let i = 0; i < sArr.length; i++) {
        if (sArr[i] !== tArr[i]) {
          return false;
        }
      }
      return true;
    }

  • 字符替换法，耗时比较长

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    function isAnagram(s: string, t: string): boolean {
      if (s.length !== t.length) {
        return false;
      }
      for (let i = 0; i < s.length; i++) {
        t = t.replace(s[i], "");
        console.log(t);
      }
      return !t.length;
    }

    来源

  • 作者：力扣 (LeetCode)

  • 链接：https://leetcode-cn.com/leetbook/read/top-interview-questions-easy/xn96us/

  • 来源：力扣（LeetCode）

  • 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

发表于 更新于 分类于

字符串中的第一个唯一字符

题目

给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。

示例：

1
2
3
返回 0

``` s = "loveleetcode"

返回 2

提示：你可以假定该字符串只包含小写字母。

题解

  • 双重循环遍历
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    function firstUniqChar(s: string): number {
      const strMap = new Map<string, number>();
      for (let i = 0; i < s.length; i++) {
        strMap.set(s[i], (strMap.get(s[i]) || 0) + 1);
      }
      for (let i = 0; i < s.length; i++) {
        if (strMap.get(s[i]) === 1) {
          return i;
        }
      }
      return -1;
    }
  • 索引一致方法
  • 如果找到的第一个索引与倒数找到的最后一个索引相同，代表是第一个
    1
    2
    3
    4
    5
    6
    7
    8
    function firstUniqChar(s: string): number {
      for (let i = 0; i < s.length; i++) {
        if (s.lastIndexOf(s[i]) === s.indexOf(s[i])) {
          return i;
        }
      }
      return -1;
    }

相关链接

发表于 更新于 分类于

题目

给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。

如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ，就返回 0。

假设环境不允许存储 64 位整数（有符号或无符号）。

示例 1：

1
2
输入：x = 123
输出：321

示例 2：

1
2
输入：x = -123
输出：-321

示例 3：

1
2
输入：x = 120
输出：21

示例 4：

1
2
输入：x = 0
输出：0

答案

1
2
3
4
5
6
7
8
9
10
11
12
/**
 *  字符串反转
 */
function reverse(x: number): number {
  const isPositive = x >= 0;
  const reverseNumberString = `${x}`.replace("-", "").split("").reverse().join("");
  const result = isPositive ? +reverseNumberString : -reverseNumberString;
  if (result <= (-2) ** 31 || result >= 2 ** 31 - 1) {
    return 0;
  }
  return result;
}

参考链接

发表于 更新于

啊，年轻时候的我，写的代码还挺规范的嘛。

原来以为那个项目已经挂掉了，没想到现在还在运行。

嗨，从16年开始学前端到现在。。快六年了。真特么快啊。。

擦，刚找自己写的第一个项目竟然没有备案，挂掉了卧槽。

没法装逼，可惜了。

年轻真好…

又想到了以前的很多事情，一个不到20平米的隔断间，住了四个人。

床上睡不下，把床掀了大家一起打地铺。

每天九点上班，五点九下班，下班就去网吧嗨。。

租了一个两室一厅的房子，一个月1200？三个月交一次房租，结果三个月到了，我们没钱交房租了，emmm，直到现在我都不敢一次性交三个月房租。。

啊，那时候是真穷啊。。

不过真的挺快乐。

几个吊毛，天天嗷嗷叫，一起看片，网吧通宵，真刺激

回不去了。。

还是有些对不住的人。。

一时间想起来，有点难过。

emmmm

做的那些事情有用吗。

二十岁的时候，买了十岁买不起的玩具，有什么意义吗

终归是让自己心里好过一点

好多事情，忍不住泪目

果然，晚上不适合瞎J8想。

发表于 更新于 分类于

nestjs 无法注入服务

问题发现

  • 在 viewService 里面导入 UserService,发现一直提示错误，没有找到可以注入的内容
  • 检查了一遍代码，确认逻辑代码没有问题
  • 怀疑是不是循环依赖了，检查代码，发现代码基本与其他 Moduel 的服务相同，没有出现循环依赖的情况
  • 打印 ModuleContainer，在当前 ViewModule 里面找到了导入的 UserModule，也存在 UserService

view.service.ts 尝试打印是否成功导入 UserModule

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
@Injectable()
export class ViewService {
  constructor(
    private modulesContainer: ModulesContainer,
    private userService: UserService,
    @InjectRepository(ViewEntity)
    private viewEntityRepository: Repository<ViewEntity>
  ) {
    [...modulesContainer.values()].map((module) => {
      if (module.metatype.name === "ViewModule") {
        console.log("=======imports=======");
        console.log(module.imports);
        console.log("=======providers======");
        console.log(module.providers);
        console.log("=======exports======");
        console.log(module.exports);

        console.log("\n\n\n\n\n");
        console.log("=======UserModule exports======");
        [...module.imports.values()].map((innerModule) => {
          if (innerModule.metatype.name === "UserModule") {
            console.log(innerModule.exports);
          }
        });
      }
    });
  }
}

view.module.ts

1
2
3
4
5
6
7
@Module({
  imports: [TypeOrmModule.forFeature([ViewEntity, ViewLikeStatEntity]), UserModule],
  controllers: [ViewController],
  providers: [ViewService],
  exports: [ViewService],
})
export class ViewModule {}

view.service.ts 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
export type ViewRelationType = "topic";
export interface JoinListInterface {
  uid: string;
  avatar: string;
  nickname: string;
  roler: number;
}
@Injectable()
export class ViewService {
  constructor(private readonly userService: UserService, @InjectRepository(ViewEntity) private readonly viewRepository: Repository<ViewEntity>) {}

  create(createViewDto: CreateViewDto) {
    return "This action adds a new view";
  }
  ...
}

控制台

1
2
3
4
5
6
7
8
[error] 2021-07-28 18:11:32.1 [ExceptionHandler] Nest can't resolve dependencies of the ViewService (?, ViewEntityRepository). Please make sure that the argument dependency at index [0] is available in the ViewModule context.

Potential solutions:
- If dependency is a provider, is it part of the current ViewModule?
- If dependency is exported from a separate @Module, is that module imported within ViewModule?
  @Module({
    imports: [ /* the Module containing dependency */ ]
  })

解决问题

  • 再次检查代码，发现 view.service.ts 导出了三个东西，一个 type，一个 interface，还有一个 viewService 服务
  • 全文查找导出的接口，发现在一个实体里面有这个类型的引入，就是 JoinListInterface.

topic.entity.ts

1
2
3
4
5
6
7
8
9
10
@Entity("topics", { schema: "42how" })
export class TopicEntity {
  @PrimaryGeneratedColumn({ type: "bigint", name: "id", unsigned: true })
  id: number;

  join: {
    count?: number;
    list?: JoinListInterface[];
  } = { count: 0, list: [] };
}

  • 尝试删除 JoinListInterface ，服务注入成功

  • 原本以为 ts 的 interface，type 是不参与到编译过后的 js 文件，检查编译后 topic.entity.js 文件，发现 const view_service_1 = require("../modules/view/view.service"); 这一句，虽然 interface 没有被使用，但是这个 js 文件被引入了。因为这个实体类被引入的比较多，产生了循环依赖，在 nestjs 进行注入的时候，这个文件导出是 undefined，查找不到服务，无法注入。

总结

  • ts 中 export 的类型文件应该单独定义，不要跟逻辑代码放在一个文件。
  • 类型文件虽然没有参与编译，但是会引入文件，如果引用的过于复杂，会导致循环依赖的情况
  • 感谢青木大佬的帮助

发表于 更新于 分类于

想在局域网内访问 wsl 端口

主要工作环境都在wsl里面，有时候想用真机调试，需要局域网访问

TODO
有空写吧