怒刷LeetCode的第16天（Java版）

目录

第一题

题目来源

题目内容

解决方法

方法一：迭代

方法二：模拟

方法三：循环模拟

方法四：传递

第二题

题目来源

题目内容

解决方法

方法一：回溯

方法二：枚举优化

第三题

题目来源

题目内容

解决方法

方法一：递归

方法二：迭代

方法三：动态规划

方法四：递推

第一题

题目来源

2582. 递枕头 - 力扣（LeetCode）

题目内容

解决方法

方法一：迭代

这个问题可以使用一个简单的循环来解决。我们使用两个变量来追踪当前拿着枕头的人的位置和传递的方向。

  1. 首先，我们初始化forward为true，表示初始传递方向是向前的。然后，我们进入一个循环，从1到time进行迭代，模拟枕头传递的过程。
  2. 在循环中，我们首先检查当前拿着枕头的人是否处于队列的首位（即pos == 1），如果是，则将传递方向设置为向前（forward = true）；然后，我们检查当前拿着枕头的人是否处于队列的末尾（即pos == n），如果是，则将传递方向设置为向后（forward = false）。
  3. 接下来，我们根据传递方向更新当前拿着枕头的人的位置。如果传递方向是向前（forward = true），则将pos加1；如果传递方向是向后（forward = false），则将pos减1。
  4. 重复这个过程，直到达到指定的传递时间time。最后，返回拿着枕头的人的编号pos。

总结来说，我们使用一个循环来迭代传递过程，并根据当前位置和传递方向进行更新，直到达到指定的传递时间。最终，返回拿着枕头的人的编号。

class Solution {public int passThePillow(int n, int time) {boolean forward = true;int pos = 1;for (int i = 1; i <= time; i++) {if (pos == 1) {forward = true;} else if (pos == n) {forward = false;}if (forward) {pos++;} else {pos--;}}return pos;}
}

复杂度分析：

  • 时间复杂度分析：循环的次数取决于传递的时间time，因此循环的次数是常数级别的。所以，时间复杂度可以表示为O(1)，即常数时间复杂度。
  • 空间复杂度分析：在这个算法中，并没有使用任何额外的数据结构，只使用了几个整型变量来追踪位置和方向。因此，空间复杂度是O(1)，即常数空间复杂度。

综上所述，该算法具有常数级别的时间复杂度和空间复杂度。这意味着无论输入的传递时间time和参与传递的人数n有多大，算法的执行时间和空间占用都是固定的。

LeetCode运行结果：

方法二：模拟

这个算法的思路是通过观察规律，找到一个公式计算出时间t后枕头所在位置的编号。

首先，我们可以注意到，每当枕头到达队伍的某一端，就会改变传递方向。也就是说，枕头的传递方向是周期性的，以(n-1)*2为一个周期。例如，当n=4时，第一次周期内，枕头的传递顺序是1-2-3-4-3-2；第二次周期内，枕头的传递顺序是2-3-4-3-2-1。因此，我们可以将time对于一个周期取模，以便更好地处理时间过长的情况。

接下来，考虑如何计算枕头所在位置的编号。如果time小于n，此时枕头仍然在最开始的n个人中间传递，因此枕头的位置等于time+1。否则，枕头已到达了队伍的另一端，需要反向传递。如果按顺序数枕头位置，此时与time相对应的枕头位置应该是n*2-time-1，因此可以使用这个表达式计算枕头所在的位置编号。

class Solution {public int passThePillow(int n, int time) {time %= (n - 1) * 2;return time < n ? time + 1 : n * 2 - time - 1;}
}

复杂度分析：

  • 时间复杂度分析：在这个算法中，我们只有一个简单的求模运算和一个条件判断，所以时间复杂度为O(1)，即常数时间复杂度。
  • 空间复杂度分析：该算法没有使用任何额外的数据结构或递归调用，所以空间复杂度为O(1)，即常数空间复杂度。不论输入的大小，所需的额外空间都是固定的。

