【算法面试题】-06

news2024/11/27 6:37:03

智能成绩表

题目描述
小明来到学校当老师，需要将学生按考试总分或单科分数进行排名，你能帮帮他吗？

输入描述
第 1 行输入两个整数，学生人数 n 和科目数量 m。
0 < n < 100
0 < m < 10
第 2 行输入 m 个科目名称，彼此之间用空格隔开。

科目名称只由英文字母构成，单个长度不超过10个字符。

科目的出现顺序和后续输入的学生成绩一一对应。

不会出现重复的科目名称。

第 3 行开始的 n 行，每行包含一个学生的姓名和该生 m 个科目的成绩（空格隔开）

学生不会重名。
学生姓名只由英文字母构成，长度不超过10个字符。
成绩是0~100的整数，依次对应第2行种输入的科目。
第n+2行，输入用作排名的科目名称。若科目不存在，则按总分进行排序。

输出描述
输出一行，按成绩排序后的学生名字，空格隔开。成绩相同的按照学生姓名字典顺序排序。
在这里插入图片描述
在这里插入图片描述

class Student:
    def __init__(self):
        self.name = ""  # 学生名字
        self.scores = []  # 每门课成绩

students = [Student() for _ in range(10004)]  # 存储学生信息的数组
key_index = 0  # 要排序的课程名的下标

# 自定义排序函数
def student_comparator(a, b):
    if a.scores[key_index] != b.scores[key_index]:
        return b.scores[key_index] - a.scores[key_index]
    return (a.name > b.name) - (a.name < b.name)

n, m = map(int, input().split())  # 学生数量和课程数量
course_names = input().split()  # 课程名数组

for i in range(1, n + 1):
    student_info = input().split()
    students[i].name = student_info[0]  # 读取学生名字
    total_score = 0
    students[i].scores = list(map(int, student_info[1:]))  # 读取每门课成绩
    total_score = sum(students[i].scores)  # 计算总分
    students[i].scores.append(total_score)  # 将总分放入成绩数组末尾

key = input()  # 要排序的课程名
key_index = m  # 若没找到，赋值为最后一个位置，也就是总分
for i in range(m):  # 寻找这个课程名的下标
    if course_names[i] == key:
        key_index = i
        break

students = students[1:n+1]  # 仅保留有效学生信息
students.sort(key=lambda x: (x.scores[key_index], -ord(x.name[0])), reverse=True)  # 排序

for i in range(n):
    print(students[i].name, end=" ")

在这里插入图片描述

按身高和体重排队

题目描述
某学校举行运动会，学生们按编号(1、2、3…n)进行标识，现需要按照身高由低到高排列， 对身高相同的人，按体重由轻到重排列； 对于身高体重都相同的人，维持原有的编号顺序关系。请输出排列后的学生编号。

输入描述
两个序列，每个序列由n个正整数组成（0 < n <= 100）。

第一个序列中的数值代表身高，第二个序列中的数值代表体重。

输出描述
排列结果，每个数值都是原始序列中的学生编号，编号从1开始
用例1
输入
4
100 100 120 130
40 30 60 50

输出
2 1 3 4

说明
❝
输出的第一个数字2表示此人原始编号为2，即身高为100，体重为30的这个人。 由于他和编号为1的人身高一样，但体重更轻，因此要排在1前面。
❞
在这里插入图片描述

class Person:
    def __init__(self, height, weight):
        self.height = height
        self.weight = weight

n=int(input())
height=list(map(int,input().split()))
weight=list(map(int,input().split()))
person=[]
for i in range(n):
    person.append([height[i],weight[i],i+1])

person.sort(key=lambda x:(x[0],x[1],x[2]))

for i in range(n):
    print(person[i][2],end='')
    if i+1<n:
        print(" ",end='')

在这里插入图片描述

攀登者1

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

s=input()
s=s[1:len(s)-1]  #去掉开头的[和结尾的]
w=list(map(int,s.split(',')))  #转为数组
res=0
n=len(w)
for i in range(n):
    l,r=-10**9,-10**9  #初始化相邻元素值
    if i>0:
        l=w[i-1]
    if i+1<n:
        r=w[i+1]
    if w[i]>l and w[i]>r:
        res+=1
print(res)

在这里插入图片描述

攀登者2

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

