2024年4月24日华为春招实习试题【三题】-题目+题解+在线评测,2024.4.24,华为机试

news2024/10/6 6:44:16

2024年4月24日华为春招实习试题【三题】-题目+题解+在线评测,2024.4.24,华为机试

  • 🏩题目一描述:
    • 输入格式
    • 输出格式
    • 样例1
    • 样例2
    • 样例3
    • 数据范围
    • 解题思路一:dfs
    • 解题思路二:直接二分查找哇!
    • 解题思路三:c++, java
  • 💒题目二描述:球员能力评估
    • 样例一
    • 样例二
    • 解题思路一:元组排序
    • 解题思路二:排序
    • 解题思路三:c++, java
  • 🏨题目三描述:
    • 样例一
    • 样例二
    • 解题思路一:
    • 解题思路二:c++
    • 解题思路三:java

🏩题目一描述:

LYA 是一名计算机专业的学生,最近她正在学习数据结构中的二叉搜索树。二叉搜索树是一种常用的数据结构,它可以实现快速的查找和插入操作。

现在,LYA 有一个由 2 n − 1 2^n-1 2n1个不同的正整数组成的数列( 1 ≤ n ≤ 10 1 \leq n \leq 10 1n10,且 n 为整数)。她想用这些数构建一棵平衡的满二叉搜索树。

二叉搜索树满足以下性质:

  1. 节点的左子树只包含小于当前节点的数。
  2. 节点的右子树只包含大于当前节点的数。
  3. 所有左子树和右子树也必须是二叉搜索树。

例如,对于数列 [1,2,3,4,5,6,7],可以构建出如下图所示的满二叉搜索树:

    4
   / \
  2   6
 / \ / \
1  3 5  7

现在,给定一个待查找的数,请你帮助 LYA 计算查找该数的路径和结果。

输入格式

第一行包含若干个用空格分隔的正整数,表示给定的数列。

第二行包含一个正整数,表示待查找的数。

输出格式

输出查找的路径和结果。

路径从根节点开始,用 S 表示。查找左子树用 L 表示,查找右子树用 R 表示。查找到结果用 Y 表示,未找到结果用 N 表示。

样例1

输入

2 1 3 7 5 6 4
6

输出

SRY

解释:
从根节点开始,所以路径的第一部分为 S。待查找数为 6 ,大于根节点 4,所以要查找右子树,路径增加 R,正好找到,因此最后增加 Y。最终输出 SRY

样例2

输入

4 2 1 3 6 5 7
5

输出

SRLY

解释:
从根节点开始,先查找右子树,再查找左子树,最终找到结果 5,因此输出 SRLY

样例3

输入

1 2 3 4 5 6 7
8

输出

SRRN

解释:
从根节点开始查找,标记 S。待查找数 8 大于根节点 4,所以查找右子树,标记 R。继续查找右子树,标记 R。8 比右子树节点 7 还大,但已经到达叶子节点,没有找到,因此最后标记 N

数据范围

  • 1 ≤ n ≤ 10 1 \leq n \leq 10 1n10
  • 给定的数列中的数互不相同

OJ链接:
https://codefun2000.com/p/P1830

解题思路一:dfs

本题考查二叉搜索树的构建和查找操作。

首先,我们需要根据给定的数列构建一棵平衡的满二叉搜索树。可以按照如下步骤进行:

  1. 将数列按照从小到大的顺序排序。
  2. 递归地构建左右子树:
    • 如果当前区间为空,则返回空树。
    • 取区间的中点作为根节点。
    • 递归地构建左子树和右子树。

构建完二叉搜索树后,我们再进行查找操作。从根节点开始,比较当前节点的值与待查找的数:

  • 如果相等,则查找成功,返回。
  • 如果待查找的数小于当前节点的值,则进入左子树查找。
  • 如果待查找的数大于当前节点的值,则进入右子树查找。

在查找的过程中,我们需要记录查找的路径。当查找到目标数时,输出查找路径以及查找结果。

