【python】五道题目

1.题目描述：
编写一个函数来验证输入的字符串是否是有效的 IPv4 或 IPv6 地址。
如果是有效的 IPv4 地址，返回 “IPv4” ；
如果是有效的 IPv6 地址，返回 “IPv6” ；
如果不是上述类型的 IP 地址，返回 “Neither” 。
IPv4 地址由十进制数和点来表示，每个地址包含 4 个十进制数，其范围为 0 - 255， 用(".")分割。比如，172.16.254.1；
同时，IPv4 地址内的数不会以 0 开头。比如，地址 172.16.254.01 是不合法的。
IPv6 地址由 8 组 16 进制的数字来表示，每组表示 16 比特。这些组数字通过 (":")分割。比如, 2001:0db8:85a3:0000:0000:8a2e:0370:7334 是一个有效的地址。而且，我们可以加入一些以 0 开头的数字，字母可以使用大写，也可以是小写。所以， 2001:db8:85a3:0:0:8A2E:0370:7334 也是一个有效的 IPv6 address地址 (即，忽略 0 开头，忽略大小写)。
然而，我们不能因为某个组的值为 0，而使用一个空的组，以至于出现 (:😃 的情况。 比如， 2001:0db8:85a3::8A2E:0370:7334 是无效的 IPv6 地址。
同时，在 IPv6 地址中，多余的 0 也是不被允许的。比如， 02001:0db8:85a3:0000:0000:8a2e:0370:7334 是无效的。
示例 1：
输入：IP = “172.16.254.1”
输出：“IPv4”
解释：有效的 IPv4 地址，返回 “IPv4”
示例 2：
输入：IP = “2001:0db8:85a3:0:0:8A2E:0370:7334”
输出：“IPv6”
解释：有效的 IPv6 地址，返回 “IPv6”
示例 3：
输入：IP = “256.256.256.256”
输出：“Neither”
解释：既不是 IPv4 地址，又不是 IPv6 地址
示例 4：
输入：IP = “2001:0db8:85a3:0:0:8A2E:0370:7334:”
输出：“Neither”
示例 5：
输入：IP = “1e1.4.5.6”
输出：“Neither”
提示：
IP 仅由英文字母，数字，字符 ‘.’ 和 ‘:’ 组成。****

思路：1）如果IP里面不是“.”或“：”，就输出“Neither”。
2）如果是“.”,可能是IPv4,以“.”分割该IP为多部分，然后遍历每一部分。有四种情况不符合要求，分别是：遍历后有字母；遍历后有空白的部分；每部分的第一个字符是‘0’；或者某一部分范围超出[0,255]。其余就都是符合要求的
3）如果是“：”，可能是IPv6.以“：”分割该IP为多部分，然后遍历每一部分。有两种情况不符合要求，分别是：分割后的任何一部分有空白的；某一部分长度大于1且长度等于该部分中“0”的个数（注意：长度等于1时，可以是“0”，但题干要求了不能同时出现多余的“0”）
运行示例如下：

def solve( IP ):
    if '.' in IP:
        for ip in IP.split('.'):
            for i in ip:     
                if 'a'<=i<='z' or 'A'<=i<='Z':    
                    return 'Neither'
            if ip == '' or ip[0] == '0' or (not 0<=int(ip)<=255):
                return 'Neither'
        return 'IPv4'
    if ':' in IP:
        for ip in IP.split(':'):
            if ip == '' or (len(ip)>1 and len(ip) == ip.count('0')):
                return 'Neither'
        return 'IPv6'
    return 'Neither'
A=input()
solve(A)

2.题目描述：
给定两个列表smlst和biglst，如果smlst的所有元素都可以在biglst中找到，并且顺序相同，那么我们说smlst是biglst的有序子列表。
示例 1：
输入：[4, 3, 2] [5, 4, 3, 2, 1]
输出：True
示例 2：
输入：[1, 2, 3] [3, 2, 1, 2, 3]
输出：True

思路：1）记录列表smlst第一个元素在列表biglst出现的位置为count（后面可以用来和smlst第一个元素之后的元素比较在biglst中是否出现在它后面）
2）之后进行双重for循环，外层循环从第二个元素开始，内层循环从哪里开始分两种情况。
第一种对应示例一，即smlst第二个数的位置在biglst中比第一个数后面。这时第二层for循环从开头开始遍历即可；
第二种对应示例二，即smlst第二个数的位置在biglst中比第一个数前面，这时第二层循环从smlst第一个元素在biglst出现位置开始遍历。
3）循环期间，如果smlst元素出现在biglst中，且在biglst中在前一个smlst元素之后，就跳出内层循环。如果没有出现，就跳出外层循环。
示例如下：

smlst = list(map(int,input().split()))
biglst=list(map(int,input().split()))
flag=0
count=0
t=0  #记录第二层for循环开始遍历的索引，默认是从头遍历
for j in range(len(biglst)):    #记下第一个数对应的索引
    if smlst[0]==biglst[j]:
        count=j
for n in range(len(biglst)):   #特殊情况，即smlst第二个数的位置在biglst中比第一个数前面
    if smlst[1]==biglst[n] and count>n :
        t=count  #第二层循环从smlst第一个元素在biglst出现位置开始遍历。
for i in range(1,len(smlst)):
    for m in range(t,len(biglst)):
        if smlst[i]==biglst[m]:
            if count<m:
                count=m
                flag=1
                break
    if flag==0:  #smlst里面的某个元素没有在biglst里面出现
        print("False")
        break
    elif i<len(smlst)-1:
        flag=0
if flag==1:
    print("True")

3.题目描述：
计算机上的文件夹系统可能类似于下图。

在此挑战中，文件夹系统将由字典表示，其中键为文件夹X，X处的值为X的子文件夹列表。例如，上图成为字典。
{
“A”: [“B”, “C”, “D”],
“B”: [“E”, “F”],
“D”: [“G”, “H”],
“G”: [“I”, “J”],
“H”: [“K”]
}
根据给定的代表文件夹系统的字典，以及两个文件夹，X和Y。编写一个函数来确定“ X是否在Y内”（在图中，这意味着可以从Y向下移动到X）。
示例 1：
输入：
{
“A”: [“B”, “C”, “D”],
“B”: [“E”, “F”],
“D”: [“G”, “H”],
“G”: [“I”, “J”],
“H”: [“K”]
}
X = “B”
Y = “A”
输出：True

思路：1）输入文件夹系统保存为字典（key只有一个，value可以有多个），输入X,Y，并都传入函数中
2）遍历字典，如果key==Y and X in value同时成立，则符号题目要求

def X_whether_in_Y(X,Y,**dir):  
    flag=0
#遍历字典
    for key ,value in dir.items():
        if key==Y and X in value:
            print("True")
            flag=1
            break
    if flag==0:
        print("False")
#输入
num=int(input())
X=input()
Y=input()
dir={} 
for i in range(num):
    key=input()
    value=list(map(str,input().split()))
    dir[key]=value   
X_whether_in_Y(X,Y,**dir)

4.题目描述：
对于一个字符串，你可以进行三种操作： 1.插入一个字符 2.删除一个字符 3.替换一个字符 现在给出两个字符串a，b，判断其中的一个字符串是否能通过 最多一次的操作转换为另一个字符串。若能，则打印YES，不能 则打印NO。 例如a=“pale”，b=“ple”，则输出：YES。
示例：
输入：a = “pale” b = “ple”
输出：YES

思路：分三种情况：
1）两个字符串长度相差大于1，不符合题意，直接pass；
2）相差等于1。
3）长度相同。
若长度相差1，从长度长的开始遍历，因为就相差一个，如果它们除了这一个其它都相同，那前面加后面会等于长度短的。
形式如下：

长度相同时，若只有一个字符不同，且顺序相同，则有一种情况两者相同：

a=list(map(int,input().split()))
b=list(map(int,input().split()))
a1=len(a)
b1=len(b)
flag=0
#长度相差大于1
if abs(a1-b1)>1:
    pass
else:
#长度相差等于1
    if a1>b1:
        for i in range(0,a1):
              if a[:i]+a[i+1:]==b:
                print ("YES")
                flag=1
                break
    elif a1<b1:
         for i in range(0,b1):
            if b[:i]+b[i+1:]==a:
                print ("YES")
                flag=1
                break
  #长度相同
    else:
        for i in range(0,n1):
            if a[:i]+a[i+1:]==b[:i]+b[i+1:]:
                print ("YES")
                flag=1
                break  
if flag!=1:
    print ("NO")

5.题目描述：
创建一个接受字符串作为参数的函数。查找其最短词，并将其作为列表返回，并按字母顺序排序（如果有多个最短词）。其中，句号，逗号和其他特殊字符不会计入单词的长度；在返回结果之前，请记住按字母顺序对单词列表进行排序；仅返回小写字母。
示例：
输入：“I think the solution is fairly obvious.”
输出：[“i”]

思路：1）输入字符串转为列表，并将元素用lower（）函数换成小写，存入新列表中。
2）记录第一个元素的长度为l，用于后面比较长度。
3）循环。如果长度比l短，就更新l和list列表（用于记录长度最短的元素对应的索引。）；如果长度与l相同，就将索引添加到list中。
4）将list[]中记录的索引对应到new[]中的最短单词，并添加到min[]
5）对min[]按字典顺序排序 min.sort(key=lambda x:x[0])
运行示例如下：

list=[]  #用于放置长度最短单词的下标
min=[]   #用于放置长度最短的单词
new=[]   #用于放置分割后的字符串并小写的单词
def find_shortest_word(z):  #字符串做参数
    words=z.split() #字符串转为列表
#把列表中的元素换成小写lower（）并添加到新的列表中
    for i in words[:]: 
        new.append(i.lower())
#以第一个元素为对比对象
    l=len(new[0])
    for i in range(0,len(words)):
#如果列表元素长度比a短，则记录该元素的索引，并定义该元素长度为新的最短长度，并刷新list[]
#把最新的最短元素的索引添加到list[]中
        if l>len(words[i]):
            l=len(words[i])
            del list[:]
            list.append(i)
#如果列表元素长度等于最短长度，则添加该列表元素于list[]中
        elif l==len(words[i]):
            list.append(i)
#将list[]中记录的索引对应到new[]中的最短单词，并添加到min[]
    for j in range(len(list)):
        y=list[j]
        min.append(new[y])
#对min[]按字典顺序排序
    min.sort(key=lambda x:x[0])
    print(min)
#输入字符串并赋值给自定义函数
x=input()  
find_shortest_word(x)