def count_mountain_climbs(terrain, stamina):
    size = len(terrain)

    # 初始化数组 left_moves、right_moves，表示从左右两边攀爬到当前位置的代价
    left_moves, right_moves = [-1] * (size + 1), [-1] * (size + 1)

    # 计算从左边攀爬到当前位置的代价
    for i in range(size):
        if terrain[i] == 0 and i - 1 > 0 and terrain[i - 1] != 0:
            j = i - 1
            right_moves[i] = 0
            while j >= 0 and terrain[j] != 0:
                if terrain[j] > terrain[j + 1]:
                    right_moves[j] = right_moves[j + 1] + 2 * (terrain[j] - terrain[j + 1])
                else:
                    right_moves[j] = right_moves[j + 1] + (terrain[j + 1] - terrain[j])
                j -= 1

        # 计算从右边攀爬到当前位置的代价
        if terrain[i] == 0 and i + 1 < size and terrain[i + 1] != 0:
            j = i + 1
            left_moves[i] = 0
            while j < size and terrain[j] > 0:
                if terrain[j] > terrain[j - 1]:
                    left_moves[j] = left_moves[j - 1] + 2 * (terrain[j] - terrain[j - 1])
                else:
                    left_moves[j] = left_moves[j - 1] + (terrain[j - 1] - terrain[j])
                j += 1

    # 初始化数组 left_total、right_total，表示从左右两边攀爬到当前位置的总代价
    left_total, right_total = [-1] * (size + 1), [-1] * (size + 1)

    # 计算从左边攀爬到当前位置的总代价
    for i in range(1, size):
        if terrain[i] == 0:
            left_total[i] = 0
        else:
            if terrain[i - 1] > terrain[i]:
                left_total[i] = left_total[i - 1] + 2 * (terrain[i - 1] - terrain[i])
            else:
                left_total[i] = left_total[i - 1] + terrain[i] - terrain[i - 1]

    # 计算从右边攀爬到当前位置的总代价
    for i in range(size - 2, -1, -1):
        if terrain[i] == 0:
            right_total[i] = 0
        else:
            if terrain[i + 1] > terrain[i]:
                right_total[i] = right_total[i + 1] + 2 * (terrain[i + 1] - terrain[i])
            else:
                right_total[i] = right_total[i + 1] + terrain[i] - terrain[i + 1]

    climb_count = 0
    
    # 遍历山脉，判断是否可以攀爬
    for i in range(0, size):
        if terrain[i] > terrain[i - 1] and terrain[i] > terrain[i + 1]:
            min_cost = 10**15

            # 如果存在从左边攀爬到当前位置的代价，则更新 min_cost
            if left_moves[i] != -1:
                min_cost = min(min_cost, left_moves[i] + left_total[i])

            # 如果存在从右边攀爬到当前位置的代价，则更新 min_cost
            if right_moves[i] != -1:
                min_cost = min(min_cost, right_moves[i] + right_total[i])

            # 如果同时存在从左边和右边攀爬到当前位置的代价，则更新 min_cost
            if left_moves[i] != -1 and right_moves[i] != -1:
                min_cost = min(left_moves[i] + right_total[i], right_moves[i] + left_total[i], min_cost)

            # 如果最小代价小于等于 stamina，则可攀爬，计数加一
            if min_cost <= stamina:
                climb_count += 1

    return climb_count

# 从输入中读取整数数组 terrain
terrain_data = list(map(int, input().split()))

# 从输入中读取目标值 stamina
stamina_value = int(input())

# 输出计算结果
print(count_mountain_climbs(terrain_data, stamina_value))

在这里插入图片描述

分披萨

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

n = int(input())  # 输入披萨的数量
a = [int(input()) for i in range(n)]  # 输入每块披萨的美味值
dp = [[-1] * n for i in range(n)]  # 记忆化数组，用于存储已计算过的状态

def solve(L, R):
    # “馋嘴“选择一块披萨吃掉，对应端点移动
    if a[L] > a[R]:
        L = (L+1) % n
    else:
        R = (R+n-1) % n
    # 如果该状态已经计算过，则直接返回结果
    if dp[L][R] != -1:
        return dp[L][R]
    # 如果左右端点相同，则说明只剩下一块披萨，直接返回该披萨的美味值
    if L == R:
        dp[L][R] = a[L]
    else:
        # 分别计算选择左边披萨和选择右边披萨的情况下的最大美味值
        dp[L][R] = max(a[L] + solve((L+1)%n, R), a[R] + solve(L, (R+n-1)%n))
    return dp[L][R]