arr = list(map(int, input().split()))
arr.sort()
n = len(arr)
target = int(input())

def dfs(arr, l, r, target):
    if l > r:
        res.append('N')
        return
    mid = (l + r) >> 1
    if arr[mid] == target:
        res.append('Y')
        return
    elif arr[mid] > target:
        if mid - 1 >= l:
            res.append('L')
        dfs(arr, l, mid-1, target)
    else:
        if mid + 1 <= r:
            res.append('R')
        dfs(arr, mid+1, r, target)
res = ['S']
dfs(arr, 0, n-1, target)
print("".join(res))

时间复杂度:O(nlogn)
空间复杂度:O(n)

解题思路二:直接二分查找哇!

nums = list(map(int, input().split()))
target = int(input())
nums.sort()

l, r = 0, len(nums) - 1
res = ['S']
while l <= r:
    mid = (l+r) // 2
    if nums[mid] == target:
        res.append('Y')
        break
    elif nums[mid] > target:
        r = mid - 1
        res.append('L')
    else:
        l = mid + 1
        res.append('R')
if res[-1] != 'Y':
    res.append('N')
print(''.join(res))

时间复杂度:O(nlogn)
空间复杂度:O(1)

解题思路三:c++, java

#include <bits/stdc++.h>
using namespace std;

const int maxn=1e4+10;
int a[maxn],n;

int main(){
 std::ios::sync_with_stdio(false);
 while(cin>>a[n]){
  n++;
 }
 n--;
 int target=a[n];
 string s="S";
 int p=(1+n)/2;
 int l=1,r=n;
 while(p!=target){
  if(target<p){
   r=p-1;
   p=(l+p-1)/2;
   s+="L";
  }else{
   l=p+1;
   p=(p+1+r)/2;
   s+='R';
  }
 }
 s+="Y";
 cout<<s;
 
 return 0;
}
# java
import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        String[] strings = in.nextLine().split("\\s+");
        int[] data = new int[strings.length];
        int target = in.nextInt();

        for (int i = 0; i < strings.length; i++) {
            data[i] = Integer.parseInt(strings[i]);
            data[i] = i + 1;
        }

        System.out.print(solutin(data, target));

    }

    private static String solutin(int[] data, int target) {
        StringBuilder sb = new StringBuilder();
        if (data != null) {
            sb.append("S");
        }

        int left = 0, right = data.length - 1;
        int mid = (left + right) / 2;

        while (left <= right) {

            if (data[mid] == target) {
                sb.append("Y");
                return sb.toString();
            }else if (data[mid] > target) {
                sb.append("L");
                right = mid - 1;
                mid = (left + right) / 2;
            }else {
                sb.append("R");
                left = mid + 1;
                mid = (left + right) / 2;
            }

        }

        String temp = sb.toString();

        return temp.substring(0, temp.length() - 1) + "N";
    }
}

时间复杂度:O(n)
空间复杂度:O(1)

💒题目二描述:球员能力评估

K教练正在对足球队的 n 名球员进行射门能力评估。评估共进行 m 次训练,每次训练时,若球员射门得分则记为1,否则记为0。现在K教练需要根据以下规则对球员进行排名:

  1. 进球总数较多的球员排名靠前。
  2. 如果进球总数相同,则最长连续进球次数较多的球员排名靠前。
  3. 如果最长连续进球次数也相同,则第一次未进球的训练序号较大的球员排名靠前。如果第一次未进球的训练序号也相同,则比较第二次、第三次……直到比较出结果。
  4. 如果按照前三条规则仍然无法区分排名,则编号较小的球员排名靠前。
    请你帮助K教练生成一个球员排名。

输入格式
第一行包含两个正整数 n 和 m , 表示参与评估的球员数量和训练次数,球员编号从1到 n 。

第二行包含 n 个空格分隔的长度为 m 的字符串,第 i 个字符串表示编号为 i 的球员在这 m 次训练中的进球记录。

输出格式
输出一行,包含 n 个空格分隔的正整数,表示球员编号按照射门能力从高到低排列的结果。

