DEV Community: IQIUM

VScode 模块调试

IQIUM — Thu, 19 Jan 2023 08:55:27 +0000

背景

当我在一个python项目中的时候，每次想要运行这个train.py代码，但是有的项目用的相对路径，这个时候就很难处理（除非把所有的相对路径改成绝对路径）

解决方法

由于vscode的调试机制采用的是：在当前文件夹下处理，也就是工作目录（就是我们用vscode 打开的哪个文件夹），那么一个处理方式就是打开两个工作区

安装 ctrl + shift + p, 输入命令add folder to workspace，选择需要的目录
修改launch.json 文件进行模块调试

Mamba usage

IQIUM — Thu, 19 Jan 2023 05:58:48 +0000

问题/背景

最近在使用conda 安装pytorch，使用的是pytorch官网的安装命令，但是安装很慢，然后也尝试了安装清华镜像，但还是很慢

解决方法

安装 mamba 工具，这个工具在conda安装的基础上进行了提升，可以快速安装conda 库，介绍网址mamba

使用网址：Conda太慢？试试这个加速工具

Install fish shell on Ubuntu-22.04

IQIUM — Mon, 01 Aug 2022 07:20:00 +0000

What is fish?

Fish shell is a terminal shell. It has many features to help developers improve coding and skills.

How to install?

First Step: add repository

sudo apt-add-repository ppa:fish-shell/release-3

Second: update and install

sudo apt update
sudo apt install fish

Third: replace the original terminal

sudo chsh -s /usr/local/bin/fish

If you want to back to the bash terminal, type this in terminal

sudo chsh -s 'which bash'

Tips on WSL2

IQIUM — Sat, 16 Jul 2022 08:36:07 +0000

Please note that this blog post will continuously updated. And the wsl2 system I used is Ubuntu22.04

wslview > This is a tool that we can open file (images, html, document...) through software on windows.

first, install wslview > type this command: sudo apt install wslview
second, use it > For example, create a text file touch hello.txt > and input something in hello.txt > then use it: wslview hello.txt > then you can see that hello.txt will open in notebook.

WSL system moving

IQIUM — Tue, 24 May 2022 05:58:24 +0000

First, close wsl：wsl --shutdown
Second, export wsl: wsl --export Debian D:\WSL\Debian.tar
Third, unregister wsl: wsl --unregister Debian
Lastly, we import the system: wsl --import Debian D:\WSL\Debian D:\WSL\Debian.tar
(optionly: change the default login user: debian config --default-user Zhang)

interesting output buffer question!

IQIUM — Sun, 15 May 2022 05:49:30 +0000

to be update, this is a note for me.

From jyy,I get a very interesting problem.

Sence like this,here are some code:

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main(int argc, char *argv[]) {
  int n = 2;
  for (int i = 0; i < n; i++) {
    fork();
    printf("Hello\n");
  }
  for (int i = 0; i < n; i++) {
    wait(NULL);
  }
}

if we run this programe, we can get this result:

//gcc fork-printf.c && ./a.out
Hello
Hello
Hello
Hello
Hello
Hello

there has six 'hello'

but when we use the pipe command,like this:

//gcc fork-printf.c && ./a.out | cat
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello

we will get eight 'hello'.

why

In linux, when we use stdout:

for termianl: linux use line buffer, if meet character \n, linux use system calling to output all buffer.

for pipe/file: linux use full buffer, when the size of buffer is up to 4096B, (except that we call fflush(stdout)).

for conition Ⅰ，use line buffer, directly output; otherwise, for condition Ⅱ, use full buffer.

【剑指 Offer.07 重建二叉树】

IQIUM — Fri, 29 Apr 2022 03:31:54 +0000

题目地址：https://leetcode-cn.com/problems/zhong-jian-er-cha-shu-lcof/

题目描述：输入某二叉树的前序遍历和中序遍历的结果，请构建该二叉树并返回其根节点。

比如：该二叉树

Input: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]

Output: [3,9,20,null,null,15,7]

递归方法

可以知道的是：

前序遍历一棵二叉树的结果肯定是：

[ 根节点, [左子树的前序遍历结果], [右子树的前序遍历结果] ]

中序遍历一棵二叉树的结果是：

[ [左子树的中序遍历结果], 根节点, [右子树的中序遍历结果] ]

