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

MSK

---

题目:

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

要求:

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

---

答案：

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

TOP_LK

pingws928

新手，借鉴一下，嘿嘿

chunchun2017

1. def FX(s1,s2):
   
2.     if(set(s1.strip())==set(s2.strip())):
   
3.             print('True')
   
4.             if(len(s1)==len(s2)):
   
5.               print('s1内的字符不可以重复使用构成s2')
   
6.             else:
   
7.               print('s1内的字符可以重复使用构成s2'')
   
8.     else:
   
9.             print('False')
   
10. s1=input('请输入字符串S1：')
    
11. s2=input('请输入字符串S2：')
    
12. 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

1. def chongfu(s1, s2):
   
2.         return set(s2)<set(s1)
   
3. 
   
4. def buchongfu(s1, s2):
   
5.         from collections import Counter
   
6.         for s_s2, n_s2 in Counter(s2).items():
   
7.                 if s_s2 in s1:
   
8.                         if s1.count(s_s2) < n_s2:
   
9.                                 return False
   
10.                 else:
    
11.                         return False
    
12.         return True
    
13. 
    
14. print(chongfu('abcd', 'aab'))
    
15. 
    
16. print(buchongfu('abcd', 'aab'))

复制代码

woigh

1. s1 = input("输入S1字符串: ")
   
2. s2 = input("输入S2字符串: ")
   
3. 
   
4. if set(s1) == set(s2):
   
5.     print("result = True")
   
6.     if len(s1) == len(s2):
   
7.         print("s1内字符串可以重複使用时, 可以通过组合成为s2")
   
8.         print("s1内字符串不可以重複使用时, 亦可以通过组合成为s2")
   
9.     else:
   
10.         print("s1内字符串可以重複使用时, 可以通过组合成为s2")
    
11.         print("s1内字符串不可以重複使用时, 无法通过组合成为s2")
    
12. else:
    
13.     print("result = False")
    

复制代码

晒月亮的扎克

能不能给一些例子

MSK

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

假设

1. s1 = 'oelh'
   
2. s2='hello'

复制代码

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

冬雪雪冬

第一种跟@jerryxjr1220 一样。

1. s1 = 'oelhl'
   
2. s2='hello'
   
3. def fun(s1, s2):
   
4.     lst = list(s1)
   
5.     for each in s2:
   
6.         if each not in lst:
   
7.             return False
   
8.         lst.remove(each)
   
9.     return True
   
10. print(fun(s1, s2))

复制代码

bush牛

1. def tran_list(s1, s2, a1, a2):
   
2.     for i in s1:
   
3.         a1.append(i)
   
4.     for j in s2:
   
5.         a2.append(j)
   
6.     return a1, a2
   
7. 
   
8. def copy(a1, a2):
   
9.     flag = True
   
10.     for i in range(len(a2)):
    
11.         if a2[i] not in a1:
    
12.             flag = False
    
13.             break
    
14.     if flag:
    
15.         print("s1内的字符可以重复使用时构成s2")
    
16.     else:
    
17.         print("s1内的字符即使可以重复使用时也不能构成s2")
    
18. 
    
19. 
    
20. def not_copy(a1,a2):
    
21.     flag = True
    
22.     for i in range(len(a1)):
    
23.         if a1[i] in a2:
    
24.             a2.remove(a1[i])
    
25.         if i == (len(a1)-1):
    
26.             if a2:
    
27.                 flag = False
    
28.     if flag:
    
29.         print("s1内的字符可以不重复使用时构成s2")
    
30.     else:
    
31.         print("s1内的字符不重复使用时不能构成s2")
    
32.    
    
33. if __name__ == '__main__':
    
34.     s1 = 'accd boprty python'
    
35.     s2 = 'aabb'
    
36.     a1, a2 = [], []
    
37.     a1, a2 = tran_list(s1, s2,a1, a2)
    
38.     copy(a1, a2)
    
39.     not_copy(a1,a2)
    

复制代码

Greenland

1. def isReusable(s1, s2):
   
2.     return set(s1).issuperset(set(s2))
   
3. 
   
4. def isReusableStrict(s1, s2):
   
5.     source = list(s1)
   
6.     for s in s2:
   
7.         if source.count(s)>0:
   
8.             source.remove(s)
   
9.         else:
   
10.             return False
    
11.     return True

复制代码

hhkayhh

其实我还没学到这

guoxiaopeng

1. def make_up(s1,s2,reUseFlag):
   
2.     map = {}
   
3.     for item in s1:
   
4.         if item not in map.keys():
   
5.             map[item] = 0
   
6.         map[item]+= 1
   
7.     if reUseFlag == 'False':
   
8.         for item in s2:
   
9.             if item in map.keys():
   
10.                 if(map[item] > 0):
    
11.                     map[item] -= 1
    
12.                 else:
    
13.                     return False
    
14.             else:
    
15.                 return False
    
16.         return True
    
17.     else:
    
18.         for item in s2:
    
19.             if item not in map.keys():
    
20.                     return False
    
21.         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

1. def repeat(s1, s2):
   
2.     if set(s1) == set(s2):
   
3.         temp = list(set(s1))
   
4.         s1 = list(s1)
   
5.         s2 = list(s2)
   
6.         for each in temp:
   
7.             s1.remove(each)
   
8.             s2.remove(each)
   
9.         if s1 == s2:
   
10.             return '当s1中的字符重复可以使用时,可以组合成s2\n不可以重复使用时也可以组合成s2'
    
11.         else:
    
12.             return '当s1中的字符重复可以使用时,可以组合成s2\n不可以重复使用时则不可以组合成s2'
    
13.     else:
    
14.         return 's1不能组合为s2'
    
15. 
    
16. 
    
17. print(repeat('oelh', 'hello'))

复制代码

warthog

看看

solomonxian

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

1. # 不可重复利用时，只要sorted后相等
   
2. def check_combine(s_1,s_2):
   
3.     return sorted(s_1) == sorted(s_2)
   
4. 
   
5. # 可重复利用时，就是集合元素相等
   
6. def check_recombine(s_1,s_2):
   
7.     return set(s_1) == set(s_2)

复制代码