数据范围
1 ≤ n ≤ 1000 1 \le n \le 1000 1n1000
1 ≤ m ≤ 1000 1 \le m \le 1000 1m1000

样例一

输入

4 5
11100 00111 10111 01111

输出

4 3 1 2

解释

4个队员,射门训练5次,队员3和4进球数均为4个,比队员1H和2的3个更多,队员3连续进球故最多一次为3个,而队员4最大为4。因此队员4射门能力强于队员3,另外队员2比队员1先丢球,因此队员1射门能力强于队员2,顺序为4 3 1 2。

样例二

输入

2 10
1011100111 1011101101

输出

2 1

解释

2个队员,射门训练10次,两个队员的进球总数均为7个,连续进球最多的均为3个,且第前两次丢球顺序均为第2次和第6次训练射门,而队员2第三次丢球为第9次训练,队员1为第7次训练,因此队员2的射门能力强于队员1,顺序为2 1

OJ链接:
https://codefun2000.com/p/P1831

解题思路一:元组排序

本题的关键是根据题目描述的规则对球员进行排序。我们可以按照以下思路解决:

  1. 统计每个球员的进球总数和最长连续进球次数。
  2. 记录每个球员第一次、第二次、第三次……未进球的训练序号。
  3. 按照题目规则,以进球总数为第一关键字,最长连续进球次数为第二关键字,未进球训练序号为第三关键字,球员编号为第四关键字,对球员进行降序排序。
  4. 输出排序后的球员编号。

在实现时,我们可以使用一个长度为 n 的数组,数组的每个元素是一个四元组(cnt, maxCnt, rec, id),分别表示球员的进球总数、最长连续进球次数、未进球训练序号和球员编号。然后按照题目规则对这个数组进行排序即可。

n, m = map(int, input().split())
rec = list(map(str, input().split()))

player = []
for i, r in enumerate(rec):
    cnt = r.count('1')
    maxCnt = max(map(len, r.split('0')))
    missrec = ''.join(['0' if c == '1' else '1' for c in r])
    player.append((-cnt, -maxCnt, missrec, i+1))

player.sort()
print(*[p[3] for p in player])

时间复杂度:O(nlogn)
空间复杂度:O(n)

解题思路二:排序

n, m = map(int, input().split())
lst = input().split()

one = [0] * n
con = [0] * n
zero = [[] for _ in range(n)]

for i in range(n):
    s = lst[i]
    for j in range(m):
        if s[j] == '1':
            one[i] += 1
        else:
            zero[i].append(j)

    j = 0
    while j < m:
        if s[j] == '0':
            j += 1
            continue
        k = j + 1
        while k < m and s[k] == '1':
            k += 1
        con[i] = max(con[i], k - j)
        j = k

a = list(range(n))
a.sort(key=lambda x: (-one[x], -con[x], [-z for z in zero[x]], x))

print(*[x + 1 for x in a])

时间复杂度:O(nlogn)
空间复杂度:O(n)

解题思路三:c++, java

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(), m = sc.nextInt();
        String[] records = new String[n];
        for (int i = 0; i < n; i++) {
            records[i] = sc.next();
        }
        
        Integer[][] players = new Integer[n][4];
        for (int i = 0; i < n; i++) {
            String record = records[i];
            int cnt = record.replaceAll("0", "").length();
            int maxCnt = Arrays.stream(record.split("0")).mapToInt(String::length).max().getAsInt();
            String missRecord = record.replaceAll("1", "2").replaceAll("0", "1").replaceAll("2", "0");
            players[i] = new Integer[]{-cnt, -maxCnt, Integer.parseInt(missRecord), i + 1};
        }
        
        Arrays.sort(players, Comparator.<Integer[]>comparingInt(p -> p[0])
                                        .thenComparingInt(p -> p[1])
                                        .thenComparingInt(p -> p[2])
                                        .thenComparingInt(p -> p[3]));
        
        for (Integer[] player : players) {
            System.out.print(player[3] + " ");
        }
    }
}