综上所述，该算法的时间复杂度为O(1)，空间复杂度为O(1)。

LeetCode运行结果：

方法三：循环模拟

这个算法的思路是使用一个循环来模拟枕头传递过程，每次选择下一个接收枕头的人的位置。

  1. 首先，我们初始化两个变量ans和k，分别表示当前枕头所在的位置和传递的方向。初始时，枕头在位置1，传递方向为向右。
  2. 然后，我们进入一个循环，循环执行time次。在每一次循环中，首先将ans的值增加k，以选取下一个接收枕头的位置（如果k为1，则向右移动一位；如果k为-1，则向左移动一位）。然后，如果ans等于1或者等于n，表示枕头到达队伍的一端，需要改变传递方向，即将k乘以-1。
  3. 重复上述步骤，直到循环执行完time次，最后返回ans即为最终枕头所在的位置编号。
class Solution {public int passThePillow(int n, int time) {int ans = 1, k = 1;while (time-- > 0) {ans += k;if (ans == 1 || ans == n) {k *= -1;}}return ans;}
}

复杂度分析：

  • 时间复杂度分析：在这个算法中，循环执行time次，因此时间复杂度为O(time)。虽然time是一个变量，但是在实际应用中，time一般是一个较小的固定值。
  • 空间复杂度分析：该算法只使用了几个整型变量，不随输入规模变化，因此空间复杂度为O(1)，即常数空间复杂度。

综上所述，该算法的时间复杂度为O(time)，空间复杂度为O(1)。

LeetCode运行结果：

方法四：传递

这个算法的思路是，先计算出枕头到达队伍的另一端需要经过几次传递，然后根据剩余传递次数和当前位置计算最终位置。

  • 首先，我们可以注意到，在N个人的队伍中，每当枕头到达队伍的某一端，就会经过N-1个人的传递。也就是说，每N-1个传递为一个周期，枕头在经过一个周期后，就会回到原来的位置并改变传递方向。因此，我们可以先计算出枕头要经过几个周期才能到达队伍的另一端。
  • 接着，我们将time除以n-1得到k，表示枕头需要经过k个周期。然后，对n-1取模得到mod，表示枕头在进行完k个周期后还要经过mod次传递。
  • 最后，我们根据当前位置和剩余传递次数计算最终位置。如果经过k个周期后，枕头处于队伍的左侧（即k为偶数），则最终位置为当前位置加上mod；否则，最终位置为n-mod（反向传递）。
class Solution {public int passThePillow(int n, int time) {int k = time / (n - 1);int mod = time % (n - 1);return (k & 1) == 1 ? n - mod : mod + 1;}
}

复杂度分析：

  • 时间复杂度分析：在这个算法中，我们只进行了几次简单的整数运算，因此时间复杂度为O(1)，即常数时间复杂度。
  • 空间复杂度分析：该算法只使用了几个整型变量，不随输入规模变化，因此空间复杂度为O(1)，即常数空间复杂度。

综上所述，该算法的时间复杂度为O(1)，空间复杂度为O(1)。

LeetCode运行结果：

第二题

题目来源

37. 解数独 - 力扣（LeetCode）

题目内容

解决方法

方法一：回溯

这道题可以通过回溯算法来解决。回溯算法是一种暴力搜索的算法，它尝试在数独的空格中填入数字，并检查填入是否满足数独的规则。如果满足，则继续下一个空格；如果不满足，则回退到上一个空格重新选择数字。

具体实现时，可以使用递归函数来进行回溯。递归函数的参数可以包括数独数组、当前要填入的行和列。在每个空格中，我们尝试填入数字 1-9，并检查是否满足数独的规则。如果满足，则递归调用下一个空格；如果不满足，则尝试下一个数字。直到填完所有的空格，或者找到了一个有效的解为止。

