【刷题】20230318

HJ5 进制转换

while True:
    try:
        s=input()
        #print(s)
        print(int(s,16))
    except:
        break

NC61 两数之和

class Solution:
    def twoSum(self , numbers: List[int], target: int) -> List[int]:
        re=[]
        hash={}#创建哈希表,两元组分别表示值、下标
        for i in range(len(numbers)):
            temp=target-numbers[i]#在哈希表中查找target-numbers[i]
            if temp not in hash:#若是没找到，将此信息计入哈希表
                hash[numbers[i]]=i
            else:
                re.append(hash[temp]+1)#哈希表中记录的是之前的数字，所以该索引比当前小
                re.append(i+1)
                break
        return re

HJ3 明明的随机数 (快速排序）

data=[]
while True:
    try:
        n=input()#指定为N个数，输入
        #print(n)
        lst=[]#指定为N个数，输入
        for i in range(int(n)):#循环N次
            lst.append(int(input()))#空集合中追加一个N个数中的某一个随机数
        uniq=set(lst)#列表去重，但是会变成无序
        for j in sorted(uniq):
            print(j)
    except:
        break

HJ10 字符个数统计

while True:
    try:
        s=input()
        #print(s)
        str=''.join(set(s))# 去重后以字符串的形式
        count=0# 开始计数
        for i in str:
            if ord(i)>=0 and ord(i)<=127:
                count+=1# 计数
        print(count)
    except:
        break

#哈希的方式
while True:
    try:
        s=input()
        #print(s)
        dst={}
        l=list(s)# str转为list
        count=0# 开始计数
        for i in l:
            if ord(i)>=0 and ord(i)<=127 and i not in dst:
                dst[i]=1
                count+=1# 计数
        print(count)
    except:
        break

NC68 跳台阶

# 斐波拉契数列 递归 动态规划
class Solution:
    def jumpFloor(self, number):
        f1=1
        f2=2
        if number==1:return f1
        elif number==2:return f2
        for _ in range(number-2):
            f2,f1=f1+f2,f2
        return f2

HJ17 坐标移动

alist = input().split(';')
#line=input()
#alist = line.split(';')  
init=[0,0] #初始位置
for i in alist:
    if not 2<=len(i)<=3:
        continue
    try:
        direction=i[0]
        step=int(i[1:])
        if direction in ['A','D','W','S']:
            if 1<=step<=99:
                if direction=='A':
                    init[0]-=step
                elif direction=='D':
                    init[0]+=step
                elif direction=='S':
                    init[1]-=step
                elif direction=='W':
                    init[1]+=step
    except:
        continue
print(str(init[0])+','+str(init[1]))

HJ20 密码验证合格程序

def check(s):
    if len(s)<=9: #条件一：长度判断
        return 'NG'
    a,b,c,d=0,0,0,0 #定义四种大小写字母.数字.其它符号,以上四种至少三种
    for i in s:#条件二：四种大小写字母.数字.其它符号，四种至少三种
        if ord('a')<=ord(i)<=ord('z'):
            a=1
        elif ord('A')<=ord(i)<=ord('Z'):
            b=1
        elif ord('0')<=ord(i)<=ord('9'):
            c=1
        else:
            d=1
    if a+b+c+d<3:
        return 'NG'
    for i in range(len(s)-3):#条件三：
        if len(s.split(s[i:i+3]))>=3:
            return 'NG'
    return 'ok'

while True:
    try:
        p=input()
        if check(p)=='NG':
            print('NG')
        else:
            print('OK')
    except:
        break

7/45

HJ23 删除字符串中出现次数最少的字符

s=input()
d={}#输入一组字符串s，同时创建一个新的字典dic；
for i in s:
    if i in d:d[i]+=1
    else:d[i]=1 #遍历字符串s，如果元素在字典里，dic[i]累加次数，否则，dic[i]为1；
MIN=min(d.values())#使得MIN为出现最小次数的值；
for j in s:
    if d[j]==MIN:
        s=s.replace(j,'')#重新遍历s，如果i在字典中记录的次数等于MIN，则在原字符串s中用空字符替换；
print(s)

HJ33 整数与IP地址间的转换

分两部分

iplist=input().split('.')
num=input()
ipnum=''
#ip2num 
for i in iplist:
    a=bin(int(i,10))[2:]#转化为2进制
    if len(a)<8:
        a=('0'*(8-len(a)))+a
    else:
        a=a
    ipnum+=a
print(int(ipnum,2))#将ipnum这个2进制数转化为十进制
#num2ip
num2ip=[]
num2=bin(int(num,10))[2:]#是将num这个10进制数转化为2进制
if len(num2)<32:
    num2=('0'*(32-len(num2)))+num2#二进制数长度不够32位用0补齐
else:
    num2=num2
for i in range(4):
    b=num2[8*i:8*i+8]#8位分别为一个数
    b=str(int(b,2))#将这个8位的二进制数转化为10进制字符串
    num2ip.append(b)
print('.'.join(num2ip))#将4个数的列表用.拼成字符串

9/45

HJ101 输入整型数组和排序标识，对其元素按照升序或降序进行排序

## list(map(int,l))  # 先使用map把l映射成整型，在使用 list() 转换为列表

n=input()
l=input().split(' ')
l=list(map(int,l))
srt=int(input())

if srt==0:
    l.sort()
    l=map(str,l)
    print(' '.join(l))
elif srt==1:
    l.sort(reverse=True)
    l=map(str,l)
    print(' '.join(l))

1839. 所有元音按顺序排布的最长子字符串

#暂时记不住
class Solution:
    def longestBeautifulSubstring(self, word: str) -> int:
        window=list()#定义滑动窗口
        cnt=set()
        left,right=0,0#窗口左右指针
        res=0
        while right<len(word):
            if not window or word[right]>=window[-1]:
                window.append(word[right])
                cnt.add(word[right])
                if len(cnt)==5:
                    res=max(res,len(window))
            else:
                window=list()
                cnt=set()
                left=right
                window.append(word[left])
                cnt.add(word[left])
            right+=1
        return res

HJ46 截取字符串

s=input()
k=int(input())
print(s[:k])

NC149 kmp算法

给你一个文本串 T ，一个非空模板串 S ，问 S 在 T 中出现了多少次

NC100 把字符串转换成整数(atoi)

#通过50%
class Solution:
    def StrToInt(self , s: str) -> int:
        # write code here
        s = s.strip()#去掉前导空格
        if not s:
            return 0
        if s[0]=='-': #去掉空格就什么都没有了
            sign=-1
        else:
            sign=1
        num=0
        for i in s:
            if i.isdigit():
                num *= 10
                num+= ord(i)- 48
            else:
                return 0
        return min(max(sign*num,-2**31),2**31-1)

HJ70 矩阵乘法计算量估算(中)

n=int(input())
arr=[]#存矩阵的行列信息
order=[]#栈，用来计算栈顶部的两个矩阵
re=0
for i in range(n):
    arr.append(list(map(int,input().split())))#处理矩阵行列的数据
f=input()#最后为相乘顺序
for i in f:
    if i.isalpha():#作用是检查一个字符串中所有的字符是否都是由字母构成的，并且至少有1个字符
        temp=ord(i)-65#将A转化为0，B转化为1，C转化为2，依次。temp作为第temp个矩阵的index
        order.append(arr[temp])
    elif i==')' and len(order)>=2:
        b=order.pop()
        a=order.pop()
        re+=a[1]*b[1]*a[0]
        order.append([a[0],b[1]])
print(re)

HJ8 合并表记录(简单)

n=int(input())
arr=[]
d={}
for i in range(n):
    s=input().split()
    #s=s.split(' ')
    key=int(s[0])
    value=int(s[1])
    d[key]=d.get(key, 0) +value#get(key, 0) 作用是获取字典中key的值，如果没有就置为默认的0
for j in sorted(d):# 最后的键值对按照升值排序
    print(j,d[j])

HJ14 字符串排序(简单)

n=int(input())
l=[]
for i in range(n):
    l.append(input())

l.sort()
for i in l:
    print(i)

HJ27 查找兄弟单词（中等）

#读取输入数据，并且转换为列表
data1 = input().split()
#获取单词的个数
n1 = data1[0]
#按字典排序的第几个兄弟词
n2 = data1[-1]
#获取输入的n个单词
data2 = data1[1:-2]
#获取兄弟词
data3 = data1[-2]
#用于存储兄弟词的数量
n3 = 0
#用于存储兄弟词
data4 = []
for word in data2:
    if word == data3:
        continue
    elif sorted(word) == sorted(data3):
        n3 = n3 + 1
        data4.append(word)
print(n3)
data5 = sorted(data4)#将兄弟词按照字典排序
print(data5[int(n2)-1])

NC37 合并区间

from functools import cmp_to_key
 
class Solution:
    def merge(self , intervals: List[Interval]) -> List[Interval]:
        intervals.sort(key = (lambda x:x.start))
        res = []
        for i in range(len(intervals)):
            if not res:
                res.append(intervals[i])
            else:
                if res[-1].end >= intervals[i].start:
                    res[-1].end = max(res[-1].end,intervals[i].end)
                else:
                    res.append(intervals[i])
        return res

HJ68 成绩排序（较难）

#仅通过30%
import sys
n=int(input())
func=int(input())
arr=[]
d={}
if func==0:
    flag=True
else:
    flag=False
for i in range(n):
    s=input().split(' ')
    s=list(map(str,s))
    #print(s)
    arr.append(s)
   #print(arr)
    arr.sort(key=lambda x:x[1],reverse=flag)
for j in arr:
    print(*j)
    

HJ65 查找两个字符串a,b中的最长公共子串（中等）

a, b = input(), input() # a保存短，b保存长
if len(a) > len(b):
    a, b = b, a
res = ''
for i in range(0, len(a)):#遍历短的字符串
    for j in range(i+1, len(a)):#把短的字符串作为滑动窗口，滑动窗口减小
        if a[i:j+1] in b and j+1-i > len(res):#如果a的子串在b里 并且指针合法
            res = a[i:j+1]
print(res)

JZ4 二维数组中的查找（中等）

NC52 有效括号序列(简单）

class Solution:
    def isValid(self, s: str) -> bool:
        re=False
        dd={'(':')','[':']','?':'?','{':'}'}
        d=['?']
        for i in s:
            if i in dd: #如果是左括号，加入堆栈
                d.append(i) 
            elif dd[d.pop()]!=i:#如果是右括号，且不是栈顶的左括号对应的右括号，返回False
                re=False
                break
            else:#如果是右括号，且是栈顶的左括号对应的右括号，返回False
                re=True
        if len(d)//2==1 :re=False#最后堆栈长度为奇数，没有对应括号
        return re

NC175 合法的括号字符串

#通过50%
class Solution:
    def isValidString(self , s: str) -> bool:
        # write code hereclass Solution:
        re=False
        dd={'(':')','[':']','?':'?','{':'}','*':'*'}
        d=['?']
        for i in s:
            if i in dd:
                if i=='*':d.pop()
                else:d.append(i)
            elif dd[d.pop()]!=i :
                re=False
                break
            else:
                re=True
        if len(d)==1 and d[0]=='?':return True
        elif len(d)//2==1 :re=False#最后堆栈长度为奇数，没有对应括号
        return re

leetcode674. 最长连续递增序列

#通过23/35
class Solution:
    def findLengthOfLCIS(self, nums: List[int]) -> int:
        max=1
        l0=nums[0]
        for i in range(1,len(nums)):
            #i+=1
            #max=1
            print(nums[i])
            if nums[i]>l0:
                max+=1
                l0=nums[i]
            else:return max
        return max

NC17 最长回文子串(简单)

贪心算法
step 1：遍历字符串每个字符。
step 2：以每次遍历到的字符为中心（分奇数长度和偶数长度两种情况），不断向两边扩展。
step 3：如果两边都是相同的就是回文，不断扩大到最大长度即是以这个字符（或偶数两个）为中心的最长回文子串。
step 4：我们比较完每个字符为中心的最长回文子串，取最大值即可。

class Solution:
    def getLongestPalindrome(self , A: str) -> int:
        # write code here
        maxlen=1
        for i in range(len(A)-1):
            maxlen=max(maxlen,max(self.fun(A,i,i),self.fun(A,i,i+1)))
        return maxlen
    def fun(self, s: str, begin: int, end: int) -> int:
        while begin >=0 and end<len(s) and s[begin]==s[end]:
            begin-=1
            end+=1
        return end-begin-1

NC28 最小覆盖子串(较难)

HJ41 称砝码(中等)

n = int(input())
m = list(map(int,input().split()))#各个砝码重量
x = list(map(int,input().split()))#对应数量

amount = []
weights = {0,}
for i in range(n):
    for j in range(x[i]):
        amount.append(m[i])
print(amount)

for i in amount:
    for j in list(weights):
        weights.add(i+j)
        print(list(weights))
print(len(weights))

HJ48 从单向链表中删除指定值的节点(中等)

while True:
    try:
        l = input().split()
        head = l[1]
        rm = l[-1]
        l = l[2:-1]
        res = [head]
        for i in range(0, len(l), 2):
 
            # i = i*2
            # if i>len(l):
            #     break
            a = l[i]
            b = l[i+1]
            res.insert(res.index(b)+1, a)
 
        res.remove(rm)
        print(' '.join(res)+" ")
    except:
        break
avatar
2590 浏览

HJ25 数据分类处理(较难)

while True:
    try:
        a=input().split()[1:]
        b=map(str,sorted(map(int,set(input().split()[1:]))))
        totalNum=0
        res=""
        for num in b:
            singleRes,count="",0
            for i,v in enumerate(a):
                if num in v:
                    singleRes+=str(i)+" "+v+" "
                    totalNum+=2
                    count+=1
            if count:
                singleRes=num+" "+str(count)+" "+singleRes
                totalNum+=2
            res+=singleRes
        print((str(totalNum)+" "+res).rstrip())
 
    except:
        break

HJ29 字符串加解密(中等)

a = input()
a = list(a) #需要加密的字符串
b = input()
b = list(b) #需要解密的字符串
for i in range(len(a)):#加密过程
    if(a[i].isupper()): #如果字符是大写字母
        if(a[i] == 'Z'): #首先如果是Z的话变为a，若z的ascll+1的值是‘{’
            a[i] = 'a'
        else:
            a[i] = a[i].lower() #先变为小写
            c = ord(a[i]) + 1 #ascll码+1
            a[i] = chr(c) #转为字符
    elif(a[i].islower()): #小写同理
        if(a[i] == 'z'):
            a[i] = 'A'
        else:
            a[i] = a[i].upper()
            c = ord(a[i]) + 1
            a[i] = chr(c)
    elif(a[i].isdigit()): #若是数字则+1，9需要单独处理
        if(a[i] == '9'):
            a[i] = '0'
        else:
            a[i] = int(a[i]) + 1
            a[i] = str(a[i])
    else: #若是其他字符则保持不变
        a[i] = a[i]
for i in range(len(b)): #解密过程
    if(b[i].isupper()): #若为大写则先变为小写，再ascll减一，A要单独处理
        if(b[i] == 'A'):
            b[i] = 'z'
        else:
            b[i] = b[i].lower()
            c = ord(b[i]) - 1
            b[i] = chr(c)
    elif(b[i].islower()): #若是小写要先变为大写，再ascll减一，a要单独处理
        if(b[i] == 'a'):
            b[i] = 'Z'
        else:
            b[i] = b[i].upper()
            c = ord(b[i]) - 1
            b[i] = chr(c)
    elif(b[i].isdigit()):#若是数字需要减一，0要单独处理
        if(b[i] == '0'):
            b[i] = '9'
        else:
            b[i] = int(b[i]) - 1
            b[i] = str(b[i])
    else:
        b[i] = b[i]
print(''.join(a)) #按要求输出
print(''.join(b))

leetcode322 零钱兑换(中等)

https://leetcode.cn/problems/coin-change/discussion/

HJ43 迷宫问题(中等)

dfs深度优先本质递归回溯

m, n = list(map(int, input().split()))
maze = []
for _  in range(m):
    maze.append(list(map(int, input().split())))
def walk(i, j, pos=[(0, 0)]):
    if j+1 < n and maze[i][j+1] == 0: # 向右
        if (i, j+1) not in pos:
            walk(i, j+1, pos + [(i, j+1)])
    if j-1 >= 0 and maze[i][j-1] == 0: # 向左
        if (i, j-1) not in pos:
            walk(i, j-1, pos + [(i, j-1)])
    if i+1 < m and maze[i+1][j] == 0: # 向下
        if (i+1, j) not in pos:
            walk(i+1, j, pos + [(i+1, j)])
    if i-1 >= 0 and maze[i-1][j] == 0: # 向上
        if (i-1, j) not in pos:
            walk(i-1, j, pos + [(i-1, j)])
    if (i, j) == (m-1, n-1): # 到达出口
        for p in pos:
            print('(' + str(p[0]) + ',' + str(p[1]) + ')')
                
walk(0, 0)

leetcode200 岛屿问题(中等)

经典题目，深度优先搜索
https://leetcode.cn/problems/number-of-islands/

HJ22 汽水瓶

def f(n):
    if n == 0: return 0
    if n == 1: return 0
    if n >=2: return f(n-2) + 1

while True:
    n=int(input())
    if n != 0:
        print(f(n))
    else:
        break

HJ2 计算某字符出现次数

#通过12/13
a = input().strip()
b=input().split()
#print(a)
re=0

for i in a:
    #print((ord(i)-ord(b[0])))
    #print( (ord(b[0])-ord(i)))
    if i==b[0] or abs(ord(i)-ord(b[0]))==32:
       # print(i)
        re+=1
print(re)
#print(ord('a'),ord('A'))

HJ4 字符串分隔

s=input().strip()
if len(s)<8:
    print(s+('0'*(8-len(s))))
elif len(s)==8:
    print(s)
else:
    #print(int(len(s)//8))
    for i in range(int(len(s)//8)+1):
        #print(i)
        if (len(s)%8)!=0:
            #print((len(s)%8))
            #print(len(s))
            #print(s[8*(i+1):])
            if i<int(len(s)//8):
                print(s[i*8:8*(i+1)])
            elif i==(len(s)//8):
                print(s[8*(i):]+('0'*(8-(len(s)%8))))
        else:
            print(s[i*8:8*(i+1)])

HJ108 求最小公倍数

#通过7/12
a,b=list(map(int, input().split()))
if a < b:
    a,b=b,a
for i in range(b):
   # print('x',i)
    if (a*(i+1))%b==0:
        print(a*(i+1))

HJ6 质数因子

import math
n = int(input())
for i in range(2, int(math.sqrt(n))+1):#sqrt ()函数返回x的平方根 (x > 0)
    while n % i == 0:
        print(i, end=' ')
        n = n // i
if n > 2:
    print(n)

将数组分成和相等的多个子数组，求子数组的最大个数

一个整数数组，长度为n，将其分为m份，使各份的和相等，求m的最大值
比如{3，2，4，3，6} 可以分成{3，2，4，3，6} m=1;
{3,6}{2,4,3} m=2
{3,3}{2,4}{6} m=3 所以m的最大值为3
https://developer.aliyun.com/article/387843