# c++
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>

using namespace std;

bool cmp(vector<int> a, vector<int> b) {
    if (a[0] != b[0]) return a[0] > b[0];
    if (a[1] != b[1]) return a[1] > b[1];
    if (a[2] != b[2]) return a[2] < b[2];
    return a[3] < b[3];
}

int main() {
    int n, m;
    cin >> n >> m;
    vector<vector<int>> players(n, vector<int>(4));
    for (int i = 0; i < n; i++) {
        string record;
        cin >> record;
        int cnt = 0, maxCnt = 0, curCnt = 0;
        for (char c : record) {
            if (c == '1') {
                cnt++;
                curCnt++;
                maxCnt = max(maxCnt, curCnt);
            } else {
                curCnt = 0;
            }
        }
        string missRecord = record;
        replace(missRecord.begin(), missRecord.end(), '1', '2');
        replace(missRecord.begin(), missRecord.end(), '0', '1');
        replace(missRecord.begin(), missRecord.end(), '2', '0');
        players[i] = {cnt, maxCnt, stoi(missRecord), i + 1};
    }

    sort(players.begin(), players.end(), cmp);
    
    for (auto player : players) {
        cout << player[3] << " ";
    }
    
    return 0;
}

时间复杂度:O(nlogn)
空间复杂度:O(n)

🏨题目三描述:

K小姐是一名软件工程师,她正在对公司的 n 个微服务进行调用情况分析。这些微服务使用 0 到 n − 1 的整数进行编号。

K小姐得到了一个长度为 n 的数组 edges,其中 edges[i] 表示存在一个从微服务 i 到微服务 edges[i] 的调用关系。

如果多个微服务形成了一个环,我们称之为一个微服务群组。对于一个微服务群组,我们定义:

  • L 表示该群组内所有微服务的数量。
  • V 表示能够调用到该群组内微服务的微服务数量。
  • 该群组的内聚值 H=L−V。

已知给定的调用关系数据中至少存在一个微服务群组,请你计算所有群组的内聚值,并按照以下规则对它们进行排序:

  1. 按照内聚值 H 从大到小排序。
  2. 如果内聚值相同,则按照群组内最大编号从小到大排序。

最后,请输出排序后的第一个微服务群组,要求从群组内编号最小的微服务开始,按照调用关系的顺序输出其中所有微服务的编号。

输入格式
第一行包含一个正整数 n ,表示微服务的数量。
第二行包含 n 个整数,表示数组 edges,相邻整数之间用空格分隔。其中 edges[i] 表示存在一个从微服务 i 到微服务 edges[i] 的调用关系。

输出格式
输出一行整数,表示内聚值最大的微服务群组,其中微服务编号按照调用关系顺序输出,起始编号为群组内最小编号。相邻整数之间用空格分隔。

数据范围

  • 2 ≤ n ≤ 1 0 5 2 \le n \le 10^5 2n105
  • 0 ≤ e d g e s [ i ] ≤ n − 1 0 \le edges[i] \le n-1 0edges[i]n1
  • e d g e s [ i ] ≠ i edges[i] \neq i edges[i]=i

样例一

输入

4
3 3 0 2

输出

0 3 2

解释

0,3,2组成了微服务群组 (环)a,他的L值为3,对于a来说,只有编号为1的1个微服务可以访问到a,因此a的为1答案输出微服务群组为0 3 2

样例二

输入

12
2 6 10 1 6 0 3 0 5 4 5 8

输出

0 2 10 5

解释

1,6,3组成了微服务群组(环) a1,L1值为3,编号为4、9的2个微服务可以访问到a1,因此√1值为2,H1为L1V1 =1;

0,2,10,5组成了微服务群组 (环) a2,L2值为4,编号为7、8、11的3个微服务可以访问到2,因此v2值为3,H2为L2-V2=1;

先对比H值,H1=H2,H值相等;

再对比环中序号最大值,a1中最大数为6。a2中最大数为10,a2排前面,因此输出答案为:0 2 10 5