那么我们可以采取以下思路：

（设定先序遍历为preorder，中序遍历为inorder）

设定preorder[0] 为根节点 root
在 inorder 中寻找根节点所在的位置，然后计算左子树的结点个数
然后就可以递归建树了

代码如下：

class Solution {
public:
    unordered_map<int, int> index;
    TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) {
        int n = preorder.size();
        for (int i = 0; i < n; i++) {
            index[inorder[i]] = i;
        }
        return myBuildTree(preorder, inorder, 0, n - 1, 0, n - 1);
    }

    TreeNode *myBuildTree(vector<int> &preorder, vector<int> &inorder, int preorder_left, int preorder_right, int inorder_left, int inorder_right) {
        if (preorder_left > preorder_right) {
            return nullptr;
        }
        int root_pre_idx = preorder_left;
        TreeNode *root = new TreeNode(preorder[root_pre_idx]);
        int root_in_idx = index[preorder[root_pre_idx]];
        int left_tree_cnt = root_in_idx - inorder_left;
        root->left = myBuildTree(preorder, inorder, preorder_left + 1, preorder_left + left_tree_cnt, inorder_left, root_in_idx - 1);
        root->right = myBuildTree(preorder, inorder, preorder_left + left_tree_cnt + 1, preorder_right, root_in_idx + 1, inorder_right);
        return root;
    }
};

【152】乘积最大子数组

IQIUM — Tue, 05 Apr 2022 07:05:01 +0000

如果你仔细看看题目就应该直到这道题应该用的是DP，思考30分钟后无果，打开题解......

看题解看的一脸懵逼，打开youtube，有人这么解释道：

如果之前的数为10，现在是个5，那肯定取最后结果50

如果之前的数为-10，现在是个-5，那也肯定取最后结果为50

如果之前的结果不乘也没有当前的数大，那肯定最后结果为当前的数10000

结果显然，需要前期维护两个数组，maxarr 代表前期pre计算的结果的最大值，minarr 代表前期计算结果的最小值，因为你也无法保证当当前的数是正数还是负数。

鉴于上面的思考，写下下面的代码：

class Solution {
public:
    int maxProduct(vector<int> &nums) {
        int size = nums.size();
        vector<int> maxarr(size, 0);
        vector<int> minarr(size, 0);
        maxarr[0] = nums[0];
        minarr[0] = nums[0];

        for (int i = 1; i < size; i++) {
            maxarr[i] = max(max(maxarr[i - 1] * nums[i], minarr[i - 1] * nums[i]), nums[i]);
            minarr[i] = min(min(maxarr[i - 1] * nums[i], minarr[i - 1] * nums[i]), nums[i]);
        }
        return *max_element(maxarr.begin(), maxarr.end());
    }
};

当然这里是可以进行优化的，take less space：

int size = nums.size();
vector<int> maxarr(size, 0);
vector<int> minarr(size, 0);
maxarr[0] = nums[0];
minarr[0] = nums[0];

int premax = nums[0];
int premin = nums[0];
int maxres = nums[0];

for (int i = 1; i < size; i++) {
    int t = premax;
    premax = max(max(premax * nums[i], premin * nums[i]), nums[i]);
    premin = min(min(t * nums[i], premin * nums[i]), nums[i]);
    maxres = max(maxres, premax);
}
return maxres;

Thank you!

VIM usage

IQIUM — Tue, 05 Apr 2022 02:40:11 +0000

Today I suddenly wanted to learn vim on a whim, and opened youtube to learn from blogger Huang Haojie. Here are some notes below.

The address of his video: vim入门教程（第2讲） - YouTube

w： the next word
B： the previous word

H: left
L：right
J：dwon
k：up

ctrl + F： turn up
ctrl + D: turn down

xxx(line number) + gg: jump to the specified line
xxx(line number) + j: jump xxx lines down
xxx(line number) + k: jump xxx lines up

/ + xxx(the word to find): find all the specified word

we can jump by pressing on the N key on the keyboard.Instead,we can use the shift + n to find the previous word.

cc: cut a specified line

we can also cut specified lines use the command of 'cc', for example, if we want to cut 2 lines, we can use this command: 'c2c'.

u: revoke the previous operation
p: paste

This is the first time for me to write a blog in English, so if there is a mistake, please correct me.