ans = 0
# 枚举吃货第一步取哪块披萨
for i in range(n):
    # 计算当前情况下吃货最多能吃到的披萨的美味值，并更新答案
    ans = max(ans, solve((i+1)%n, (i+n-1)%n) + a[i])

print(ans)  # 输出最多能吃到的披萨的美味值

在这里插入图片描述

机械绘图

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

n, e = map(int, input().split())
last_x = 0   # 记录上一个位置的横坐标
y = 0      # 记录起始点的纵坐标
area = 0    # 记录面积
for i in range(n):
    x, d = map(int, input().split())
    area += (x - last_x) * abs(y)   # 计算执行第i个指令后的增量面积
    y += d   # 更新纵坐标
    last_x = x   # 更新上一个位置的横坐标
area += (e - last_x) * abs(y)   # 计算终点的增量面积
print(area)

在这里插入图片描述

英文输入法

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

import re  # 导入re模块
 
s = input()  # 读取输入的字符串s
t = input()  # 读取输入的字符串t
 
s1 = re.split("[^a-zA-Z]", s)  # 使用正则表达式将字符串s按非字母字符分割
s2 = list(set(s1))  # 将分割后的结果转为集合去重，再转为列表
s2.sort()  # 对列表进行排序
s2 = list(filter(lambda x: x.startswith(t), s2))  # 过滤出以t开头的字符串
if len(s2) > 0:  # 如果过滤后的列表长度大于0
    print(" ".join(s2))  # 输出连接后的字符串
else:  # 否则
    print(t)  # 输出字符串t

在这里插入图片描述

小华最多能得到多少克黄金

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

from queue import Queue

m, n, k = map(int, input().split(" "))
if m == 0 or n == 0:
    print(0)
else:
    arr = []
    res = 0
    for i in range(m):
        tem = []
        for j in range(n):
            x = sum(int(digit) for digit in str(i))
            y = sum(int(digit) for digit in str(j))
            if x + y <= k:
                tem.append(1)
            else:
                tem.append(0)
        arr.append(tem)
    q = Queue()
    q.put([0, 0])
    arr[0][0] = 0
    dirs = [-1, 0, 1, 0, -1]
    while not q.empty():
        cur = q.get()
        res += 1
        i, j = cur
        for k in range(4):
            x = i + dirs[k]
            y = j + dirs[k + 1]
            if x < 0 or x >= m or y < 0 or y >= n or arr[x][y] == 0:
                continue
            arr[x][y] = 0
            q.put([x, y])
    print(res)

在这里插入图片描述

分配土地

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

n, m = map(int, input().split())
mp = {}

# 读取矩阵数据并记录非零元素的位置
for i in range(1, n + 1):
    j = 1
    for a in list(map(int, input().split())):
        if a != 0:
            if a not in mp:
                mp[a] = []
            mp[a].append((i, j))
        j += 1

ans = 0
# 遍历记录的非零元素及其位置，计算包含该元素的矩形的最大面积
for u, v in mp.items():
    minrow, maxrow, mincol, maxcol = float('inf'), 0, float('inf'), 0

    # 计算当前非零元素所在矩形的行列范围
    for t in v:
        minrow = min(minrow, t[0])
        maxrow = max(maxrow, t[0])
        mincol = min(mincol, t[1])
        maxcol = max(maxcol, t[1])

    # 计算当前矩形的面积，并更新最大面积
    ans = max(ans, (maxrow - minrow + 1) * (maxcol - mincol + 1))

print(ans)  # 输出最大矩形面积

在这里插入图片描述

字符串变换最小字符串

题目描述
给定一个字符串s，最多只能进行一次变换，返回变换后能得到的最小字符串（按照字典序进行比较）。

变换规则：交换字符串中任意两个不同位置的字符。

输入描述
一串小写字母组成的字符串s

输出描述
按照要求进行变换得到的最小字符串。
在这里插入图片描述

s = input()
t = sorted(s)

for i in range(len(s)):
    if s[i] != t[i]:
        for j in range(len(s) - 1, -1, -1):
            if s[j] == t[i]:
                s = s[:i] + s[j] + s[i+1:j] + s[i] + s[j+1:]
                break
        break

print(s)

在这里插入图片描述

考勤信息

题目描述
公司用一个字符串来表示员工的出勤信息

absent：缺勤

late：迟到

leaveearly：早退

present：正常上班

现需根据员工出勤信息，判断本次是否能获得出勤奖，能获得出勤奖的条件如下：

缺勤不超过一次；

没有连续的迟到/早退；

