Python：每日一题 79（答题领鱼币）

MSK

---

题目:

给定两个字符串 s1 和 s2 如果s1 内的字符通过重新组合后能成为 s2返回True
否则返回False

要求:

分别写出s1内的字符可以重复使用和不可以重复使用时的答案

---

答案：

游客，如果您要查看本帖隐藏内容请回复

TOP_LK

pingws928

新手，借鉴一下，嘿嘿

chunchun2017

def FX(s1,s2):
    if(set(s1.strip())==set(s2.strip())):
            print('True')
            if(len(s1)==len(s2)):
              print('s1内的字符不可以重复使用构成s2')
            else:
              print('s1内的字符可以重复使用构成s2'')
    else:
            print('False')
s1=input('请输入字符串S1：')
s2=input('请输入字符串S2：')
FX(s1,s2)

运行结果：
============== RESTART: C:\Users\每日一题\79.py ==============
请输入字符串S1：I am Boy
请输入字符串S2：I am a Boy
True
s1内的字符可以重复使用构成s2
>>>

============== RESTART: C:\Users\每日一题\79.py ==============
请输入字符串S1：aaaa
请输入字符串S2：bbbb
False
>>>
============== RESTART: C:\Users\每日一题\79.py ==============
请输入字符串S1：abcd
请输入字符串S2：abcdddd
True
s1内的字符可以重复使用构成s2
>>>
============== RESTART: C:\Users\每日一题\79.py ==============
请输入字符串S1：abcd
请输入字符串S2：dbca
True
s1内的字符不可以重复使用构成s2
>>>

chunchun2017

发了答案后，再看到大神给出的答案，才发现自己理解的和题目原意有点差别，自己理解的是dbca重新排列可以组成abcd，不需要重复使用字符；dbca重新排列并且重复使用字符，可以构成abbbcd；dbca重新排列不能构成dbcae，哈哈，不过总体思路上没有问题的，继续膜拜大神！

jerryxjr1220

def chongfu(s1, s2):
        return set(s2)<set(s1)

def buchongfu(s1, s2):
        from collections import Counter
        for s_s2, n_s2 in Counter(s2).items():
                if s_s2 in s1:
                        if s1.count(s_s2) < n_s2:
                                return False
                else:
                        return False
        return True

print(chongfu('abcd', 'aab'))

print(buchongfu('abcd', 'aab'))

woigh

s1 = input("输入S1字符串: ")
s2 = input("输入S2字符串: ")

if set(s1) == set(s2):
    print("result = True")
    if len(s1) == len(s2):
        print("s1内字符串可以重複使用时, 可以通过组合成为s2")
        print("s1内字符串不可以重複使用时, 亦可以通过组合成为s2")
    else:
        print("s1内字符串可以重複使用时, 可以通过组合成为s2")
        print("s1内字符串不可以重複使用时, 无法通过组合成为s2")
else:
    print("result = False")

晒月亮的扎克

能不能给一些例子

MSK

晒月亮的扎克 发表于 2017-8-17 06:10
能不能给一些例子

假设

s1 = 'oelh' 
s2='hello'

当s1内的字符可以重复使用时,s1可以重新排列组成s2
当不可以重复使用时,不可以重新排列组成s2

冬雪雪冬

第一种跟@jerryxjr1220 一样。

s1 = 'oelhl' 
s2='hello'
def fun(s1, s2):
    lst = list(s1)
    for each in s2:
        if each not in lst:
            return False
        lst.remove(each)
    return True
print(fun(s1, s2))

bush牛

def tran_list(s1, s2, a1, a2):
    for i in s1:
        a1.append(i)
    for j in s2:
        a2.append(j)
    return a1, a2

def copy(a1, a2):
    flag = True
    for i in range(len(a2)):
        if a2[i] not in a1:
            flag = False
            break 
    if flag:
        print("s1内的字符可以重复使用时构成s2")
    else:
        print("s1内的字符即使可以重复使用时也不能构成s2")


def not_copy(a1,a2):
    flag = True
    for i in range(len(a1)):
        if a1[i] in a2:
            a2.remove(a1[i])
        if i == (len(a1)-1):
            if a2:
                flag = False
    if flag:
        print("s1内的字符可以不重复使用时构成s2")
    else:
        print("s1内的字符不重复使用时不能构成s2")
    
if __name__ == '__main__':
    s1 = 'accd boprty python'
    s2 = 'aabb'
    a1, a2 = [], []
    a1, a2 = tran_list(s1, s2,a1, a2)
    copy(a1, a2)
    not_copy(a1,a2)

Greenland

def isReusable(s1, s2):
    return set(s1).issuperset(set(s2))

def isReusableStrict(s1, s2):
    source = list(s1)
    for s in s2:
        if source.count(s)>0:
            source.remove(s)
        else:
            return False
    return True

hhkayhh

其实我还没学到这

guoxiaopeng

def make_up(s1,s2,reUseFlag):
    map = {}
    for item in s1:
        if item not in map.keys():
            map[item] = 0
        map[item]+= 1
    if reUseFlag == 'False':
        for item in s2:
            if item in map.keys():
                if(map[item] > 0):
                    map[item] -= 1
                else:
                    return False
            else:
                return False
        return True
    else:
        for item in s2:
            if item not in map.keys():
                    return False
        return True

用reUseFlag=False 表示不可重用模式，True代表可重用模式
>>> make_up('---..-','..----','True')
True
>>> make_up('---..-','..----','False')
True

>>> make_up('hello world','hello  world','False')
False
>>> make_up('hello world','hello  world','True')
True

guoxiaopeng

当我看到楼主的答案时，我惊呆了

Jiangxiao_Bai

# s1 能组合成为s2   可以重复
s1 = "12123"
s2 = "132131"
for char in s1:
    if char in s2:
        pass
    else:
        
        print(False)
        break
else:
    print(True)

# s1能组合成s2不能重复
s1 = "11234456"
s2 = "112343456"
for char in s1:
    if char in s2 and s1.count(char) >= s2.count(char):
        pass
    else:
        print(False)
        break
else:
    print(True)

qwc3000

s1=input("input s1:")
s2=input("input s2:")
logo=False
for x in s2:
    print(x)
    for y in s1:
        print(y)
        if x == y:
            logo=True
            print(logo)
            break
        else:
            logo=False
            print(logo)
    if logo == False:
        break
if logo:
    print(logo)
else:
    print(logo)


要求没看懂   先看看大神的答案再说

ywhywh

def repeat(s1, s2):
    if set(s1) == set(s2):
        temp = list(set(s1))
        s1 = list(s1)
        s2 = list(s2)
        for each in temp:
            s1.remove(each)
            s2.remove(each)
        if s1 == s2:
            return '当s1中的字符重复可以使用时,可以组合成s2\n不可以重复使用时也可以组合成s2'
        else:
            return '当s1中的字符重复可以使用时,可以组合成s2\n不可以重复使用时则不可以组合成s2'
    else:
        return 's1不能组合为s2'


print(repeat('oelh', 'hello'))

warthog

看看

solomonxian

s1 能成为 s2 是指包含还是相等呢？
没例子说明，那我假设是相等啦

# 不可重复利用时，只要sorted后相等
def check_combine(s_1,s_2):
    return sorted(s_1) == sorted(s_2)

# 可重复利用时，就是集合元素相等
def check_recombine(s_1,s_2):
    return set(s_1) == set(s_2)