class Solution {public void solveSudoku(char[][] board) {if (board == null || board.length == 0) {return;}solve(board);}private boolean solve(char[][] board) {for (int row = 0; row < 9; row++) {for (int col = 0; col < 9; col++) {if (board[row][col] == '.') {for (char num = '1'; num <= '9'; num++) {if (isValid(board, row, col, num)) {board[row][col] = num;if (solve(board)) {return true;} else {board[row][col] = '.'; // 回溯}}}return false; // 所有数字都尝试过都不满足条件，返回false}}}return true; // 数独已填满，返回true}private boolean isValid(char[][] board, int row, int col, char num) {for (int i = 0; i < 9; i++) {if (board[i][col] == num) { // 检查列是否重复return false;}if (board[row][i] == num) { // 检查行是否重复return false;}int subBoxRow = 3 * (row / 3) + i / 3; // 检查小宫格是否重复int subBoxCol = 3 * (col / 3) + i % 3;if (board[subBoxRow][subBoxCol] == num) {return false;}}return true;}
}

复杂度分析：

时间复杂度：

  • 遍历数独空格：O(81)，因为数独是固定的9x9大小，所以遍历所有的空格需要O(81)的时间复杂度。
  • 递归尝试填入数字：在每个空格中，我们尝试填入1-9的数字，所以对于每个空格，尝试的次数为常数，所以总的尝试次数为O(1)。
  • 判断填入的数字是否满足数独规则：在判断一个数字在行、列、3x3宫格中是否重复时，我们需要遍历相关的行、列和宫格，每次都是常数时间操作，所以总的判断时间为O(1)。 综上所述，整个数独解法的时间复杂度为O(81 * 1 * 1) = O(81)。

空间复杂度：

  • 递归栈空间：递归函数的调用会使用一定的栈空间，递归的最大深度不会超过空格的数量，所以空间复杂度为O(m)，其中m是空格的数量。对于数独问题来说，空格的数量最多为81个，所以空间复杂度为O(81) = O(1)。
  • 数独数组修改：原地修改数独数组，不需要使用额外空间，所以空间复杂度为O(1)。

综上所述，数独解法的总体空间复杂度为O(1)，时间复杂度为O(81)。

LeetCode运行结果：

方法二：枚举优化

class Solution {private int[] line = new int[9];private int[] column = new int[9];private int[][] block = new int[3][3];private boolean valid = false;private List<int[]> spaces = new ArrayList<int[]>();public void solveSudoku(char[][] board) {for (int i = 0; i < 9; ++i) {for (int j = 0; j < 9; ++j) {if (board[i][j] != '.') {int digit = board[i][j] - '0' - 1;flip(i, j, digit);}}}while (true) {boolean modified = false;for (int i = 0; i < 9; ++i) {for (int j = 0; j < 9; ++j) {if (board[i][j] == '.') {int mask = ~(line[i] | column[j] | block[i / 3][j / 3]) & 0x1ff;if ((mask & (mask - 1)) == 0) {int digit = Integer.bitCount(mask - 1);flip(i, j, digit);board[i][j] = (char) (digit + '0' + 1);modified = true;}}}}if (!modified) {break;}}for (int i = 0; i < 9; ++i) {for (int j = 0; j < 9; ++j) {if (board[i][j] == '.') {spaces.add(new int[]{i, j});}}}dfs(board, 0);}public void dfs(char[][] board, int pos) {if (pos == spaces.size()) {valid = true;return;}int[] space = spaces.get(pos);int i = space[0], j = space[1];int mask = ~(line[i] | column[j] | block[i / 3][j / 3]) & 0x1ff;for (; mask != 0 && !valid; mask &= (mask - 1)) {int digitMask = mask & (-mask);int digit = Integer.bitCount(digitMask - 1);flip(i, j, digit);board[i][j] = (char) (digit + '0' + 1);dfs(board, pos + 1);flip(i, j, digit);}}public void flip(int i, int j, int digit) {line[i] ^= (1 << digit);column[j] ^= (1 << digit);block[i / 3][j / 3] ^= (1 << digit);}
}

这段代码使用了位运算和深度优先搜索来解决数独问题。下面是算法的思路：

