蓝桥杯(2):python基础算法【上】

时间复杂度、枚举、模拟、递归、进制转换、前缀和、差分、离散化

1 时间复杂度

重要是看循环,一共运行了几次

1.1 简单代码看循环

#时间复杂度1
n = int(input())
for i in range(1,n+1):
    for j in range(0,i):
        pass
###时间复杂度:1+2+3+....+n=n(1+n)/2 所以时间复杂度是o(n^2)


#时间复杂度2
for i in range(1,n+1):
    for j in range(0,n,i):
        pass
###时间复杂度:n+ n/2+ n/3+ .....+n/n = nlog(n)

1.2 复杂代码

1.2.1 归并排序

通过不断地往回带入得出的:一共带入了多少次呢?

看n可以被多少个2整除就可以 个数为:log_2^n ,则有log_2^n个o(n)叠加在一起,所以复杂度为o(nlogn)

2 枚举

2.1 定义

通过逐个尝试,遍历所有的解

2.2 流程

2.3 例子

注意字符串再 in上的伟大应用!!!!

2.3.1 简单计算

a = input()
sum1,sum2=0,0
for s in a:
    if s in "aeiou":
        sum1 +=1
    else:
        sum2+=1
print(sum1)
print(sum2)

2.3.2 洁净数

问题描述:小明不喜欢数字2,包括数位上包含数字2 的数,如果没有2则称为洁净数

n = int(input())
ans = 0
for i in range(1,n+1):
    if "2" not in str(i):
        ans+=1
print(ans)

2.3.3 扫雷【初用矩阵哦】

问题描述:

#枚举
def input_list():
    return list(map(int,input().split()))


n_m = input_list()
n = n_m[0]
m = n_m[1]
a = []
for i in range(n):
    a.append(input_list())
b = [[0]*m for i in range(n)] #生成n行m列的矩阵!
# print(b)

#表示方向
dir = [(1,0),(0,1),(-1,0),(0,-1),(-1,-1),(-1,1),(-1,1),(1,1)]  #一共8个方向

for i in range(0,n):
    for j in range(0,m):
        if a[i][j] == 1:
            b[i][j]=9
        else:
            b[i][j]=0
            for k in range(8):
                x,y = i+dir[k][0],j+dir[k][1]
                if 0<=x<n and 0<=y<m:
                    if a[x][y]==1:
                        b[i][j] +=1
        print(b[i][j],end = ' ')
    print()

2.3.4   容斥定理

容斥定理:

1到n中a的倍数有 n//a 个

1到n中b的倍数有 n//b 个

1到n中ab的倍数有 n//ab 个

那么1到n中是a或者b的倍数有n//a+n//b-n//ab 个

3 模拟

3.1 定义

3.2 例题

3.2.1 喝饮料

n = int(input())
ans = n
while True:
    if n >=3:
        ans += n//3
        n = n//3+n%3
    else:
        break
print(ans)

3.2.2 像素模糊

问题描述:

像素在中间就是除以9,在别上就是除的数不定

def input_list():
    return list(map(int,input().split()))


n,m = input_list()
b = [[0]*m for i in range(n)]
a = []
dir = [(0,-1),(0,1),(-1,0),(1,0),(-1,-1),(1,-1),(1,1),(-1,1)]
for i in range(n):
    a.append(input_list())
for i in range(n):
    for j in range(m):
        count = 1
        sum_= a[i][j]
        for k in range(8):
            x,y = i+dir[k][0],j+dir[k][1]
            if 0<=x<n and 0<=y<m:
                count += 1
                sum_ += a[x][y]
        b[i][j] = int(sum_/count)
        print(b[i][j],end=' ')
    print()
#或者这样输出!!!
# for i in b:
#     print(' '.join(map(str,i)))

3.2.3 螺旋矩阵

用螺旋的方式填充矩阵!就是思考的那种形状

1   2   3   4

12 13 14  5

11  16 15 6

10   9   8  7

def input_list():
    return list(map(int,input().split()))


n,m = input_list()
x,y = 0,0
value = 1
a=[[0]*m for i in range(n)]