OJ链接:
https://codefun2000.com/p/P1832

解题思路一:

from collections import defaultdict

def dfs(u):
    global cnt
    cnt += 1
    group.append(u)
    visit[u] = True
    
    if visit[edges[u]]:
        if edges[u] in group:
            idx = group.index(edges[u])
            size = len(group) - idx
            connect = sum(indegree[v] for v in group[idx:])
            groups.append((-size + connect, -max(group), group[idx:]))
    else:
        dfs(edges[u])

n = int(input())
edges = list(map(int, input().split()))

adj = defaultdict(list)
indegree = [0] * n
for i, v in enumerate(edges):
    adj[v].append(i)
    indegree[i] += 1

groups = []
visit = [False] * n
for i in range(n):
    if not visit[i]:
        cnt = 0
        group = []
        dfs(i)

groups.sort()
ans = groups[0][2]
start = min(ans)
idx = ans.index(start)

print(*(ans[idx:] + ans[:idx]))

时间复杂度:O(n)
空间复杂度:O(n)

解题思路二:c++

#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 1;
int adj[N];
int dfn[N], low[N], dfncnt = 0, scc[N], siz[N], scccnt = 0;

bool in_stk[N];
stack<int> s;
int maxn[N], minn[N]; // 记录环上(一个scc就是一个环)最大和最小编号节点

void dfs(int u) {
    dfn[u] = low[u] = ++dfncnt;
    s.push(u);
    in_stk[u] = true;
    int v = adj[u];
    if (!dfn[v]) {
        dfs(v);
        low[u] = min(low[u], low[v]);
    } else if (in_stk[v]) {
        low[u] = min(low[u], dfn[v]);
    }

    // 事实上,一个scc里的任何一个点都可以作为这个scc的dfs树根
    // 因此在一个scc内部时,用任何一种遍历顺序都可以
    if (dfn[u] == low[u]) {
        int y;
        do {
            y = s.top();
            scc[y] = scccnt;
            ++siz[scccnt];
            s.pop();
            in_stk[y] = false;

            maxn[scccnt] = max(maxn[scccnt], y);
            minn[scccnt] = min(minn[scccnt], y);
        } while (y != u); // 由于u一定在栈里,最后一次pop栈顶一定有y == u
        ++scccnt;
    }
    // dfs结束时从不pop堆栈
    // 这样当dfs递归调用回到dfs树的根时,堆栈中会保留这个scc的所有节点
}

