Python：每日一题 264

zltzlt

__mrsq__ 发表于 2019-10-27 15:56
我觉得可以理解为：

C 是仓库里常规物品的合集

差不多

阴阳神万物主

这锅我背了，我换个好懂的描述吧：
背景

小明同学是我们的执行人，他要去本公司旗下的某家商店采购一些东西，并调查该商店销售的商品是否符合本公司的规定。如果需要采购的东西商店存货不足，则可以向该商店提出进货要求，直到满足采购需求。但是，当要采购的东西商店没有存货，并且这个东西不符合公司规定时，由于小明失落的心情，会直接放弃采购，也不会调查了，因为小明认为在该商店中不可能购买到该商品。

描述

关于规定：当商店销售的商品中，出现规定以外的东西，则应该将该商店查封。
商店销售的商品记为字符串 A ，小明要采购的东西记为字符串 B ，公司规定的商品记为字符串 C 。
这三个字符串的内容均为：首字母大写的英文单词，每个单词用空格分开(在英文中有空格的单词，空格用短横线代替，如：Ice cream 在字符串中为 Ice-cream)，某一单词的数量即为该单词代表的商品的数量。但在字符串 C 中不会出现重复的单词。

输入

A B C 三个字符串。

输出格式

当小明失落时，只需输出一个单词：Impossible
但是，他不失落时，需要输出：
第一行：小明是否采购成功？
第二行：按照规定，该商店是否 不该 查封？
若小明采购失败，从第三行开始，往后的每一行(按照在 B 中从左往右出现的顺序)都是：采购失败的物品的单词+一个空格+商店需要进货的最少数量

输入输出样例

输入 #1	输出 #1
A = 'Ball Ball Ball Knife Knife Condom Ice-cream' B = 'Ball Condom Ball' C = 'Ball Knife Condom' 复制代码	True False 复制代码

输入 #2	输出 #2
A = 'Ball Ball Ball Ball Ball Ball Ball Ball Ball Ball Ball Ball Ball Ball Ball Ball Ball Ball Ball Ball Star Star Star Sun' B = 'Ball Moon Star' C = 'Ball Star Sun Moon' 复制代码	False True Moon 1 复制代码

输入 #3	输出 #3
A = 'Jin-Yong Country-love-story Country-love-story Country-love-story Guitar Guitar Guitar' B = 'Little-Turtle' C = 'Jin-Yong Guitar' 复制代码	Impossible 复制代码

永恒的蓝色梦想

