编程能力提升_8

- 日理万妓 2022-02-28 06:40 516阅读 0赞

华为上机笔试

**目录**

1.有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶，

2.明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤1000），

3.写出一个程序，接受一个十六进制的数值字符串，输出该数值的十进制字符串。（多组同时输入 ）

4.约瑟夫环问题，有一个数组a\[N\]顺序存放0~N-1，要求每隔两个数删掉一个数，到末尾时循环至开头继续进行，求最后一个被删掉的数的原始下标位置。

5.输入一个字符串，求出该字符串包含的字符集合

6.数独是一个我们都非常熟悉的经典游戏，运用计算机我们可以很快地解开数独难题，现在有一些简单的数独题目，请编写一个程序求解。

7.老师想知道从某某同学当中，分数最高的是多少，现在请你编程模拟老师的询问。当然，老师有时候需要更新某位同学的成绩.

8.开发一个简单错误记录功能小模块，能够记录出错的代码所在的文件名称和行号。

9.扑克牌游戏大家应该都比较熟悉了，一副牌由54张组成，含3~A，2各4张，小王1张，大王1张。

--------------------

### 1.有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶， ###

她最多可以换多少瓶汽水喝？”答案是5瓶，方法如下：先用9个空瓶子换3瓶汽水，喝掉3瓶满的，喝完以后4个空瓶子，用3个再换一瓶，喝掉这瓶满的，这时候剩2个空瓶子。然后你让老板先借给你一瓶汽水，喝掉这瓶满的，喝完以后用3个空瓶子换一瓶满的还给老板。如果小张手上有n个空汽水瓶，最多可以换多少瓶汽水喝？

**输入描述:**

输入文件最多包含10组测试数据，每个数据占一行，仅包含一个正整数n（1<=n<=100），表示小张手上的空汽水瓶数。n=0表示输入结束，你的程序不应当处理这一行。

**输出描述:**

对于每组测试数据，输出一行，表示最多可以喝的汽水瓶数。如果一瓶也喝不到，输出0。

while True:
        try:
            empty = int(input())
            drink = 0
            if empty!=0:            
                while empty >= 3:
                    drink += empty // 3
                    empty = empty% 3 + empty // 3
                if empty == 2:
                    drink += 1
                print(drink)
            else:
                break
        except:
            break

### 2.明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤1000）， ###

对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作(同一个测试用例里可能会有多组数据，希望大家能正确处理)。

Input Param

n 输入随机数的个数

inputArray n个随机整数组成的数组

Return Value

OutputArray 输出处理后的随机整数  
注：测试用例保证输入参数的正确性，答题者无需验证。测试用例不止一组。

**输入描述:**

输入多行，先输入随机整数的个数，再输入相应个数的整数

**输出描述:**

返回多行，处理后的结果

while True:
        try:
            amount = int(input())
            numbers = [] 
            for i in range(amount):
                number = int(input())
                numbers.append(number) 
            numbers_set = set(numbers)
            result = list(numbers_set) 
            result= sorted(result)
            for i in result:
                print(i)
        except:
            break

while True:
        try:
            nums_count = int(input())
            nums = set()
            for i in range(nums_count):
                nums.add(int(input()))
            nums = sorted(list(nums))
            for each in nums:
                print(each)
        except:
            break

### 3.写出一个程序，接受一个十六进制的数值字符串，输出该数值的十进制字符串。（多组同时输入 ） ###

**输入描述:**

输入一个十六进制的数值字符串。

**输出描述:**

输出该数值的十进制字符串。

**输入例子1:**0xA**输出例子1:**10

while True:
            try:
                h = input()
                if len(h) > 0:
                    print(int(h, 16))
            except:
                break

### 4.约瑟夫环问题，有一个数组a\[N\]顺序存放0~N-1，要求每隔两个数删掉一个数，到末尾时循环至开头继续进行，求最后一个被删掉的数的原始下标位置。 ###

以8个数(N=7)为例:｛0，1，2，3，4，5，6，7｝，0->1->2(删除)->3->4->5(删除)->6->7->0(删除),如此循环直到最后一个数被删除。

**输入描述:**

每组数据为一行一个整数n(小于等于1000)，为数组成员数,如果大于1000，则对a[999]进行计算。

**输出描述:**

一行输出最后一个被删掉的数的原始下标位置。

python:

while True:
        try:
            n = int(raw_input())
        except:
            exit()
        a = range(n)
        i = 0
        while len(a) > 1:
            i = (i+2) % len(a)
            if i != len(a) - 1
                a = a[:i] + a[i+1:]
            else:
                a = a[:i]
                i = 0
        print a[0]

while True:
        try:
            n = int(raw_input())
        except:
            exit()
        #r即为最终返回的索引
        r = 0
        #i代表的是当前剩余的人数，从2开始
        i = 2
        while i <= n:
            #3即为k，代表报数每次为3的人删除
            r = (r+3) % i
            i += 1
        #求出的结果是数组中的下标
        print(r)