int main() {
    int n;
    cin >> n;
    // int adj[n];

    for (int i = 0; i < n; ++i) {
        cin >> adj[i];
    }

    // tarjan scc(求强连通分量)
    // int dfn[n], low[n], dfncnt = 0, scc[n], siz[n], scccnt = 0;
    memset(dfn, 0, sizeof dfn);
    memset(siz, 0, sizeof siz);
    
    // bool in_stk[n];
    memset(in_stk, 0, sizeof in_stk);
    // stack<int> s;

    // int maxn[n], minn[n]; // 记录环上(一个scc就是一个环)最大和最小编号节点
    memset(maxn, 0, sizeof maxn);
    memset(minn, 0x3f, sizeof minn);
    // 为什么tarjan只需要跑一遍loop dfs
    // 假如有两个scc,scc1 -> scc2
    // 普通dfs无法正确求出scc的原因是:如果从scc1的点开始dfs,那么dfs会搜索到scc2
    // 但事实上scc2里的点是无法回到scc1的,它们不是同一个scc

    // 但在使用tarjan算法时,即使从scc1开始dfs,搜索到了scc2
    // scc2的点最多也只能回溯到开始进入scc2的起始点(并且那个起始点一定是dfs树根)

    for (int i = 0; i < n; ++i) {
        if (!dfn[i]) dfs(i);
    }

    // 拓扑排序
    int sccadj[scccnt], d[scccnt]; // 新建meta node邻接表,把一个scc缩成一个点
    memset(sccadj, -1, sizeof sccadj); // 如果某个meta node没有出边,那么邻接表值为-1
    memset(d, 0, sizeof d);

    // 现在邻接表中的节点是scc编号
    for (int i = 0; i < n; ++i) {
        int x = scc[i], y = scc[adj[i]];
        if (x != y) {
            ++d[y];
            sccadj[x] = y;
        }
    }

    int cnt[scccnt]; // 记录每个meta node被指向的节点数,这是拓扑排序真正需要做的事情
    memset(cnt, 0, sizeof cnt);
    queue<int> q;
    for (int i = 0; i < scccnt; ++i) {
        if (d[i] == 0) q.push(i);
    }
    // 这实际上会对多个DAG同时进行拓扑排序,BFS拓扑排序时多个DAG的拓扑序会混杂在一起
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        if (sccadj[u] != -1) {
            int v = sccadj[u];
            cnt[v] += cnt[u] + 1;
            --d[v];
            if (d[v] == 0) q.push(v);
        }
    }

    int sccid = -1;
    for (int i = 0; i < scccnt; ++i) {
        if (siz[i] > 1) {
            // L = siz[i], V = cnt[i]
            // 多关键字排序
            if (sccid == -1) sccid = i;
            else if (siz[sccid] - cnt[sccid] < siz[i] - cnt[i]) sccid = i;
            else if (siz[sccid] - cnt[sccid] == siz[i] - cnt[i] && maxn[sccid] < maxn[i]) sccid = i;
        }
    }
    int cur = minn[sccid];
    cout << cur;
    cur = adj[cur];
    while (cur != minn[sccid]) {
        cout << ' ' << cur;
        cur = adj[cur];
    }
}

时间复杂度:O(n)
空间复杂度:O(n)

解题思路三:java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

/**
 * @Author jinwang
 * @Date 2024/5/9 10:48
 * @Version 1.0 (版本号)
 */
 class Main {
    private static class node {
        int maxIdx;
        int minIdx;
        int H;
        public node(int maxIdx, int minIdx, int H) {
            this.maxIdx = maxIdx;
            this.minIdx = minIdx;
            this.H = H;
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        int[] arr = new int[n];
        int[] ru = new int[n];
        int[] v = new int[n];
        boolean[] vis = new boolean[n];
        StringTokenizer st = new StringTokenizer((br.readLine()));
        for (int i = 0; i < n; i++) {
            arr[i] = Integer.parseInt(st.nextToken());
            ru[arr[i]]++;
        }
        Queue<Integer> q = new ArrayDeque<>();
        for (int i = 0; i < n; i++) {
            if (ru[i] == 0) {
                q.add(i);
            }
        }
        while (!q.isEmpty()) {
            int now = q.poll();
            vis[now] = true;
            v[arr[now]] += v[now] + 1;
            ru[arr[now]]--;
            if (ru[arr[now]] == 0) q.add(arr[now]);
        }
        List<node> nodes = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            if (!vis[i]) {
                int now = i, mx = 0, cnt = 0, mn = n, sm = 0;
                while (!vis[now]) {
                    vis[now] = true;
                    mx = Math.max(mx, now);
                    mn = Math.min(mn, now);
                    cnt += v[now];
                    now = arr[now];
                    sm++;
                }
                nodes.add(new node(mx, mn, sm - cnt));
            }
        }
        node ans = nodes.get(0);
        for (int i = 1; i < nodes.size(); i++) {
            if (nodes.get(i).H > ans.H || nodes.get(i).H == ans.H && nodes.get(i).maxIdx > ans.maxIdx)
                ans = nodes.get(i);
        }
        System.out.print(ans.minIdx);
        for (int i = arr[ans.minIdx]; i != ans.minIdx; i = arr[i]) {
            System.out.print(" " + i);
        }
    }
}

时间复杂度:O(n)
空间复杂度:O(n)


创作不易,观众老爷们请留步… 动起可爱的小手,点个赞再走呗 (๑◕ܫ←๑)
欢迎大家关注笔者,你的关注是我持续更博的最大动力


原创文章,转载告知,盗版必究