zltzlt 发表于 2019-10-27 16:40
往后，当 A 中无法取出 B 中列出的物品时，每一行为：{需要的物品单词} {如果 A 要满足 B 的需求需要进货 ...

OKOK

永恒的蓝色梦想

1. def makedict(s):
   
2.     s=s.split(' ')
   
3.     return {i:s.count(i) for i in set(s)}
   
4. def function(A,B,C):
   
5.     set_c=set(C.split(' '))
   
6.     a=makedict(A)
   
7.     b=makedict(B)
   
8. 
   
9.     res=[True]
   
10.     for i in b:
    
11.         try:
    
12.             if a[i]<b[i]:
    
13.                 res[0]=False
    
14.                 res.append(f'{i} {b[i]-a[i]}')
    
15.         except:
    
16.             res[0]=False
    
17.             if i not in set_c:
    
18.                 print("Impossible")
    
19.                 return
    
20.             else:
    
21.                 res.append(f'{i} {b[i]}')
    
22.     res.insert(1,bool(len(set(a)-set_c)))
    
23.     print(*res,sep='\n')

复制代码

zltzlt

Unicorn# 发表于 2019-10-27 16:20
.....这总行了吧

OK

zltzlt

__mrsq__ 发表于 2019-10-27 16:35

通过

zltzlt

永恒的蓝色梦想 发表于 2019-10-27 17:06

输入：A='Z S E E S A', B='Z Z A A S E', C='A Z'
输出：False
False
A 1
Z 1
预期结果：False
True
A 1
Z 1

永恒的蓝色梦想

阴阳神万物主 发表于 2019-10-27 17:00
这锅我背了，我换个好懂的描述吧：
背景

话说应该查封难道不应该是True吗……为什么是False

永恒的蓝色梦想

zltzlt 发表于 2019-10-27 17:15
输入：A='Z S E E S A', B='Z Z A A S E', C='A Z'
输出：False
False

感觉你和他的例子冲突了啊……

zltzlt

永恒的蓝色梦想 发表于 2019-10-27 17:23
感觉你和他的例子冲突了啊……

好吧，你的输出是对的

阴阳神万物主

永恒的蓝色梦想 发表于 2019-10-27 17:16
话说应该查封难道不应该是True吗……为什么是False

我在那里有个否定词

永恒的蓝色梦想

__mrsq__ 发表于 2019-10-27 16:39
打印{需要的物品单词} {如果 A 要满足 B 的需求需要进货的最少数量}

感谢，已经解决了

阴阳神万物主

zltzlt 发表于 2019-10-27 17:15
输入：A='Z S E E S A', B='Z Z A A S E', C='A Z'
输出：False
False

买不着，货都有但不够 ——> 第一行 False
商店违规进货 ——> 第二行 False
小明没有失落，按照 B 中从左到右的规则输出补货需求：
Z 1
A 1

所以，前两行没毛病，问题出在后面的顺序

danteer

1. def func(stra,strb,strc):
   
2.     dicta = {}
   
3.     dictb = {}
   
4.     stra = stra.split()
   
5.     for each in set(stra):
   
6.         dicta[each] = stra.count(each)
   
7.     strb = strb.split()
   
8.     for each in set(strb):
   
9.         dictb[each] = strb.count(each)
   
10.     listc = strc.split()
    
11.     kind = True
    
12.     kindforbidden = True
    
13.     kindless = []
    
14.     number = True
    
15.     numberless = {}
    
16.    
    
17.     for each in dictb:
    
18.         if not each in dicta:
    
19.             kind = False
    
20.             kindless.append(each)
    
21.         else:
    
22.             if dicta[each] < dictb[each]:
    
23.                 number = False
    
24.                 numberless[each] = dictb[each] - dicta[each]
    
25.                
    
26.     for each in dictb:
    
27.         if not each in dicta and not each in listc:
    
28.             print('Impossible')
    
29.             return None
    
30.         
    
31.     if number == True and kind == True:
    
32.         print(True)
    
33.     else:
    
34.         print(False)
    
35.         
    
36.     for each in dicta:
    
37.         if not each in listc:
    
38.             kindforbidden = False
    
39.     if kindforbidden == True:
    
40.         print(True)
    
41.     else:
    
42.         print(False)
    
43.    
    
44.     for each in strb:
    
45.         if strb.count(each) > 1:
    
46.             counter = strb.count(each) - 1
    
47.             while counter > 0:
    
48.                 strb.remove(each)
    
49.                 counter -= 1
    
50.    
    
51.     for each in strb:
    
52.         if each in kindless:
    
53.             print(each,str(dictb[each]))
    
54.         elif each in numberless:
    
55.             print(each,str(numberless[each]))

复制代码

真实的阅读理解题

动心成神

1. A = 'Star Chimpanzee Monkey Monkey Little-Turtle Mom Son Ball Ball Ball'
   
2. B = 'Ball Star Ball'
   
3. C = 'Star Chimpanzee Monkey Little-Turtle Mom Son Ball'
   
4. 
   
5. # 要求a
   
6. print(sum(list(map(lambda x:x in A.split(' ') and B.split(' ').count(x)<=A.split(' ')
   
7.                    .count(x),B.split(' '))))==len(B.split(' ')))
   
8. 
   
9. print(sum(list(map(lambda x:x in C.split(' '),set(A.split(' ')))))==len(set(A.split(' '))))
   
10. 
    
11. #要求b
    
12. if sum(list(map(lambda x:x in A.split(' ') and B.split(' ').count(x)<=A.split(' ')
    
13.                    .count(x),set(B.split(' ')))))!=len(B.split(' ')):
    
14.     for i in list(set(B.split(' '))):
    
15.         if i not in A.split(' '):
    
16.             if i not in C.split(' '):
    
17.                 print('{%s}Impossible'%(i))
    
18.             else:
    
19.                 print('{%s}{%d}'%(i,B.split(' ').count(i)))
    
20.         elif B.split(' ').count(i)>A.split(' ').count(i):
    
21.             print('{%s}{%d}'%(i,B.split(' ').count(i)-A.split(' ').count(i)))
    
22. 
    

复制代码

战场原

def solution(A: str, B:str, C:str) -> str :
    from collections import Counter
    A = A.split()
    B = B.split()
    C = C.split()

    if set(A).intersection(set(B)) != set(B) and set(B).union(set(C))!=set(C):
        return "Impossible"

    res = list()
    tmp = list()
    dictA = Counter(A)
    dictB = Counter(B)
    dictA.subtract(dictB)
    #print(dictA)
    for i,v in dictA.items():
        if v<0:
            res.append("False")
            tmp.append(i)
            tmp.append(str(-v))
    if len(res)>0:
        res = res[:1]
    else:
        res.append("True")
    res.append(str(set(A).union(set(C))==set(C)))
    res = res+tmp
    return "\n".join(res)

panheng

题目没看懂 真的

python万

华一仙

1. def f264(A, B, C):
   
2.     """
   
3.     A: 仓库存货
   
4.     B: 采购列表
   
5.     C: 合法清单
   
6.     """
   
7.     a_list, b_list = A.split(), B.split()
   
8.     a_set, b_set, c_set = set(a_list), set(b_list), set(C.split())
   
9.     for b in b_set - c_set:
   
10.         if b not in a_set:                          # 若 B 的非法物品在 A 仓库中没有库存
    
11.             print("Impossible")
    
12.             return
    
13. 
    
14.     repo_dict = {i:a_list.count(i) for i in a_set}  # 用来放 A 仓库的存货
    
15.     lack_dict = {}                                  # 用来放 A 仓库无法满足 B 的部分
    
16.     legal = True                                    # 默认 A 仓库的物品均合法
    
17.     for b in b_set:                                 # 将 A 仓库无法满足 B 的物品放入 lack_dict
    
18.         cnt = b_list.count(b)
    
19.         if b not in a_set:
    
20.             lack_dict[b] = cnt
    
21.         elif repo_dict[b] < cnt:
    
22.             lack_dict[b] = cnt - repo_dict[b]
    
23.     for a in a_set:
    
24.         if a not in c_set:                          # 若 A 仓库有非法物品，则做好标记并退出循环
    
25.             legal = False
    
26.             break
    
27. 
    
28.     bought_all = lack_dict == {}
    
29.     print(bought_all)                               # B 中的物品是否能买齐
    
30.     print(legal)                                    # A 中的物品是否均合法
    
31.     if not bought_all:
    
32.         lack_list = [k for k in lack_dict.keys()]
    
33.         lack_list.sort(key=b_list.index)
    
34.         for b in lack_list:                         # 按 B 中的顺序输出没买齐的物品
    
35.             print(b, lack_dict[b])
    
36.     return

复制代码

kaohsing

1. from collections import Counter
   
2. 
   
3. 
   
4. class Kao():
   
5. 
   
6.     def __init__(self, A, B, C):
   
7.         self.shopGoodLst = Counter(list(A.split()))
   
8.         self.buyGoodLST = Counter(list(B.split()))
   
9.         self.soldGoodLst = Counter(list(C.split()))
   
10.         self.a, self.b = self.shopBuygoods()
    
11. 
    
12.     def isFoul(self):
    
13.         for good in self.shopGoodLst:
    
14.             if good not in self.soldGoodLst:
    
15.                 return True
    
16.         else:
    
17.             return False
    
18. 
    
19.     def haveGood(self):
    
20.         for good in self.buyGoodLST:
    
21.             if good not in self.shopGoodLst:
    
22.                 return True
    
23.         else:
    
24.             return False
    
25. 
    
26.     def shopBuygoods(self):
    
27.         a, b = '', ''
    
28.         for good in self.buyGoodLST:
    
29.             if self.shopGoodLst[good]:
    
30.                 if self.buyGoodLST[good] > self.shopGoodLst[good]:
    
31.                     a += good + ' ' + str(self.buyGoodLST[good] - self.shopGoodLst[good]) + '\n'
    
32.             else:
    
33.                 b += good
    
34.                 a += good + ' ' + str(self.buyGoodLST[good] - self.shopGoodLst[good]) + '\n'
    
35.         return a, b
    
36. 
    
37.     def juge(self):
    
38.         s, s1 = True, True
    
39.         if self.isFoul() and self.haveGood():
    
40.             return 'Impossible'
    
41.         if self.b or self.a:
    
42.             s = False
    
43.         if self.isFoul():
    
44.             s1 = False
    
45.         return str(s) + '\n' + str(s1) + '\n' + self.a
    
46. 
    
47. 
    
48. 
    
49. A = 'Z S E E S A'
    
50. B = 'Z Z A A S E'
    
51. C = 'A Z'
    
52. print(Kao(A, B, C).juge())

复制代码