### 5.输入一个字符串，求出该字符串包含的字符集合 ###

**输入描述:**

每组数据输入一个字符串，字符串最大长度为100，且只包含字母，不可能为空串，区分大小写。

**输出描述:**

每组数据一行，按字符串原有的字符顺序，输出字符集合，即重复出现并靠后的字母不输出。

while True:
        try:        
            strs=input()
            newstr=''
            theset=set()
            for i in strs:
                if i not in theset:
                    theset.add(i)
                    newstr+=i
            print(newstr)
        except:
            break

### 6.数独是一个我们都非常熟悉的经典游戏，运用计算机我们可以很快地解开数独难题，现在有一些简单的数独题目，请编写一个程序求解。 ###

**输入描述:**

输入9行，每行为空格隔开的9个数字，为0的地方就是需要填充的。

**输出描述:**

输出九行，每行九个空格隔开的数字，为解出的答案。

#Python版
    #只过了83.33% 。。。。。。。 
    #思路： 深搜+剪枝
    # -*- coding:utf-8 -*-
    import sys
    def isOk(mat, i, j,num):
        for row in range(0,9):
            if mat[row][j] == num:
                return False
        for col in range(0,9):
            if mat[i][col] == num:
                return False
        ii = i/3
        jj = j/3
        for row in range(ii*3,ii*3+3):
            for col in range(jj*3,jj*3+3):
                if mat[row][col] == num:
                    return False
        return True
     
    def dfs(mat,i,j):
        if i==9:
            return mat
        if j==9:
            return dfs(mat,i+1,0)
        flag = False
        for col in range(j,9):
            if mat[i][col]==0:
                flag = True
                isChange =False
                for num in range(1,10):
                    if isOk(mat,i,col,num):
                        isChange =True
                        mat[i][col] = num
                        tpp = dfs(mat,i,col+1)
                        if tpp == None:
                            isChange = False
                            mat[i][col] = 0
                            continue
                        else:
                            return  tpp
                if isChange==False:
                    return None
        if flag==False:
            return dfs(mat,i+1,0)
     
     
     
    if __name__ == '__main__':
        while True:
            isCon = True
            mat = []
            for i in range(9):
                tp = sys.stdin.readline().strip()
                if not tp:
                    isCon = False
                    break
                tp =[int(i) for i in tp.split(' ')]
                mat.append(tp)
     
            if isCon ==False:
                break
     
            mat = dfs(mat,0,0)
            for i in mat:
                print ' '.join(str(j) for j in i)

### 7.老师想知道从某某同学当中，分数最高的是多少，现在请你编程模拟老师的询问。当然，老师有时候需要更新某位同学的成绩. ###

**输入描述:**

输入包括多组测试数据。
    每组输入第一行是两个正整数N和M（0 < N <= 30000,0 < M < 5000）,分别代表学生的数目和操作的数目。
    学生ID编号从1编到N。
    第二行包含N个整数，代表这N个学生的初始成绩，其中第i个数代表ID为i的学生的成绩
    接下来又M行，每一行有一个字符C（只取‘Q’或‘U’），和两个正整数A,B,当C为'Q'的时候, 表示这是一条询问操作，他询问ID从A到B（包括A,B）的学生当中，成绩最高的是多少
    当C为‘U’的时候，表示这是一条更新操作，要求把ID为A的学生的成绩更改为B。

**输出描述:**

对于每一次询问操作，在一行里面输出最高成绩.

示例1

输入

5 7
    1 2 3 4 5
    Q 1 5
    U 3 6
    Q 3 4
    Q 4 5
    U 4 5
    U 2 9
    Q 1 5

输出

5
    6
    5
    9

while True:
        try:
            inp_m_n=raw_input()
            inp_m_n=inp_m_n.split()
            M=int(inp_m_n[1])
            N=int(inp_m_n[0])
            input_id=raw_input()
            input_id=input_id.split()
            input_id=[int(i) for i in input_id]
     
            dic={}
            out_show=[]
            while(M>0):
                M-=1
                input_q_u=raw_input()
                input_q_u=input_q_u.split()
                A=int(input_q_u[1])
                B=int(input_q_u[2])
                if(input_q_u[0]=='Q'):
                    if(A==B):
                        out_show.append(input_id[A-1])
                    elif(A>B):
                         
                        out_show.append(max(input_id[B-1:A]))
                    else:
                        out_show.append(max(input_id[A-1:B]))
                elif(input_q_u[0]=='U'):
                    input_id[A-1]=B
            for i in out_show:
                print i
        except:
            break

### 8.开发一个简单错误记录功能小模块，能够记录出错的代码所在的文件名称和行号。 ###