  1. 初始化 line、column 和 block 数组，用于记录每行、每列和每个九宫格中已经出现的数字状态。
  2. 遍历整个数独棋盘，对于已填入数字的格子，更新相应的状态数组。
  3. 使用循环，不断尝试填入数字，直到无法再填入为止。在每次循环中，遍历棋盘上的每个空白格子，并计算可填入数字的条件：
    • 通过位运算计算出当前格子可用的数字（即未出现在同一行、同一列和同一个九宫格中的数字）。
    • 如果仅有一个数字满足条件，则将其填入，并更新状态数组。
    • 如果有多个数字满足条件，则跳过该格子，继续下一个格子。
  4. 遍历完成后，如果仍存在空白格子，将它们的位置保存在 spaces 列表中。
  5. 调用深度优先搜索函数 dfs，递归地尝试填入空白格子：
    • 如果已经填完所有空白格子，设定 valid 为真并返回。
    • 取出下一个空白格子的位置，计算可填入的数字的条件。
    • 通过位运算，逐个尝试可填入的数字，并进行递归搜索。
  6. 如果搜索到最后，仍未找到合法解，则将之前填入的数字恢复，并返回上一层继续搜索其他可能的数字组合。

这种解法通过位运算和状态压缩技巧，提高了数独求解的效率。同时使用深度优先搜索来穷举所有可能的数字组合，直到找到合法解或遍历完所有空白格子。

复杂度分析：

时间复杂度：

  • 初始化部分需要遍历数独棋盘，时间复杂度为O(81) = O(1)。
  • 循环填入数字的部分，最坏情况下需要进行多轮循环，但每轮循环中每个格子的操作是常数时间的，因此可以认为整体时间复杂度为O(81) = O(1)。
  • 深度优先搜索部分，最坏情况下需要穷举所有可能的数字组合，并且每个格子都有9种选择，因此时间复杂度为O(9^(空白数量))。空白数量通常较小，因此可以近似看作常数，即O(1)。 综上所述，整体时间复杂度为O(1)。

空间复杂度：

  • 使用了line、column和block数组来记录数字出现的状态，每个数组的长度为9，因此空间复杂度为O(9) = O(1)。
  • 使用了spaces列表来保存空白格子的位置，最多有81个空白格子，因此空间复杂度为O(81) = O(1)。
  • 递归调用dfs函数时产生的函数调用栈空间，最多深度为空白数量，通常较小，因此空间复杂度为O(1)。 综上所述，整体空间复杂度为O(1)。

总结起来，该算法的时间复杂度和空间复杂度都是O(1)，表示算法的运行时间和占用的额外空间都与输入规模无关，非常高效。

LeetCode运行结果：

第三题

题目来源

38. 外观数列 - 力扣（LeetCode）

题目内容

解决方法

方法一：递归

要解决这个问题，我们可以使用递归的方法来生成外观数列。首先，定义一个递归函数generateNext，该函数输入一个数字字符串，并返回对其进行描述后的新字符串。然后，我们可以使用递归调用generateNext来生成外观数列的第n项。

public class Solution {public String countAndSay(int n) {if (n == 1) {return "1";}String prev = countAndSay(n - 1);StringBuilder result = new StringBuilder();int count = 1;for (int i = 0; i < prev.length(); i++) {// 如果下一个字符与当前字符相同，则增加计数器if (i < prev.length() - 1 && prev.charAt(i) == prev.charAt(i + 1)) {count++;} else {  // 否则，将描述添加到结果中，并重置计数器result.append(count);result.append(prev.charAt(i));count = 1;}}return result.toString();}
}

在上面的代码中，当n为1时，直接返回"1"；否则，先递归调用countAndSay(n - 1)来得到前一项的描述字符串，然后遍历该字符串，统计相邻相同字符的个数，并将个数和字符添加到结果中。最后，返回结果字符串。通过调用countAndSay函数，可以得到外观数列的第n项。

复杂度分析：