任意连续7次考勤，缺勤/迟到/早退不超过3次。

输入描述
用户的考勤数据字符串
记录条数 >= 1；
输入字符串长度 < 10000；
不存在非法输入；

如：

❝
2
present
present absent present present leaveearly present absent
❞
输出描述
根据考勤数据字符串，如果能得到考勤奖，输出”true”；否则输出”false”，
对于输入示例的结果应为：

❝
true false
❞
在这里插入图片描述

mp={"absent":0,"late":1,"leaveearly":2,"present":3}  #出勤信息映射
def check(s):
    cnts=[0]*4  #统计每一项的次数
    m=len(s)
    for i in range(m):
        cnts[mp[s[i]]]+=1
        if i>6: 
            cnts[mp[s[i-7]]]-=1
        if i>=6 and cnts[3]<4:  #正常上班天数<4，则说明其他天数超过3次
            return False
        if i and 1<=mp[s[i]]<=2 and 1<=mp[s[i-1]]<=2:  #连续的迟到，早退
            return False
    count=0  #单独统计所有的缺勤次数
    for x in s:
        if mp[x]==0:
            count+=1
    return count<=1
    
n=int(input())
for _ in range(n):
    s=input().split(' ')
    if check(s):
        print("true")
    else:
        print("false")

在这里插入图片描述

游戏分组/英雄联盟

题目描述
2020年题：

英雄联盟是一款十分火热的对战类游戏。每一场对战有10位玩家参与，分为两组，每组5人。每位玩家都有一个战斗力，代表着这位玩家的厉害程度。为了对战尽可能精彩，我们需要把玩家们分为实力尽量相等的两组。一组的实力可以表示为这一组5位玩家的战斗力和。现在，给你10位玩家的战斗力，请你把他们分为实力尽量相等的两组。请你输出这两组的实力差。

2023年题：

部门准备举办一场王者荣耀表演赛，有10名游戏爱好者参与，分5为两队，每队5人。每位参与者都有一个评分，代表着他的游戏水平。为了表演赛尽可能精彩，我们需要把10名参赛者分为实力尽量相近的两队。一队的实力可以表示为这一队5名队员的评分总和。 现在给你10名参与者的游戏水平评分，请你根据上述要求分队最后输出这两组的实力差绝对值。 例: 10名参赛者的评分分别为5 1 8 3 4 6 710 9 2，分组为 (135 8 10) (24 679)，两组实力差最小，差值为1。有多种分法，但实力差的绝对值最小为1。

输入描述
10个整数，表示10名参与者的游戏水平评分。范围在[1,10000]之间

输出描述
1个整数，表示分组后两组实力差绝对值的最小值.
在这里插入图片描述
在这里插入图片描述

a=list(map(int,input().split()))
ans=abs(sum(a[:5])-sum(a[5:]))
for i in range(1<<10):
    cnt=[0,0]
    val=[0,0]
    for j in range(10):
        cnt[(i>>j)&1]+=1
        val[(i>>j)&1]+=a[j]
    if cnt[0]==cnt[1]:
        ans=min(ans,abs(val[0]-val[1]))
print(ans)

在这里插入图片描述

精准核酸检测

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

while True:
    try:
       
        n = int(input())
        list_qz = list(map(int, input().split(",")))
        list_qz1 = list_qz.copy()
        list_rq = []
        for i in range(n):
            list_rq.append(list(map(int, input().split(","))))
       
        result = []
        vistied = []
        while list_qz:
            a = list_qz.pop(0)
            if a not in vistied:
                vistied.append(a)
                
                for i in range(n):
                    if list_rq[a][i] == 1 and i != a:
                        result.append(i)
                       
                        if sum(list_rq[i]) > 1:
                            list_qz.append(i)
 
      
        result = [i for i in result if i not in list_qz1]
        print(len(set(result)))
    except:
        break

在这里插入图片描述

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

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

相关文章

14双体系Java学习之数组

14双体系Java学习之数组

数组 ★小贴士 数组中保存固定数量的值&#xff0c;声明数组时需要制定数组中元素的类型&#xff0c;数组的长度在创建数组时设定。 保存数据的数据结构有很多&#xff0c;Java的标准函数库中就包含了许多复杂的数据结构&#xff0c;比如map、tree和set&#xff0c;以后会讲解的…
阅读更多...
数据结构·复杂度

数据结构·复杂度

