20190402编程题练习-Easy version

1. 交错子串

     

分析：本题需要计算最长交错子串的长度：首先肯定需要遍历input()的字符串序列，然后去判断后者和前者相等与否，如果不等，则在目前的子串长度(count)基础上+1；如果相等，则需要将子串长度重置为0（count = 0）;

在此过程中，需要另外一个变量(l)来标识遍历到当前位置时，交错子串的最大长度；flag是用于特殊情况(例如，input仅仅只有0，1个数字时。)

A = input()
count = 0  # 记录当前该交错子串的长度
l = 0      # 记录截止目前为止，前面所有交错子串的最大长度。
flag = 1   # 特殊情况
for i in range(1,len(A)):
    if A[i] != A[i-1]:
        count += 1
    else:
        if l < count + 1:
            l = count +1
        count = 0
        flag = 0
if flag == 1:
    print(len(A))
else:
    print(l)

2.操作序列

    

分析：根据新输入的数据进行逐一遍历，先将当前元素放入已有的列表b中，然后对b进行逆置序列(需要借用另一个新的列表)。但这种思路没有通过，时间复杂度高了。

 

n = input()
A = list(input().split(' '))
b = []
for i in range(n):
    b.append(A[i])
    b_new = []
    for j range(len(b)):
        b_new[j] = b[(len(b)-j-1)]
    b = b_new
print(b)

然后看到别人的分析：
别被迷惑了，其实不需要逆序，直接从后向前间隔一个输出，然后没有输出的，接着顺序输出即可

n = int(input())
arr = list(input().split())
print(' '.join(arr[-1::-2]), end=' ')
print(' '.join(arr[n%2::2]))

3.独立的小易

   

分析：这就是一个简单的计算题，对于现有的金钱和水果个数，首先计算现有金钱是否能满足水果个数的天数，如不能，则计算现有金钱能支撑房租费的天数；如果满足的话，则需要计算剩下的金钱能满足水果+房租的天数。