在这里插入图片描述


在这里插入图片描述
♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠ ⊕ ♠

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

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

经典权限五张表功能实现

文章目录 用户模块(未使用框架)查询功能实现步骤代码 新增功能实现步骤代码 修改功能实现步骤代码实现 删除功能实现步骤代码实现 用户模块会了&#xff0c;其他两个模块与其类似 用户模块(未使用框架) 查询功能 这里将模糊查询和分页查询写在一起 实现步骤 前端&#xff1…

Linux下安装gmp6.2.1的详细操作(深度学习)

方式一&#xff1a;编译gmp GMP官方地址https://gmplib.org/ 1. 官网下载gmp安装包 2. 解压下载好的安装包 tar -zxvf gmp-6.2.1.tar.bz2 3. 进入解压后的文件夹 cd gmp-6.2.1 4. 指定安装路径进行安装 # /usr/local换成自己的安装路径 ./configure --prefix/usr/local 5. 编…

Excel快速填充序号的方法

Excel快速填充序号常用的方法。 方法一&#xff1a;填充前面序号后拖拽 特点&#xff1a; 能有规律的填充&#xff0c;排序的行数由拖拽的行数决定。 此方法填充的序号等效于手打的序号&#xff0c;删除一行后下一行不会自动更新排序。 步骤&#xff1a;输入两个初始序号&…

org.springframework.jdbc.BadSqlGrammarException

Cause: java.sql.SQLSyntaxErrorException: Table ‘web.emp’ doesn’t exist 产生原因&#xff1a;web表找不到&#xff0c;所以可能数据库配置错误 spring.datasource.urljdbc:mysql://localhost:3306/web02 更改完成后运行成功

windows@注册表介绍@注册表的查看和编辑操作

文章目录 abstractrefs注册表的主要组件包括根键极其缩写名称&#x1f47a;子键特性 查看注册表&#x1f47a;使用powershell查看路径下的子路径声明概念Get-ChildItem查看注册表路径下的项Set-Location进入注册表路径举例说明查看文件系统某个路径下的项查看某个注册表路径的项…

系统分析师论文——论软件需求分析方法和工具的选用

现已临近2024年软考&#xff0c;周围一些报名参加系统分析师考试的“小伙伴”还未准备论文&#xff0c;我分享早年写的一些内容&#xff08;包括参加继续教育准备的论文&#xff09;&#xff0c;仅供大家结合最新考纲要求酌情参考&#xff0c;希望予人玫瑰&#xff0c;手有余香…

【CTF MISC】XCTF GFSJ0513 pdf Writeup(PDF隐写)

pdf 菜猫给了菜狗一张图&#xff0c;说图下面什么都没有 解法 打开 pdf&#xff0c;只看见一张图片。 用浏览器搜索 flag&#xff0c;发现图片中间藏了一行字。 复制出来&#xff0c;得到 flag。 Flag flag{security_through_obscurity}声明 本博客上发布的所有关于网络攻…

Arduino-ILI9341驱动开发TFT屏显示任意内容三

Arduino-ILI9341驱动开发TFT屏显示任意内容三 1.概述 这篇文章介绍使用ILI9341驱动提供的函数控制TFT屏显示字符串、图形、符号等等内容的编辑和展示。 2.硬件 2.1.硬件列表 名称数量Arduino Uno12.8" TFT彩色液晶触摸屏模块&#xff08;ILI9431&#xff09;110K 电阻…

从JSON数据到Pandas DataFrame:如何解析出所需字段

目录 一、引言 二、JSON数据的基本结构 三、使用Pandas从JSON数据中读取数据 四、从DataFrame中解析出所需字段 解析对象字段 解析嵌套对象字段 解析数组字段 五、案例与代码示例 六、总结 一、引言 在数据分析和处理的日常工作中&#xff0c;我们经常需要从各种…

基于单片机的空气质量检测系统设计(51+4G版)-设计说明书