目录 1 时间复杂度 2 大O渐进表示法 举例子&#xff08;计算时间复杂度为多少&#xff09; 3 空间复杂度 前言&#xff1a;复杂度分为时间复杂度和空间复杂度&#xff0c;两者是不同维度的&#xff0c;所以比较不会放在一起比较&#xff0c;但是时间复杂度和空间复杂度是用…
阅读更多...
Ubuntu 安装腾讯会议

Ubuntu 安装腾讯会议

1.官网下载 进入腾讯会议下载官网下载腾讯会议Linux客户端 选择x86_64格式安装包下载 若不知道自己的系统架构,输入 uname -a 在命令行结果中查看系统架构信息 2.终端命令安装 cd {你的下载路径} sudo dpkg -i TencentMeeting_0300000000_3.19.0.401_x86_64_default.publi…
阅读更多...
数据结构·二叉树(一)

数据结构·二叉树(一)

1. 树概念及结构 1.1 树的概念 树是一种非线性的数据结构&#xff0c;它是由n(n>0)个有限节点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一颗倒挂的树&#xff0c;也就是说它是根朝上&#xff0c;树叶朝下的。 有一个特殊的节点&#xff0c;称为根节点&#…
阅读更多...
嵌入式系统工程师错题总结

嵌入式系统工程师错题总结

笔者来介绍一下嵌入式系统工程师考试的一些易错题目 题目介绍  流水线指令计算公式&#xff1a;一条指令总时间max&#xff08;单个指令执行时间&#xff09;*&#xff08;指令数-1&#xff09;  平均故障间隔时间  ICMP协议&#xff1a;传送通信问题相关的消息。 …
阅读更多...
sqlserver中将csv非空间数据(带点坐标)转为空间数据

sqlserver中将csv非空间数据(带点坐标)转为空间数据

1、导入csv数据 2、修改字段shape为空间字段 ALTER TABLE FJPOIHB66 ALTER COLUMN shape geometry;3、空间字段转字符串 UPDATE FJPOIHB66 SET shape geometry::STGeomFromText(CONVERT(nvarchar(254),shape), 4326);4、设置主键字段 5、即可
阅读更多...
141 Linux 系统编程18，线程，ps –Lf 进程 查看LWP，线程间共享数据，优缺点，编译加-lpthread，

141 Linux 系统编程18，线程，ps –Lf 进程 查看LWP，线程间共享数据，优缺点，编译加-lpthread，

一 线程概念 什么是线程 LWP&#xff1a;light weight process 轻量级的进程&#xff0c;本质仍是进程(在Linux环境下) 进程&#xff1a;独立地址空间&#xff0c;拥有PCB 线程&#xff1a;有独立的PCB&#xff0c;但没有独立的地址空间(共享) 区别&#xff1a;在于是否共…
阅读更多...
C++vector的模拟实现

C++vector的模拟实现

文章目录 模拟实现1. 迭代器2. 容量操作&#xff08;1&#xff09;size和capacity&#xff08;2&#xff09;reserve&#xff08;3&#xff09; resize 3. 元素访问&#xff08;1&#xff09;下标 [ ] 4. 修改操作&#xff08;1&#xff09;push_back&#xff08;2&#xff09…
阅读更多...
【死磕Elasticsearch】从实战中来，到实战中去

【死磕Elasticsearch】从实战中来，到实战中去

文章目录 写在前面&#xff1a;1、索引阻塞的种类2、什么时候使用阻塞&#xff1f;场景1&#xff1a;进行系统维护场景。场景2&#xff1a;保护数据不被随意更改场景。场景3&#xff1a;优化资源使用的场景。场景4&#xff1a;遵守安全规则场景。 3、添加索引阻塞API4、解除设置…
阅读更多...
使用jquery的autocomplete属性实现联想补全操作

使用jquery的autocomplete属性实现联想补全操作

平时使用百度&#xff0c;淘宝等软件搜索时&#xff0c;常见一个搜索框联想提示&#xff0c;感觉确实好用但没有研究过原理&#xff0c;最近恰巧工作中遇到一个同样的场景&#xff0c;不同于大厂使用高端的Python&#xff0c;这次需要使用jQuery的autocomplete属性来自动联想补…
阅读更多...
git撤回代码提交commit或者修改commit提交注释

git撤回代码提交commit或者修改commit提交注释

执行commit后&#xff0c;还没执行push时&#xff0c;想要撤销之前的提交commit 撤销提交 使用命令&#xff1a; git reset --soft HEAD^命令详解&#xff1a; HEAD^ 表示上一个版本&#xff0c;即上一次的commit&#xff0c;也可以写成HEAD~1 如果进行两次的commit&#xf…
阅读更多...
Singularity（二）| 安装singularity工具

