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

永恒的蓝色梦想

def makedict(s):
    s=s.split(' ')
    return {i:s.count(i) for i in set(s)}
def function(A,B,C):
    set_c=set(C.split(' '))
    a=makedict(A)
    b=makedict(B)

    res=[True]
    for i in b:
        try:
            if a[i]<b[i]:
                res[0]=False
                res.append(f'{i} {b[i]-a[i]}')
        except:
            res[0]=False
            if i not in set_c:
                print("Impossible")
                return
            else:
                res.append(f'{i} {b[i]}')
    res.insert(1,bool(len(set(a)-set_c)))
    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

def func(stra,strb,strc):
    dicta = {}
    dictb = {}
    stra = stra.split()
    for each in set(stra):
        dicta[each] = stra.count(each)
    strb = strb.split()
    for each in set(strb):
        dictb[each] = strb.count(each)
    listc = strc.split()
    kind = True
    kindforbidden = True
    kindless = []
    number = True
    numberless = {}
    
    for each in dictb:
        if not each in dicta:
            kind = False
            kindless.append(each)
        else:
            if dicta[each] < dictb[each]:
                number = False
                numberless[each] = dictb[each] - dicta[each]
                
    for each in dictb:
        if not each in dicta and not each in listc:
            print('Impossible')
            return None
        
    if number == True and kind == True:
        print(True)
    else:
        print(False)
        
    for each in dicta:
        if not each in listc:
            kindforbidden = False
    if kindforbidden == True:
        print(True)
    else:
        print(False)
    
    for each in strb:
        if strb.count(each) > 1:
            counter = strb.count(each) - 1
            while counter > 0:
                strb.remove(each)
                counter -= 1
    
    for each in strb:
        if each in kindless:
            print(each,str(dictb[each]))
        elif each in numberless:
            print(each,str(numberless[each]))

真实的阅读理解题

动心成神

A = 'Star Chimpanzee Monkey Monkey Little-Turtle Mom Son Ball Ball Ball'
B = 'Ball Star Ball'
C = 'Star Chimpanzee Monkey Little-Turtle Mom Son Ball'

# 要求a
print(sum(list(map(lambda x:x in A.split(' ') and B.split(' ').count(x)<=A.split(' ')
                   .count(x),B.split(' '))))==len(B.split(' ')))

print(sum(list(map(lambda x:x in C.split(' '),set(A.split(' ')))))==len(set(A.split(' '))))

#要求b
if sum(list(map(lambda x:x in A.split(' ') and B.split(' ').count(x)<=A.split(' ')
                   .count(x),set(B.split(' ')))))!=len(B.split(' ')):
    for i in list(set(B.split(' '))):
        if i not in A.split(' '):
            if i not in C.split(' '):
                print('{%s}Impossible'%(i))
            else:
                print('{%s}{%d}'%(i,B.split(' ').count(i)))
        elif B.split(' ').count(i)>A.split(' ').count(i):
            print('{%s}{%d}'%(i,B.split(' ').count(i)-A.split(' ').count(i)))

战场原

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万

华一仙

def f264(A, B, C):
    """
    A: 仓库存货
    B: 采购列表
    C: 合法清单
    """
    a_list, b_list = A.split(), B.split()
    a_set, b_set, c_set = set(a_list), set(b_list), set(C.split())
    for b in b_set - c_set:
        if b not in a_set:                          # 若 B 的非法物品在 A 仓库中没有库存
            print("Impossible")
            return

    repo_dict = {i:a_list.count(i) for i in a_set}  # 用来放 A 仓库的存货
    lack_dict = {}                                  # 用来放 A 仓库无法满足 B 的部分
    legal = True                                    # 默认 A 仓库的物品均合法
    for b in b_set:                                 # 将 A 仓库无法满足 B 的物品放入 lack_dict
        cnt = b_list.count(b)
        if b not in a_set:
            lack_dict[b] = cnt
        elif repo_dict[b] < cnt:
            lack_dict[b] = cnt - repo_dict[b]
    for a in a_set:
        if a not in c_set:                          # 若 A 仓库有非法物品，则做好标记并退出循环
            legal = False
            break

    bought_all = lack_dict == {}
    print(bought_all)                               # B 中的物品是否能买齐
    print(legal)                                    # A 中的物品是否均合法
    if not bought_all:
        lack_list = [k for k in lack_dict.keys()]
        lack_list.sort(key=b_list.index)
        for b in lack_list:                         # 按 B 中的顺序输出没买齐的物品
            print(b, lack_dict[b])
    return

kaohsing

from collections import Counter


class Kao():

    def __init__(self, A, B, C):
        self.shopGoodLst = Counter(list(A.split()))
        self.buyGoodLST = Counter(list(B.split()))
        self.soldGoodLst = Counter(list(C.split()))
        self.a, self.b = self.shopBuygoods()

    def isFoul(self):
        for good in self.shopGoodLst:
            if good not in self.soldGoodLst:
                return True
        else:
            return False

    def haveGood(self):
        for good in self.buyGoodLST:
            if good not in self.shopGoodLst:
                return True
        else:
            return False

    def shopBuygoods(self):
        a, b = '', ''
        for good in self.buyGoodLST:
            if self.shopGoodLst[good]:
                if self.buyGoodLST[good] > self.shopGoodLst[good]:
                    a += good + ' ' + str(self.buyGoodLST[good] - self.shopGoodLst[good]) + '\n'
            else:
                b += good
                a += good + ' ' + str(self.buyGoodLST[good] - self.shopGoodLst[good]) + '\n'
        return a, b

    def juge(self):
        s, s1 = True, True
        if self.isFoul() and self.haveGood():
            return 'Impossible'
        if self.b or self.a:
            s = False
        if self.isFoul():
            s1 = False
        return str(s) + '\n' + str(s1) + '\n' + self.a



A = 'Z S E E S A'
B = 'Z Z A A S E'
C = 'A Z'
print(Kao(A, B, C).juge())