设计摘要&#xff1a; 本设计是基于单片机的空气质量检测系统设计涉及以下主要功能&#xff0c;旨在监测甲烷和一氧化碳的浓度&#xff0c;并在浓度过高时采取相应措施&#xff0c;以确保室内空气质量的安全。该系统使用传感器对甲烷和一氧化碳的浓度进行检测。传感器将收集到…

大数据Scala教程从入门到精通第七篇:Scala在IDEA中编写Hello World

一&#xff1a;Scala在IDEA中编写Hello World 想让我们的idea支持scala的编写&#xff0c;需要安装一个插件。

kdb 调试内核-延迟驱动加载

说明: 系统在启动过程中&#xff0c;一些要调试的驱动在 "进入kdb 之前" 就已经加载了&#xff0c; 那么&#xff0c;我们就需要延迟 "加载驱动" #define XX_module_platform_driver(__platform_driver) \XX_module_driver(__platform_driver, platform_d…

以太ETH链市值机器人

在数字资产交易市场的浪潮中&#xff0c;如何高效地管理市值、提升交易流动性并保障资金安全&#xff0c;一直是交易所和项目方关注的焦点。市值管理机器人飞机//aishutuyu以太ETH链市值机器人凭借其卓越的功能和强大的安全保障&#xff0c;为数字资产交易市场带来了革命性的变…

python视频转码脚本

今天有一个临时的需求&#xff0c;就是需要将一个wmv的初步转码成mp4的格式。找了一圈&#xff0c;免费的工具少&#xff0c;即使有免费的工具&#xff0c;在功能上也是有所限制&#xff0c;或者会给你塞广告或者附带安装其它流氓小游戏或者杀毒程序。 我并非不支持正版&#…

矩阵稀疏扫描 - 矩阵

系列文章目录 文章目录 系列文章目录前言一、题目描述二、输入描述三、输出描述四、Java代码五、测试用例提示 前言 本人最近再练习算法&#xff0c;所以会发布一些解题思路&#xff0c;希望大家多指教 一、题目描述 如果矩阵中的许多系数都为零&#xff0c;那么该矩阵就是稀…

【Spring】初识 Spring AOP(面向切面编程)

目录 1、介绍AOP 1.1、AOP的定义 1.2、AOP的作用 1.3、AOP的核心概念及术语 2、AOP实现示例 3、EnableAspectJAutoProxy注解 1、介绍AOP 1.1、AOP的定义 AOP&#xff08;Aspect Orient Programming&#xff09;&#xff0c;直译过来就是面向切面编程&#xff0c;AOP 是一…

windows使用Docker-Desktop部署lobe-chat

文章目录 window安装docker-desktop下载和启动lobe-chatAI大语言模型的选择lobe-chat设置大模型连接 window安装docker-desktop docker-desktop下载地址 正常安装应用&#xff0c;然后启动应用&#xff0c;注意启动docker引擎 打开右上角的设置&#xff0c;进入Docker Engine设…

wangEditor富文本编辑器与layui图片上传

记录&#xff1a;js 显示默认的wangEditor富文本编辑器内容和图片 <style>body {background-color: #ffffff;}.layui-form-select dl{z-index:100000;} </style> <div class"layui-form layuimini-form"><div class"layui-form-item"…

【IC前端虚拟项目】验证环境env与base_teat思路与编写

【IC前端虚拟项目】数据搬运指令处理模块前端实现虚拟项目说明-CSDN博客 上一篇里解决了最难搞的axi_ram_model,接下来呢就会简单又常规一些了,比如这一篇要说的env和base_test的搭建。在这里我用了gen_uvm_tb脚本: 【前端验证】验证自动化脚本的最后一块拼图补全——gen_t…

一个全栈SpringBoot项目-Book Social Network

一个全栈SpringBoot项目-Book Social Network BSN是一个会员之间交换图书的社交网络平台。图书社交网络是一个全栈应用程序&#xff0c;使用户能够管理他们的图书收藏并与图书爱好者社区互动。它提供的功能包括用户注册、安全电子邮件验证、图书管理&#xff08;包括创建、更新…