a[x][y]=value
print(a)
while value < n*m:
    while y+1 < m and a[x][y+1]==0:
        y = y + 1
        value += 1
        a[x][y]=value

    while x+1<n and a[x+1][y]==0:
        x=x+1
        value +=1
        a[x][y]=value

    while y-1>=0 and a[x][y-1] ==0:
        y = y-1
        value += 1
        a[x][y]=value

    while x-1>0 and a[x-1][y] == 0:
        x = x-1
        value += 1
        a[x][y]= value

for i in a:
    print(' '.join(map(str,i)))

3.2.4 对折矩阵

1 2 6 7

3 5 8 11

4 9 10 12

def input_list():
    return list(map(int,input().split()))


n,m = input_list()
a = [[0]*m for i in range(n)]
value = 1
a[0][0]=1
y,x = 0,0 # n,m
while value < n*m:

    if x+1 < m and a[y][x+1]==0:
        value += 1
        x=x+1
        a[y][x]=value

    while y+1<n and x-1>=0 and a[y+1][x-1]==0:
        value+=1
        y = y+1
        x = x-1
        a[y][x]=value

    if y+1<n and a[y+1][x] ==0:
        value +=1
        y = y+1
        a[y][x]=value

    while y-1>=0 and x+1<m and a[y-1][x+1] == 0:
        value +=1
        y = y-1
        x = x+1
        a[y][x] = value
for i in a:
    print(" ".join(map(str,i)))

 

4 递归

4.1 定义

4.2 汉诺塔问题

4.2.1 可以跳步的

(即可以从A直接到C)

def move(n,A,B,C):
    #n个盘子从A移动到C,借助B
    if n==0:
        return
    move(n-1,A,C,B)
    print(A,"-->",C)
    move(n-1,B,A,C)
move(3,"A","B","C")

4.2.2 不可以跳步

即只能相邻的移动,不能A直接到C

def move1(n,A,B,C):
    if n==0:
        return
    move1(n-1,A,B,C)
    print(A,"-->",B)
    move1(n-1,C,B,A)
    print(B,"-->",C)
    move1(n-1,A,B,C)
move1(2,"A","B","C")

4.3 找自然数

只需要找到n前面可以加几个数 ,是相同的子问题!!

代码:

def f(n):
    if n == 1:
        return 1
    ans = 1
    for i in range(1,n//2 +1):
        ans += f(i)
    return ans
print(f(6))
# 6
# 16
# 26
# 126
# 36
# 136

4.4 快速排序和归并排序

见第一节中有哦

快速排序:找基准 时间复杂度0(nlogn)

def partition(a,left,right):
    stand = a[left]
    idx = left+1
    for i in range(left+1,right+1):
        if a[i]<stand:
            a[idx],a[i]=a[i],a[idx]
            idx +=1
    a[idx-1],a[left]=a[left],a[idx-1]
    #返回基准所在的位置
    return idx-1


def quicksort(a,left,right):
    if left == right:
        return a

    if left<right:
        mix = partition(a,left,right)
        quicksort(a,left,mix-1)
        quicksort(a,mix+1,right)
        return a

a = [3,4,5,6,2,1]
left = 0
right = 5
print(quicksort(a,left,right))

归并排序:

def merge(A,B):
    C=[]
    while len(A)!=0 and len(B)!=0:
        if A[0]<=B[0]:
            C.append(A.pop(0))
        else:
            C.append(B.pop(0))
    C +=A
    C+=B
    return C
# A=[1,3,5]
# B=[2,4]
# print(merge(A,B))


def merge_sort(a):

    if len(a)<2:
        return a
    mix = len(a)//2
    left = merge_sort(a[0:mix])
    right = merge_sort(a[mix:len(a)])
    a = merge(left,right)
    return a

a = [4,3 ,2,5,1]
print(merge_sort(a))

5 进制转换

5.1 基数和权

按权展开:

5.2 代码实现

5.2.1 K进制转换成10进制

int_to_char="0123456789ABCDEF"
char_to_int ={}
for idx,chr in enumerate(int_to_char):
    char_to_int[chr] =idx
print(char_to_int)
# print(char_to_int["1"])
# x = "1234"
# x = x[::-1]
# print(x)

def K_to_Ten(k,x):
    ans = 0
    x = x[::-1] #把顺序颠倒了
    for i in range(len(x)):
        ans = ans + char_to_int[str(x[i])] * k**i
    return ans

k = 8
x = "3506"
print(K_to_Ten(k,x))

5.2.2 十进制转任何进制

代码:

int_to_char="0123456789ABCDEF"
char_to_int ={}
for idx,chr in enumerate(int_to_char):
    char_to_int[chr] =idx

def Ten_to_k(k,x):
    ans = ""
    while x !=0:
        ans = ans + int_to_char[x%k]
        x = x//k
    return ans[::-1]

k=2
x=19
print(Ten_to_k(k,x))

5.2.3 任意进制之间的转换

以十进制作为桥梁

def k_k(m,n,x):
    #m进制转n进制,数字是x现在
    #第一步:m进制转10进制
    int_to_char = '0123456789ABCDEF'
    char_to_int = {}
    for idx,char in enumerate(int_to_char):
        char_to_int[char] = idx
    x = str(x)[::-1]
    y = 0
    for i in range(len(x)):
        y = y+char_to_int[str(x[i])]*m**i
    #第二步:十进制转n进制
    z = ""
    while y!=0:
        z = z+int_to_char[int(y)%n]
        y = y//n
    z = z[::-1]
    return z

m = 2
n = 16
x = 10010
print(k_k(m,n,x))

6 一维前缀和(区间)

6.1 定义

前缀和的目的是:快速求出去区间之和!

6.2 代码实现前缀和

def get_presum(a):
    n = len(a)
    sum = [0]*n
    sum[0] = a[0]
    for i in range(1,n):
        sum[i] = sum[i-1]+a[i]
    return sum

print(get_presum([1,2,3,4,5]))

6.3 前缀和实现区间差

def get_sum(sum,l,r):
    if l==0:
        return sum[r]
    else:
        return  sum[r] - sum[l-1]

a = [1,2,3,4,5]
sum = get_presum(a)
print(sum)
b = get_sum(sum,1,4)
print(b)

6.4 具体例题

6.4.1 例题1求k次方的和

注意题目中说的:"请对每一个查询输出一个答案,答案对10的9次方+7取模"的意思是:答案对10的9次方+7 取余数!!【NO!!!不是的】请看下面的文章!!! 

编程语言中,取余和取模的区别到底是什么? - 知乎 (zhihu.com)

取余和取模在 都是正数的时候结果相同,但是到符号不同的时候会出现不同:

取余,遵循尽可能让商向0靠近的原则

取模,遵循尽可能让商向负无穷靠近的原则

原则的解释可见:负数取余mod_负数mod运算规则-CSDN博客

综上所述:蓝桥杯里出现取模的话:!!!你就这么写:

((sum[r]-sum[l-1])+mod)%mod
def input_list():
    return list(map(int,input().split()))

mod =1000000007
def ger_presum(a):

    n = len(a)
    sum = [0]*n
    sum[0]=a[0]
    for i in range(1,n):
        sum[i] = (sum[i-1]+ a[i])%mod

    return sum


def get_sum(a,l,r):

    if l==0:
        return a[r]
    else:
        return ((a[r]-a[l-1])+mod)%mod


n,m = input_list()
a = input_list()
sum_list = []
for i in range(1,6):
    tmp_a = [x**i for x in a]
    sum_list.append(ger_presum(tmp_a))

for j in range(m):
    l,r,k = input_list()
    print(get_sum(sum_list[k-1],l-1,r-1))

6.4.2 平衡串

区间的统计都可以看作是前缀和!!!!当一个问题套三层循环的时候时间复杂度就太高了,容易不通过!

输出的最长平衡串的意思是:找到最长子串,所以基本的思想就是:遍历左端点再遍历右端点

def get_presum(a):
    n = len(a)
    sum = [0]*n
    sum[0] = a[0]
    for i in range(1,n):
        sum[i] = sum[i-1]+a[i]
    return sum


def get_sum(a,l,r):
    if l==0:
        return a[r]
    else:
        return a[r]-a[l-1]

s = input()
n = len(s)
a = []
for i in s:
    if i=="L":
        a.append(1)
    else:
        a.append(-1)
sum  = get_presum(a)
ans = 0
for i in range(0,n):
    for j in range(i,n):
        if get_sum(sum,i,j) == 0:
            ans = max(ans,j-i+1)
print(ans)

7 二维前缀和(矩阵)

7.1 定义

7.1.1 sum[i][j]之和

找递推式不能每一个都用两重迭代去求

7.1.2 (x1,y1)-(x2,y2)之和

7.2 代码实现

7.2.1 左上角全部

推荐使用方法2:在外围加上一行一列!

#方法1:使用原矩阵!
#输出一个二维矩阵
def output(a):
    n = len(a)
    for i in range(0,n):
        print(" ".join(map(str,a[i][0:])))

def input_list():
    return list(map(int,input().split()))

n,m = input_list()
a = [[0]*(m) for i in range(n)]
sum_ = [[0]*(m) for i in range(n)]

#输入一个二维数组
for i in range(0,n):
    a[i] = input_list()
output(a,n)

for i in range(0,n):
    for j in range(0,m):
        sum_[0][0] = a[0][0]
        if i==0 and j!=0:
            sum_[i][j] = a[i][j]+sum_[i][j-1]
            continue
        if i!=0 and j==0:
            sum_[i][j] = a[i][j]+sum_[i-1][j]
            continue
        sum_[i][j] = sum_[i][j-1]+sum_[i-1][j]+a[i][j]-sum_[i-1][j-1]
output(sum_,n)

#方法2 在外围扩充一行一列0
def output(a):
    n = len(a)
    for i in range(1,n):
        print(" ".join(map(str,a[i][1:])))


def input_list():
    return list(map(int,input().split()))

n,m = input_list()
a=[[0]*(m+1) for i in range(n+1)]
sum_ = [[0]*(m+1) for i in range(n+1)]
for i in range(1,n+1):
    a[i] = [0]+input_list()
for i in range(1,n+1):
    for j in range(1,m+1):
        sum_[i][j] = sum_[i][j-1]+sum_[i-1][j] +a[i][j] -sum_[i-1][j-1]
output(a)
output(sum_)

#例题

7.2.2 任意子矩阵

#方法2 在外围扩充一行一列0
def output(a):
    n = len(a)
    for i in range(1,n):
        print(" ".join(map(str,a[i][1:])))


def input_list():
    return list(map(int,input().split()))

n,m = input_list()
a=[[0]*(m+1) for i in range(n+1)]
sum_ = [[0]*(m+1) for i in range(n+1)]
for i in range(1,n+1):
    a[i] = [0]+input_list()
for i in range(1,n+1):
    for j in range(1,m+1):
        sum_[i][j] = sum_[i][j-1]+sum_[i-1][j] +a[i][j] -sum_[i-1][j-1]
output(a)
output(sum_)
print(sum_)
#
#任意子矩阵
x1,y1 =input_list()
x2,y2 =input_list()
sum1 = sum_[x2][y2] - sum_[x1-1][y2] - sum_[x2][y1-1] +sum_[x1-1][y1-1]
print(sum1)

7.3 例题

7.3.1 统计子矩阵

def output(a):
    n = len(a)
    for i in range(1,n):
        print(" ".join(map(str,a[i][1:])))


def input_list():
    return list(map(int,input().split()))


def get_a(n,m):
    a = [[0] * (m + 1) for i in range(n + 1)]
    for i in range(1,n+1):
        a[i] = [0]+input_list()
    return a


def get_presum(a,n,m):
    sum_ = [[0]*(m+1) for i in range(n+1)]
    for i in range(1,n+1):
        for j in range(1,m+1):
            sum_[i][j] = sum_[i][j-1]+sum_[i-1][j] +a[i][j] -sum_[i-1][j-1]
    return sum_

#任意子矩阵
def get_sum(sum_,x1,y1,x2,y2):
    sum1 = sum_[x2][y2] - sum_[x1-1][y2] - sum_[x2][y1-1] +sum_[x1-1][y1-1]
    return sum1

#例题1
N,M,K= input_list()
a = get_a(N,M)
sum_ = get_presum(a,N,M)

ans = 0
for x1 in range(1,N+1):
    for y1 in range(1,M+1):
        for x2 in range(x1,N+1):
            for y2 in range(y1,M+1):
                sum1 = get_sum(sum_,x1,y1,x2,y2)
                if sum1<=K:
                    ans +=1
print(ans)

8 差分

8.1 定义

差分数组是任意两个数字求差

很重要的一点是:!!!差分数组的前缀和等于原数组!!!

得到差分数组后,将原数组加上差分数组就是最后的结果!

8.2 例子

8.2.1 区间更新

def input_list():
    return list(map(int,input().split()))

#注意这个数组是从1开始的!!!!意味着给定的下标和实际的下标相差1
while True:
    try:
        n,m = input_list()
        # print(n,type(n))
        # print(m)
        a = input_list()
        diff = [0]*(n+1)
        diff[0] = a[0]
        for i in range(1,n):
            diff[i] = a[i] -a[i-1]
        #给定的m个操作
        for j in range(m):
            # print("121312")
            x,y,z = input_list()
            x = x-1
            y = y-1
            diff[x] += z
            diff[y+1] -=z
            a[0] = diff[0]
            for i in range(1,n):
                a[i] = diff[i]+a[i-1]
        print(' '.join(map(str,a)))


    except:
        break

9 二维差分数组

9.1 定义

在(x1,y1)到(x2,y2)这个矩阵里的元素都加上固定的值!哦

用上差分数组降低时间复杂度!

过程:

加上的3会把那一行:3那一个格后面的所有都加上3,所以用-3平衡掉影响!

找到差分数组后将原数组和它进行运算即可!

9.2 代码实现



##二维的
def input_list():
    return list(map(int,input().split()))


def output(a):
    n = len(a)
    for i in range(1,n-1):
        print(" ".join(map(str,a[i][1:m+1])))


n,m = input_list()
a = [[0]*(m+2) for i in range(n+2)]
# output(a)
for i in range(1,n+1):
    a[i] = [0] +input_list() +[0]
diff =[[0]*(m+2) for i in range(n+2)]
# output(a)

for i in range(1,n+1):
    for j in range(1,m+1):
        diff[i][j] = a[i][j] - a[i-1][j] - a[i][j-1] +a[i-1][j-1]
# output(diff)
print("请输入x1,y1:")
x1,y1 = input_list()

print('请输入x2,y2:')
x2,y2 = input_list()
print("请输入需要增加的元素:")
k = int(input())

diff[x1][y1] +=k
diff[x1][y2+1] -=k
diff[x2+1][y1] -=k
diff[x2+1][y2+1] +=k

# output(diff)
for i in range(1,n+1):
    for j in range(1,m+1):
        a[i][j] =diff[i][j]+ a[i - 1][j]+a[i][j - 1]-a[i-1][j-1]

output(a)

10 离散化

10.1 定义(去重排序,返回下标)

10.2 算法步骤

10.3 代码

def Discrete(a):
    #a是输入的列表#return是返回的结果
    b = list(set(a))
    b = sorted(b)
    print(b)
    value = list(range(0,len(b)))
    dic = dict(zip(b,value))

    ans = []
    #对a中的每一个x返回b的下标
    for x in a:
        ans.append(dic[x])
    return ans

a = list(map(int,input().split()))
print(Discrete(a))


 

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

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

Ambari——编译——解决替换yarn 版本后 系mvn 打包找不到yarn 文件问题

您的支持是我继续创作与分享的动力源泉!!! 您的支持是我继续创作与分享的动力源泉!!! 您的支持是我继续创作与分享的动力源泉!!! 报错原因&#xff1a; [ERROR] Failed to execute goal com.github.eirslett:frontend-maven-plugin:1.4:yarn (yarn install) on project amb…

python综合实战案例-数据分析

Python是进行数据分析的好工具&#xff0c;今天就是借助一个案例给大家进行数据分析讲解。 本例设计一个log.txt⽂件&#xff0c;该文件记录了某个项⽬中某个 api 的调⽤情况&#xff0c;采样时间为每分钟⼀次&#xff0c;包括调⽤次数、响应时间等信息&#xff0c;⼤约18万条数…

基于Java中的SSM框架实现快餐店线上点餐系统项目【项目源码+论文说明】计算机毕业设计

基于Java中的SSM框架实现快餐店线上点餐系统演示 摘要 随着计算机互联网的高速发展。餐饮业的发展也加入了电子商务团队。各种网上点餐系统纷纷涌现&#xff0c;不仅增加了商户的销售量和营业额&#xff0c;而且为买家提供了极大的方便&#xff0c;足不出户&#xff0c;就能订…

备战蓝桥杯---牛客寒假算法基础集训6

1.并查集数学 分析&#xff1a; 首先我们知道算数基本定理&#xff0c;如果两个数有大于1的质因子&#xff0c;那么我们就需要把他们放在同一个集合&#xff0c;因此我们可以用欧拉刷出1e6范围内的素数&#xff0c;然后依次看输入的数。 拿202*2*5举例子&#xff0c;我们在求…

检索增强生成(RAG)技术:实现流程、作用及应用案例

一. RAG简介 在自然语言处理&#xff08;NLP&#xff09;领域中&#xff0c;检索增强生成&#xff08;Retrieval-Augmented Generation, RAG&#xff09;技术巧妙地结合了信息检索与神经网络生成模型的力量&#xff0c;通过在生成过程中引入相关的外部信息&#xff0c;实现了在…

【Vue3】组件通信以及各种方式的对比

方式一&#xff1a;props 「父」向「子」组件发送数据 父组件&#xff1a; 定义需要传递给子组件的数据&#xff0c;并使用 v-bind 指令将其绑定到子组件的 props 上。 <template><child-component :message"parentMessage" /> </template><sc…

6. ping在windows中的常见用法

&#xff08;1&#xff09;ping简介 1.ping简介 &#xff08;2&#xff09;在windows上用法 1.直接ping 对方IP&#xff08;无参数时&#xff09; 2.ping -t IP (长ping) 3.ping -n 包数量 4.ping -l 字节大小 IP 5.如何批量的ping一个网段&#xff1f; &#xff08;1&a…

24计算机考研调剂 | 【官方】山东工商学院

山东工商学院 考研调剂招生信息 招生专业&#xff1a; 学院概况&#xff1a; 计算机科学与技术学院始建于1999年&#xff0c;拥有计算机科学与技术一级学科硕士点,在2022软科中国最好学科排名中&#xff0c;计算机科学与技术学科位列全国第104位。在2022年“软科”中国大学专…

【MySQL】2.MySQL数据库的基本操作

目录 数据库基本操作 查看数据库信息 查看数据库结构 显示数据表的结构&#xff08;字段&#xff09; 常用的数据类型 数据库管理操作 SQL语句概述 SQL分类 1.DDL&#xff1a;数据定义语言 1.1创建数据库和表 创建数据库 创建数据表 1.2删除数据库和表 删除数据表…

音视频领域首个,阿里云推出华为鸿蒙 HarmonyOS NEXT 版音视频 SDK

近日&#xff0c;阿里云在官网音视频终端 SDK 栏目发布适配 HarmonyOS NEXT 的操作文档和 SDK&#xff0c;官宣 MediaBox 音视频终端 SDK 全面适配 HarmonyOS NEXT。 此外&#xff0c;阿里云播放器 SDK 也在华为开发者联盟官网鸿蒙生态伙伴 SDK 专区同步上线&#xff0c;面向所…

SpringCloud-记

目录 什么是SpringCloud 什么是微服务 SpringCloud的优缺点 SpringBoot和SpringCloud的区别 RPC 的实现原理 RPC是什么 eureka的自我保护机制 Ribbon feigin优点 Ribbon和Feign的区别 什么是SpringCloud Spring Cloud是一系列框架的有序集合。它利用Spring Boot的开发…

STM32之HAL开发——系统定时器(SysTick)

系统定时器&#xff08;SysTick&#xff09;介绍 SysTick—系统定时器是属于 CM3 内核中的一个外设&#xff0c;内嵌在 NVIC 中。系统定时器是一个 24bit的向下递减的计数器&#xff0c;计数器每计数一次的时间为 1/SYSCLK&#xff0c;一般我们设置系统时钟 SYSCLK等于 72M。当…

人工智能之Tensorflow变量作用域

在TensoFlow中有两个作用域&#xff08;Scope&#xff09;&#xff0c;一个时name_scope ,另一个是variable_scope。variable_scope主要给variable_name加前缀&#xff0c;也可以给op_name加前缀&#xff1b;name_scope给op_name加前缀。 variable_scope 通过所给的名字创建或…

【电路笔记】-场效应管(FET)电流源

场效应管(FET)电流源 文章目录 场效应管(FET)电流源1、概述2、偏置结 FET2.1 N沟道JFET偏置2.2 N沟道JFET输出特性3、JFET 作为恒流源4、JFET 零电压偏置5、JFET 负电压偏置6、FET 恒流源示例17、JFET电流源8、FET 恒流源示例29、FET 恒流源示例310、总结FET 恒流源使用 JFET 和…

Java学习笔记NO.26

T3.以面向对象的思想&#xff0c;编写自定义类描述IT从业者。 设定属性包括&#xff1a;姓名&#xff0c;年龄&#xff0c;技术方向&#xff0c;工作年限&#xff1b; 方法包括&#xff1a;工作。 要求&#xff1a; (1)设置属性的私有访问权限&#xff0c;通过公有的get,set…

业务服务:redisson

文章目录 前言一、配置1. 添加依赖2. 配置文件/类3. 注入redission3. 封装工具类 二、应用1. RedisUtils工具类的基本使用 三、队列1. 工具类2. 普通队列3. 有界队列&#xff08;限制数据量&#xff09;4. 延迟队列&#xff08;延迟获取数据&#xff09;5. 优先队列&#xff08…

Netty - 五种 I/O 多路复用机制 select、poll、epoll、kqueue、iocp(windows) 对比

文章目录 Preselect、poll、epoll、kqueue、iocp(windows) Pre 高性能网络编程 - select、 poll 、epoll 、libevent select、poll、epoll、kqueue、iocp(windows) 这里我将对比一下常见的多路复用技术&#xff1a;select、poll、epoll、kqueue 和 IOCP&#xff08;Windows&a…

分区表索引失效导致业务异常

业务无法正常进行&#xff0c;查看数据库后台进程&#xff0c;发现有大量阻塞 QL_ID WAIT_CLASS EVENT ------------- --------------- ------------------------- 1cpk7srb6cr0r User I/O db file scattered read 279knu21n06x6…

音视频开发之旅(78)- Docker使用和交互流程

目录 1.Docker是什么 2.DockerFile的使用 3.常用命令 4.Docker和Web服务的交互流程 5.资料 一、Docker是什么 Docker通过轻量级的容器化技术&#xff0c;使得应用程序及其依赖可以打包在一个可移植的容器中运行&#xff0c;确保应用在不同环境下的一致性和效率。 1.1 核心…

中断(NVIC)的使用--EXTI--TIM

目录 中断是什么 轮询 中断 中断调用情况 中断的分类 内部中断&#xff08;TIM、UART等&#xff09; tim.c tim.h 外部中断EXTI exti.c exti.h 中断是什么 在处理事件的时候有两种方式&#xff1a;轮询和中断。 轮询 顾名思义&#xff0c;就是每轮都询问一次。比如…