x, f, d, p = [int(i) for i in input().split()]  # 采用条件表达式和同时分配技术，x, f, d, p = list（input().split())不通过，改成这样的方式就通过了。
d1 = d-f*x
if d1 >= 0:
    day = f+(d1//(p+x))
else:
    day = (d//x)
print(day)

4.堆棋子

没太看懂题目……

但大概是：对于所有的x\y坐标的组合方式，进行遍历，针对基准点k，计算基准点和所有组合点的距离和，放入tmp之中，然后排序，取前n个点的值；连加到t中，然后和已有的dist[k]进行比较

def sol(n, x, y):
    dist = [float('Inf') for _ in range(n)]
    for i in range(n):
        for j in range(n):
            t = 0
            tmp = []
            for k in range(n):
                tmp.append(abs(x[i]-x[k])+abs(y[j]-y[k]))
            tmp.sort()
            for k in range(n):
                t += tmp[k]
                dist[k] = min(dist[k], t)
    return dist
n = int(input())
x = list(map(int, input().split()))
y = list(map(int, input().split()))
# print(sol(n, x, y))
print(' '.join(map(str, sol(n, x, y))))

其实对程序的结果还是没有太理解。

5. 疯狂队列：

输出：100

分析：

首先将数据从小到大的排序，先将最小的数据放在第一位，然后最大的数据放在第二位，接着删除掉这两个数据；进而继续针对删除后的数据进行逐步放最小的数据、最大的数据，……。但是需要判断数据个数的奇偶性，因为每次是同时删除两个数据(当前最大和最小)，如果数据个数是奇数，最后还剩下一个数据，需要判断该数据与已有排列中的第一个和最后一个的差值，最后放在差值大的地方。

将结果序列排出来之后(最大与最小交叉排列)，在计算相邻差值绝对值之和。

def crazy_queue(n, input_list):
    input_list = sorted(input_list)
    result_list = [input_list[0], input_list[len(input_list)-1]]
    del(input_list[0])
    del(input_list[len(input_list)-1])
    for i in range(int(len(input_list)/2)):
        min = [input_list[0]]
        max = [input_list[len(input_list)-1]]
        if i % 2 == 0:
            max.extend(result_list)
            max.extend(min)
            result_list = max
        elif i % 2 == 1:
            min.extend(result_list)
            min.extend(max)
            result_list = min
        del(input_list[0])
        del(input_list[len(input_list)-1])
    if input_list:
        temp = [input_list[0]]
        if abs(result_list[0]-temp[0]) > abs(result_list[len(result_list)-1] - temp[0]):
            temp.extend(result_list)
            result_list = temp
        else:
            result_list.extend(temp)
    result = 0
    for i in range(len(result_list)-1):
        result += abs(result_list[i+1] - result_list[i])
    return result
 
while(True):
    try:
        n = int(input())
        input_list = [int(x) for x in input().split()]
        result = crazy_queue(n, input_list)
        print(result)
    except:
        exit(0)

 

6. 唯一的摩斯密码

        

题意：对现有的26个小写字母进行摩斯密码的对应(字典)，对于输入的字符串的lists,首先对于其中每一个词进行摩斯密码的转换，每个词有一组摩斯密码的组合，将其放在新的list,然后求该list中不同摩斯密码组合的个数(相应list的集合长度)。

class Solution:
    def uniqueMorseRepresentations(self, words: List[str]) -> int:
        mourse_codes = [".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."]
        alphabet =['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
        dct = {i:j for i,j in zip(alphabet,mourse_codes)}
        words_mourse = []
        for word in words:
            words_mourse.append(''.join(list(map(dct.get,list(word)))))
        return len(set(words_mourse))
                

当读懂题意之后，还是很好解决的。可以对比牛客和letcode上的编程题，发现：它们内部的评审机制大有不同。

7. 要写入字符串的行数和最后一行的长度

分析：读完题发现，其目的是：已给26个小写字母的宽度和相应要写入的字符串；根据每行限定宽度是100，来将要写入的字符串写入到几行中，返回写的行数和最后一行的宽度(长度)；

首先建立字母-宽度之间的一个字典，根据这个字典来进行要写入字符串的宽度，根据这个宽度和限定的每行宽度=100，来计算相应的值。

class Solution:
    def numberOfLines(self, widths: List[int], S: str) -> List[int]:
        alphabet = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
        dct = {i:j for i,j in zip(alphabet,widths)}
        s_lens = 0
        for i in range(len(S)):
            w = S[i] 
            s_lens += dct[w] 
        q,m = divmod(s_lens,100)
        if m > 0:
            lines = q + 1
            last_len = m
        else:
            lines = q
            last_len = m
        return (lines,last_len)
## 修正版本
class Solution:
    def numberOfLines(self, widths: List[int], S: str) -> List[int]:
        alphabet = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
        dct = {i:j for i,j in zip(alphabet,widths)}
        count_line ,count = 1, 0
        for s in S:
            w = dct[s]
            if count + w <= 100:
                count += w
            else:
                count_line += 1
                count = dct[s]
        return (count_line, count)
        

letcode上还有另外的解法：没有建立字典，直接利用ord()函数来计算相应字符在widths中的宽度值，然后其思想是逐一去放，每行超过100了，就往下一行放。感觉还是这个思路要更好一些。

例如：针对某行当放入最后一个字符串时，其行宽度会超过100，但我的算法，会将其拆开来放(显然错误)；但该算法就会将其直接整体向下一行移动。

class Solution(object):
    def numberOfLines(self, widths, S):
        """
        :type widths: List[int]
        :type S: str
        :rtype: List[int]
        """
        count_line, count = 1, 0
        for s in S:
            w = widths[ord(s)-ord('a')] 
            if count + w <= 100:
                count += w
            else:
                count_line += 1
                count = widths[ord(s)-ord('a')]
        return [count_line, count]

 

8. Max Increase to Keep City Skyline

题意分析：

分析：遍历grid中的每一个值，相应位置上的值作如下改变：min(row_max[r],col_max[c])，所以需要首先计算，每行的最大值和每列的最大值；接着遍历更新，并在过程中记录更新前后的差值，最后返回这个差值和。

class Solution:
    def maxIncreaseKeepingSkyline(self, grid: List[List[int]]) -> int:
        row_max = [max(row) for row in grid]         # 计算每行的最大值
        col_max = [max(col) for col in zip(*grid)]   # 计算每列的最大值
        diff_val = 0
        for r, row in enumerate(grid):               # 返回，行数、行的list结果
            for c, val in enumerate(row):            # 返回相应行情况下，对应的列数和相应的grid中的值,相当于grid(r,c)
                diff_val +=(min(row_max[r],col_max[c]) - val) 
        return diff_val
        

9.808. Soup Servings

官网给出的题意解析：

 

class Solution:
    def soupServings(self, N: int) -> float:
        Q, R = divmod(N, 25)
        N = Q + (R > 0)
        if N >= 500: 
            return 1
        memo = {}
        def dp(x, y):
            if (x, y) not in memo:
                if x <= 0 or y <= 0:
                    ans = 0.5 if x<=0 and y<=0 else 1.0 if x<=0 else 0.0
                else:
                    ans = 0.25 * (dp(x-4,y)+dp(x-3,y-1)+dp(x-2,y-2)+dp(x-1,y-3))
                memo[x, y] = ans
            return memo[x, y]

        return dp(N, N)