  • 时间复杂度分析：
  • 对于每一项n，我们需要递归调用`countAndSay(n - 1)`来得到前一项的描述字符串。因此，总共需要进行n次递归调用。
  • 在每一次递归调用中，我们需要遍历前一项的描述字符串，计算相邻相同字符的个数，并将结果添加到结果中。这一步的时间复杂度是O(len(prev))，其中len(prev)表示前一项描述字符串的长度。
  • 综上所述，总的时间复杂度是O(1 + 2 + 3 + ... + n) = O(n^2)，其中n是给定的正整数。

空间复杂度分析：

  • 递归调用`countAndSay(n)`的最大深度是n，因此递归栈的空间复杂度是O(n)。
  • 此外，在每一次递归调用中，我们使用一个StringBuilder来构建当前项的描述字符串，并返回它。这个StringBuilder的空间也是O(n)。
  • 综上所述，总的空间复杂度是O(n)。

综合起来，该算法的时间复杂度是O(n^2)，空间复杂度是O(n)。

LeetCode运行结果：

方法二：迭代

除了递归之外，我们还可以使用迭代的方法来生成外观数列。

public class Solution {public String countAndSay(int n) {String result = "1";for (int i = 2; i <= n; i++) {StringBuilder temp = new StringBuilder();int count = 1;for (int j = 0; j < result.length(); j++) {// 如果下一个字符与当前字符相同，则增加计数器if (j < result.length() - 1 && result.charAt(j) == result.charAt(j + 1)) {count++;} else {  // 否则，将描述添加到临时字符串中，并重置计数器temp.append(count);temp.append(result.charAt(j));count = 1;}}result = temp.toString();}return result;}
}

在上面的代码中，我们使用一个循环从2到n，依次生成外观数列的每一项。对于每一项，我们使用一个临时的StringBuilder来构建它的描述字符串，并更新result变量为临时字符串的值。

复杂度分析：

这种迭代方法的时间复杂度和空间复杂度与递归方法相同，都是O(n^2)和O(n)，因为我们仍然需要遍历前一项的描述字符串来计算当前项的描述字符串。只是在实现上，迭代方法更简单直观，没有递归的函数调用开销。

LeetCode运行结果：

方法三：动态规划

除了递归和迭代，还可以使用动态规划的方法来生成外观数列。动态规划通过存储中间结果来避免重复计算，提高效率。

public class Solution {public String countAndSay(int n) {List<String> dp = new ArrayList<>();dp.add("1"); // 初始项for (int i = 1; i < n; i++) {String prev = dp.get(i - 1); // 前一项的描述字符串StringBuilder current = new StringBuilder();int count = 1;for (int j = 0; j < prev.length(); j++) {// 如果下一个字符与当前字符相同，则增加计数器if (j < prev.length() - 1 && prev.charAt(j) == prev.charAt(j + 1)) {count++;} else {  // 否则，将描述添加到临时字符串中，并重置计数器current.append(count);current.append(prev.charAt(j));count = 1;}}dp.add(current.toString()); // 将当前项的描述字符串添加到动态规划数组中}return dp.get(n - 1); // 返回第n项的描述字符串}
}

在上面的代码中，我们使用一个动态规划数组dp来存储每一项的描述字符串。初始时，将"1"作为第一项的描述字符串。然后，从2到n依次计算每一项的描述字符串，并将其存储到动态规划数组中。最后，返回第n项的描述字符串。

复杂度分析：

使用动态规划方法，我们将外观数列的每一项的描述字符串存储起来，避免了重复计算，提高了效率。它的时间复杂度仍然是O(n^2)，但相对于递归和迭代方法，动态规划在计算过程中节省了一些中间计算的时间。空间复杂度为O(n)，用来存储动态规划数组。

LeetCode运行结果：

方法四：递推

除了前面提到的方法，还可以使用递推方法来生成外观数列。递推方法是指根据已知的前几项，通过递推公式计算得到后续的项数。

public class Solution {public String countAndSay(int n) {String current = "1"; // 初始项for (int i = 1; i < n; i++) {StringBuilder next = new StringBuilder();int count = 1;char ch = current.charAt(0);for (int j = 1; j < current.length(); j++) {// 如果下一个字符与当前字符相同，则增加计数器if (current.charAt(j) == ch) {count++;} else { // 否则，将计数器和当前字符追加到下一个描述字符串中，并更新当前字符和计数器next.append(count).append(ch);ch = current.charAt(j);count = 1;}}next.append(count).append(ch); // 将最后一个连续数字段追加到下一个描述字符串中current = next.toString(); // 更新当前描述字符串为下一个描述字符串}return current; // 返回第n项的描述字符串}
}

在这种方法中，我们根据外观数列的定义，通过递推公式计算每一项的描述字符串。具体来说，我们遍历当前项的描述字符串，记录当前字符和计数器。如果下一个字符与当前字符相同，则增加计数器；否则，将计数器和当前字符追加到下一个描述字符串中，并更新当前字符和计数器。最后，将最后一个连续数字段追加到下一个描述字符串中，更新当前描述字符串为下一个描述字符串。通过这种方式，我们可以递推得到所有项的描述字符串。

复杂度分析：