一个字符串匹配多个字符串

IQIUM — Fri, 01 Apr 2022 16:22:04 +0000

题目来源：392. 判断子序列 - 力扣

这个假如有多个字符串需要判断是否是字符串的子串

对于给定字符串t，给定待匹配字符串数组words，字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

这里主要看它的进阶问题：

如果有大量输入的 S，称作 S1, S2, ... , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？

对于这样情况下，我们不可能考虑10亿个依次进行比较，这样的效率太低而且会超时，可以借鉴KMP的思想，提前记录下一个字符出现的地方。

举个例子，比如对于字符串' abc'(前面添加一个空格，方便后续处理)，a 出现的地方在下标为 1 的地方，c 出现在下标为 3 的地方。

那么如果我们后面找字符串 'ac',索引的顺序就变成了 1->3，提高了访问效率。

我们可以给字符串(后面我们称为t)建立一个索引二维数组dp，t.length * 26(26个英文字母)

vector<vector<int>> dp(length, vector<int>(26, 0));

对于每个字符，我们从后往前遍历，这样很方便记录下一个字符出现的地方：

for (int i = 0; i < 26; ++i) {
    int nextPos = -1;
    for (int j = length - 1; j >= 0; --j) {
        dp[j][i] = nextPos;
        if (('a' + i) == t[j]) {
            nextPos = j;
        }
    }
}

这里dp[i][j] 代表的是当前字符距离下一个字符'a'+j 出现的位置

那么，对于我们待查找的字符串 s，只需要从index 开始查找，直到结束：

int index = 0;
for (char &ch : s) {
    index = dp[index][ch - 'a'];
    if (index == -1) {
        return false;
    }
}
return true;

这里为什么要记录呢？因为查找字符是否出现在字符串中有很多方法，暴力遍历、位运算都是值得记录的。

318. 最大单词长度乘积

IQIUM — Mon, 28 Mar 2022 09:42:17 +0000

题目链接🔗:318. 最大单词长度乘积

这道题可以学习的地方在于如何快速比较出两个字符串是否拥有相同的字符。举个例子，比如"aaa" 和 "bab" 这两个字符串拥有相同的字符 'a' 的，暴力的解法就是对逐个字符进行比较，如果是这样的话，这就缺失了写这篇博文的意义。

这里我们使用比较巧妙的方法：位运算

先设定对于26个字符a ~ z，我们设定使用 0 ~ 25 代表它们，即num = x - 'a'
那么对应的每个字符串，都可以由一个整数（看成二进制表示），比如 'acd' 可以用二进制1101表示
如果两个字符串不包含相同的字符，那么与操作的结果一定是0，比如
'acd'用二进制表示为1101，'efg' 用二进制表示结果为1110000，比如1110000 & 0001101 = 0
这样双重for循环遍历就可以找到结果，时间复杂度为O(N^2)

优化

为什么会有优化呢？

对于本题的第三个实例可以看出，对于如果由相同字符组成的不同长度的字符串，这样遍历很显然无用而且超时的
我们可以想到，对于由相同字符组成的字符串，他们的二进制表示一定是一样的，比如'aa' 和 'aaa'，他们表示的结果都是0000 0001
那么根据题目的要求，求没有相同的字符的两个字符串的最大长度乘积，只需要记录相同字符组成的字符串长度的最大值就可以了，这里就使用map去实现

代码参考如下：

class Solution {
public:
    int maxProduct(vector<string> &words) {
        int len = words.size();
        vector<int> mask(len, 0);
        map<int, string> ma;
        for (int i = 0; i < len; ++i) {
            string cur = words[i];
            int l = cur.length();
            int total = 0;
            for (int j = 0; j < l; ++j) {
                total |= (1 << (cur[j] - 'a'));
            }
            if (ma.find(total) != ma.end()) {
                if (ma[total].length() < l) {
                    ma[total] = cur;
                }
            } else {
                ma[total] = cur;
            }
        }
        int res = 0;
        for (auto it = ma.begin(); it != ma.end(); ++it) {
            for (auto next = it; next != ma.end(); ++next) {
                if (it == next) {
                    continue;
                }
                if (!((it->first) & (next->first))) {
                    res = max(res, int((it->second.length()) * (next->second.length())));
                }
            }
        }

        return res;
    }
};