处理:  
1.记录最多8条错误记录，对相同的错误记录(即文件名称和行号完全匹配)只记录一条，错误计数增加；(文件所在的目录不同，文件名和行号相同也要合并)  
2.超过16个字符的文件名称，只记录文件的最后有效16个字符；(如果文件名不同，而只是文件名的后16个字符和行号相同，也不要合并)  
3.输入的文件可能带路径，记录文件名称不能带路径

**输入描述:**

一行或多行字符串。每行包括带路径文件名称，行号，以空格隔开。
    
        文件路径为windows格式
    
        如：E:\V1R2\product\fpgadrive.c 1325

**输出描述:**

将所有的记录统计并将结果输出，格式：文件名代码行数数目，一个空格隔开，如: fpgadrive.c 1325 1 
    
        结果根据数目从多到少排序，数目相同的情况下，按照输入第一次出现顺序排序。
    
        如果超过8条记录，则只输出前8条记录.
    
        如果文件名的长度超过16个字符，则只输出后16个字符

示例1

输入

E:\V1R2\product\fpgadrive.c 1325

输出

fpgadrive.c 1325 1

import sys
    import collections
    lst = []
    dct = collections.OrderedDict()
    #循环读取输入，将输入的出现次数计入有序字典里面
    for line in sys.stdin:
        ele = line.split('\\')[-1].strip('\n')
        if ele not in lst:
            lst.append(ele)
        if ele in dct:
            dct[ele] = dct[ele] + 1
        else:
            dct[ele] = 1
    #对字典按照出现次数(value)排序
    lstTuple = sorted(dct.items(), key = lambda d:d[1], reverse = True)
    #输出不超过8行的结果
    count = 0
    for key in lstTuple:
        if count > 7:
            break
        count = count + 1
        #文件名取后16位
        if len(key[0].split(' ')[0]) > 16:
            print key[0].split(' ')[0][-16:], key[0].split(' ')[1], key[1]
        else:
            print key[0].split(' ')[0], key[0].split(' ')[1], key[1]

### 9.扑克牌游戏大家应该都比较熟悉了，一副牌由54张组成，含3~A，2各4张，小王1张，大王1张。 ###

牌面从小到大用如下字符和字符串表示（其中，小写joker表示小王，大写JOKER表示大王）:)  
3 4 5 6 7 8 9 10 J Q K A 2 joker JOKER  
输入两手牌，两手牌之间用“-”连接，每手牌的每张牌以空格分隔，“-”两边没有空格，如：4 4 4 4-joker JOKER  
请比较两手牌大小，输出较大的牌，如果不存在比较关系则输出ERROR  
  
基本规则：  
（1）输入每手牌可能是个子，对子，顺子（连续5张），三个，炸弹（四个）和对王中的一种，不存在其他情况，由输入保证两手牌都是合法的，顺子已经从小到大排列；  
（2）除了炸弹和对王可以和所有牌比较之外，其他类型的牌只能跟相同类型的存在比较关系（如，对子跟对子比较，三个跟三个比较），不考虑拆牌情况（如：将对子拆分成个子）  
（3）大小规则跟大家平时了解的常见规则相同，个子，对子，三个比较牌面大小；顺子比较最小牌大小；炸弹大于前面所有的牌，炸弹之间比较牌面大小；对王是最大的牌；  
（4）输入的两手牌不会出现相等的情况。  
  
答案提示：  
（1）除了炸弹和对王之外，其他必须同类型比较。  
（2）输入已经保证合法性，不用检查输入是否是合法的牌。  
（3）输入的顺子已经经过从小到大排序，因此不用再排序了.

**输入描述:**

输入两手牌，两手牌之间用“-”连接，每手牌的每张牌以空格分隔，“-”两边没有空格，如4 4 4 4-joker JOKER。

**输出描述:**

输出两手牌中较大的那手，不含连接符，扑克牌顺序不变，仍以空格隔开；如果不存在比较关系则输出ERROR。

示例1

输入

4 4 4 4-joker JOKER

输出

joker JOKER

# -*- coding:utf-8 -*-
    import sys
     
    if __name__ == '__main__':
        while True:
            tp = sys.stdin.readline().strip()
            if not tp:
                break
            if 'joker JOKER' in tp:
                print 'joker JOKER'
            else:
                strs = ['3','4','5','6','7','8','9','10','J','Q','K','A','2','joker','JOKER']
                s1,s2 = tp.split('-')
                ss1 = s1.split(' ')
                ss2 = s2.split(' ')
                len1 = len(ss1)
                len2 = len(ss2)
                if len1 ==4 and len2!=4:
                    print s1
                elif len2==4 and len1!=4:
                    print s2
                elif len1==len2:
                    ind1 = strs.index(ss1[0])
                    ind2 = strs.index(ss2[0])
                    if ind1>ind2:
                        print s1
                    elif ind1<ind2:
                        print s2
                else:
                        print 'ERROR'