Singularity（二）| 安装singularity工具

Singularity&#xff08;二&#xff09;| 安装singularity工具 以默认安装 Ubuntu 22.04 (jammy) 发行版的 WSL 2 (Windows Subsystem for Linux 2) 为例&#xff1a; 参考&#xff1a;官方快速安装向导 安装系统依赖项 首先在主机上安装开发工具和库&#xff0c;在基于 debian…
阅读更多...
【黑马程序员】python函数

【黑马程序员】python函数

文章目录 函数什么是函数为什么学习函数函数定义函数的传入参数函数的返回值返回值基础None返回值 函数说明文档函数的嵌套调用定义代码示例 全局变量和局部变量全局变量global变量局部变量 函数综合案例 函数 什么是函数 组织好的&#xff0c;可重复使用的、用来实现特定功能…
阅读更多...
5.Java并发编程—JUC线程池架构

5.Java并发编程—JUC线程池架构

JUC线程池架构 在Java开发中&#xff0c;线程的创建和销毁对系统性能有一定的开销&#xff0c;需要JVM和操作系统的配合完成大量的工作。 JVM对线程的创建和销毁&#xff1a; 线程的创建需要JVM分配内存、初始化线程栈和线程上下文等资源&#xff0c;这些操作会带来一定的时间和…
阅读更多...
【C语言步行梯】自定义函数、函数递归详谈

【C语言步行梯】自定义函数、函数递归详谈

&#x1f3af;每日努力一点点&#xff0c;技术进步看得见 &#x1f3e0;专栏介绍&#xff1a;【C语言步行梯】专栏用于介绍C语言相关内容&#xff0c;每篇文章将通过图片代码片段网络相关题目的方式编写&#xff0c;欢迎订阅~~ 文章目录 什么是函数库函数自定义函数函数执行示例…
阅读更多...
数据结构 第2章：线性表

数据结构 第2章：线性表

文章目录 2.1 线性表的定义和操作2.1.1 线性表的基本概念2.1.2 线性表的基本操作 2.2. 顺序表2.2.1. 顺序表的基本概念2.2.2. 顺序表的实现2.2.3. 顺序表的基本操作 2.3 链表2.3.1 单链表的基本概念2.3.2 单链表的实现2.3.3 单链表的插入2.3.4. 单链表的删除2.3.5. 单链表的查找…
阅读更多...
VB 数据质量诊断软件(分析数据的完整性,合理性,准确性)-139-(代码+程序说明)

VB 数据质量诊断软件(分析数据的完整性,合理性,准确性)-139-(代码+程序说明)

转载地址http://www.3q2008.com/soft/search.asp?keyword139 前言: 为何口出狂言,作任何VB和ASP的系统, 这个就是很好的一个证明 :) 又有些狂了... 数据库操作谁都会,接触的多了也没什么难的,VB编程难在哪?算法上,这个是一个算法题的毕业设计 哈哈忙活了足足有一○小时, …
阅读更多...
2024年最新阿里云和腾讯云云服务器价格租用对比

2024年最新阿里云和腾讯云云服务器价格租用对比

2024年阿里云服务器和腾讯云服务器价格战已经打响&#xff0c;阿里云服务器优惠61元一年起&#xff0c;腾讯云服务器61元一年&#xff0c;2核2G3M、2核4G、4核8G、4核16G、8核16G、16核32G、16核64G等配置价格对比&#xff0c;阿腾云atengyun.com整理阿里云和腾讯云服务器详细配…
阅读更多...
C语言 ——关键字

C语言 ——关键字

关键字&#xff1a;在C语言中被赋予了特定含义的英文单词&#xff0c;一共有32个关键字 * 关键字全部小写 * 在特定的编译器中&#xff0c;关键字是高亮显示的 vs&#xff1a;蓝色或者紫色 vs&#xff1a;蓝色 下图圈起来的都是关键字 c auto break case char const con…
阅读更多...
Kafka消费者重平衡

Kafka消费者重平衡

「&#xff08;重平衡&#xff09;Rebalance本质上是一种协议&#xff0c;规定了一个Consumer Group下的所有Consumer如何达成一致&#xff0c;来分配订阅Topic的每个分区」。 比如某个Group下有20个Consumer实例&#xff0c;它订阅了一个具有100个分区的Topic。 正常情况下&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023