  • 使用递推方法，我们避免了使用递归或动态规划来求解外观数列，减少了时间和空间复杂度。但是，递推方法需要根据递推公式，对每一项进行计算，因此时间复杂度仍然为O(n^2)。
  • 空间复杂度为O(m)，其中m是当前项的长度。在每次计算下一项时，我们只需使用一个StringBuilder对象来构建描述字符串，其长度为m。每次计算完成后，我们无需保留之前的计算结果，因此只需要恒定的额外空间来存储当前项的描述字符串。因此，总的空间复杂度为O(m)。

LeetCode运行结果：

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.xdnf.cn/news/146807.html

如若内容造成侵权/违法违规/事实不符，请联系一条长河网进行投诉反馈，一经查实，立即删除！

相关文章

差分放大器的精髓：放大差模信号 抑制共模信号

差分放大器的精髓：放大差模信号 抑制共模信号

参考如图基本的差分放大电路&#xff0c;在R1R2 R3R4的条件下&#xff0c;其输出与输入的关系为 &#xff1a; 具体推导过程参考&#xff1a;差分运算放大器的放大倍数的计算及结论_正在黑化的KS的博客-CSDN博客 由这个式子我们可以发现&#xff0c;差分放大器放大的是同相端与…
阅读更多...
stable diffusion和gpt4-free快速运行

stable diffusion和gpt4-free快速运行

这是一个快速搭建环境并运行的教程 stable diffusion快速运行gpt快速运行 包含已经搭建好的环境和指令&#xff0c;代码等运行所需。安装好系统必备anaconda、conda即可运行。 stable diffusion快速运行 github: AUTOMATIC1111/稳定扩散网络UI&#xff1a;稳定扩散网页用户界…
阅读更多...
STL upper_bound和lower_bound函数

STL upper_bound和lower_bound函数

声明&#xff1a; 首先包含头文件#include<algorithm> 这里的两个函数所运用的对象必须是非递减的序列&#xff08;也就是数组&#xff0c;数组必须是非递减的&#xff09;&#xff0c;只有这样才可以使用upper_bound和lower_bound这两个函数。 还有一点&#xff0c;就…
阅读更多...
（七）Flask之路由转换器

（七）Flask之路由转换器

引子&#xff1a; from flask import Flaskapp Flask(__name__)# 通过使用<int>转换器&#xff0c;可以捕获URL中的整数值&#xff0c;并将其作为参数传递给视图函数。 app.route(/index/<int:nid>, methods[GET, POST]) def index(nid):print(nid)return Indexi…
阅读更多...
软件测试之Python基础学习

软件测试之Python基础学习

目录 一、Python基础 Python简介、环境搭建及包管理 Python简介 环境搭建 包管理 Python基本语法 缩进(Python有非常严格的要求) 一行多条语句 断行 注释 变量 基本数据类型(6种) 1. 数字Number 2. 字符串String 3. 列表List 4. 元组Tuple 序列相关操作方法 …
阅读更多...
黑豹程序员-架构师学习路线图-百科：Git/Gitee（版本控制）

黑豹程序员-架构师学习路线图-百科：Git/Gitee（版本控制）

文章目录 1、什么是版本控制2、特点3、发展历史4、SVN和Git比较5、Git6、GitHub7、Gitee&#xff08;国产&#xff09;8、Git的基础命令 1、什么是版本控制 版本控制系统&#xff08; Version Control &#xff09;版本控制是一种管理和跟踪软件开发过程中的代码变化的系统。它…
阅读更多...
树莓派4B串口通信配置方式

树莓派4B串口通信配置方式

目录 1树莓派4B的安装&#xff1a; 1.1安装Serial与使用 1.1.1安装serial 1.1.2打开串口 1.2设置硬件串口为GPIO串口&#xff08;修改串口映射关系&#xff09; 1.2.1修改配置文件 2.1minicom串口 2.1.1安装minicom 这篇博客源于&#xff1a;工创赛。需要让树莓派与STM…
阅读更多...
JDK11优化了哪些功能以及新增了哪些特性功能|JDK各个版本的特性分析

JDK11优化了哪些功能以及新增了哪些特性功能|JDK各个版本的特性分析

一、前言 上一期讲了JDK10的一些新特性&#xff0c;需要回顾的朋友们可以去该专栏回顾一下 这一期讲一讲JDK11的一些新功能 二、新增特性 以下是JDK 11的一些新增或变化的特性&#xff1a; 1. 纯字符串类型的 HTTP 客户端: JDK 11 引入了一个新的 HTTP 协议的客户端 API&…
阅读更多...
【Java】super 关键字用法

【Java】super 关键字用法

目录 this与super区别 1.访问成员变量-示例代码 继承中构造方法的访问特点 2.访问构造方法-示例代码&#xff1a; 继承中成员方法访问特点 3.访问成员方法-示例代码&#xff1a; super 关键字的用法和 this 关键字相似 this : 代表本类对象的引用super : 代表父类存储空间…
阅读更多...
使用 Elastic 输入包自定义你的数据摄取

使用 Elastic 输入包自定义你的数据摄取

作者&#xff1a;Ishleen Kaur Elastic 通过集成&#xff08;integrations&#xff09;实现了外部数据源和 Elastic Observability Solution 之间数据流的收集、转换和分析。 集成包通过封装多个组件来实现这一点&#xff0c;包括代理配置 (agent configuration)、数据收集输入…
阅读更多...
利用DMA的触发循环实现eTMR的PWM周期计数

利用DMA的触发循环实现eTMR的PWM周期计数

利用DMA的触发循环实现对eTMR的PWM周期计数 文章目录 利用DMA的触发循环实现对eTMR的PWM周期计数引言分析问题eTMR的调试模式ModulizationFTM的多次重载事件终极大招-使用触发链 解决问题确认DMAMUX中的eTMR相关触发源eTMR产生触发信号 软件总结参考文献 引言 最近在同客户一起…
阅读更多...
Docker学习_镜像和容器篇

Docker学习_镜像和容器篇

简介 Docker是一种容器化的技术&#xff0c;可以实现在一台宿主机电脑上运行多个不同的容器&#xff0c;每个容器之间都相互独立&#xff0c;具有完整的一套文件&#xff0c;网络和端口。 可以将其理解为一种虚拟机技术&#xff0c;只不过和VMware等虚拟化技术不同&#xff0…
阅读更多...
【工具】idea 设置自动渲染注释

【工具】idea 设置自动渲染注释

前言 需求&#xff1a;自动渲染文档注释&#xff0c;看源码更加舒服。 已知 crtl alt Q 可以 设置 尝试搜索 render&#xff0c;发现有启用 “渲染文档注释” 的地方 坐标 &#xff1a; Settings -> Editor-> Appearance
阅读更多...
链表经典面试题(五)

链表经典面试题(五)

求链表的公共结点 1.题目2.详细的图示3.详细注释和代码实现 1.题目 2.详细的图示 3.详细注释和代码实现 public class Solution {public ListNode getIntersectionNode(ListNode headA, ListNode headB) {//定义两个表示长度的指针,让它们指向headA和headB//我们暂时无法知道哪…
阅读更多...
14：00面试测试岗，14：06就出来了，问的问题有点变态。。。

14：00面试测试岗，14：06就出来了，问的问题有点变态。。。

从小厂出来&#xff0c;没想到在另一家公司又寄了。 到这家公司开始上班&#xff0c;加班是每天必不可少的&#xff0c;看在钱给的比较多的份上&#xff0c;就不太计较了。没想到9月一纸通知&#xff0c;所有人不准加班&#xff0c;加班费不仅没有了&#xff0c;薪资还要降40%,…
阅读更多...
ElementUI之首页导航+左侧菜单

ElementUI之首页导航+左侧菜单

文章目录 一、Mock.js1.1.什么是Mock.js1.2.安装与配置1.3使用 二、登录注册跳转2.1.在views中添加Register.vue2.2.在Login.vue中的methods中添加gotoRegister方法2.3.在router/index.js中注册路由 三、组件通信&#xff08;总线&#xff09;3.1 在main.js中添加内容3.2.在com…
阅读更多...
分布式搜索引擎es-3

分布式搜索引擎es-3

文章目录 数据聚合聚合的种类RestAPI实现聚合 自动补全自定义拼音分词器自动补全查询案例&#xff1a;实现酒店搜索框自动补全自动补全的javaAPI实现搜索框自动补全 口述自动补全数据同步集群集群的分布式存储集群分布式查询集群故障转移 数据聚合 什么是聚合&#xff1f; 聚合…
阅读更多...
chrome extensions mv3通过content scripts注入/获取原网站的window数据

chrome extensions mv3通过content scripts注入/获取原网站的window数据

开发插件的都知道插件的content scripts和top window只共享Dom不共享window和其他数据&#xff0c;如果想拿挂载在window的数据还有点难度&#xff0c;下面会通过事件的方式传递cs和top window之间的数据写一个例子 代码 manifest.json 这里只搞了2个js&#xff0c;content.…
阅读更多...
【前端】ECMAScript6从入门到进阶

【前端】ECMAScript6从入门到进阶

【前端】ECMAScript6从入门到进阶 1.ES6简介及环境搭建 1.1.ECMAScript 6简介 &#xff08;1&#xff09;ECMAScript 6是什么 ECMAScript 6.0&#xff08;以下简称 ES6&#xff09;是 JavaScript 语言的下一代标准&#xff0c;已经在2015年6月正式发布了。它的目标&#xff…
阅读更多...
Excel·VBA分列、字符串拆分

Excel·VBA分列、字符串拆分

看到一篇博客《VBA&#xff0c;用VBA进行分列&#xff08;拆分列&#xff09;的2种方法》&#xff0c;使用VBA对字符串进行拆分 目录 Excel分列功能将字符串拆分为二维数组&#xff0c;Split函数举例 将字符串拆分为一维数组&#xff0c;正则表达式举例 Excel分列功能 Sub 测…
阅读更多...
最新文章

Copyright @ 2022~2023