分配是编写一个程序，接受来自用户的两组单词，然后如果两个是字谜（或者至少如果一个字母的所有字母都存在于另一个中），则打印“True”语句如果没有“假”声明。
作为一个整体编程的新手，我不知道如何超越仅仅索引一个字符串并比较一个字符串的所有部分。我强调我是初学者;我已经阅读了许多其他标有Python和Anagram的帖子，它们总是在我的脑海中并且参考我没有被教过的东西。所以越简单越好。到目前为止，这是我的非工作代码：
s1 = input("Please enter a word:")
s2 = input("Please enter another word:")
for i in range(0, len(s1), 1):
if i in range (0, len(s2), 1):
print("The letters in your first word are present in your second word.")
答案 0 :(得分：37)
为什么不对字符串进行排序？
>>> sorted('anagram')
['a', 'a', 'a', 'g', 'm', 'n', 'r']
>>> sorted('nagaram')
['a', 'a', 'a', 'g', 'm', 'n', 'r']
>>> sorted('anagram') == sorted('nagaram')
True
答案 1 :(得分：15)
您可以使用集合库中的魔术Counter。 来自文档：
这是一个无序集合，其中元素存储为字典键，其计数存储为字典值
因此，您可以使用字符串（可迭代）初始化Counter对象，并与字符串中的另一个Counter进行比较
from collections import Counter
def is_anagram(str1, str2):
return Counter(str1) == Counter(str2)
答案 2 :(得分：5)
您需要更多地考虑条件逻辑。循环在正确的轨道上，但如果s1中的字母不在s2中，则应该break退出此循环并打印“False”语句。考虑使用all_s1_in_s2 = True之类的变量，如果找到不匹配的字母，请将其设置为false。
其他一些提示：
for l in s1会遍历字符串s1，让您按顺序访问每个字母l - 您根本不需要range或len < / p>
if .. in语句可以帮助测试字符串中是否存在字母，例如if letter in mystring:是一个有效的声明，这可以为您提供很多帮助，同样不需要range或len
您应尽可能避免在变量名称中使用数字 - 例如，word_one和word_two更好，
答案 3 :(得分：2)
def is_anagram(w1, w2):
w1, w2 = list(w1.upper()), list(w2.upper())
w2.sort()
w1.sort()
return w1 == w2
答案 4 :(得分：1)
如果您坚持使用Python字典并且不能使用函数式编程，那么这是一个解决方案：
使用理解创建字典，并使用简单的==运算符比较两个单词的字典。
def isanagram2(wrd1, wrd2):
wrd1_dict = {k: 0 for k in wrd1}
wrd2_dict = {k: 0 for k in wrd2}
for c1, c2 in zip(wrd1, wrd2):
wrd1_dict[c1] += 1
wrd2_dict[c2] += 1
if wrd1_dict == wrd2_dict:
return True
return False
答案 5 :(得分：1)
您可以使用以下代码，它不会计算特殊字符，也不会计算数字并返回＆＃34;它们是字谜＆＃34;如果两个字符串中的总字符数相同，则会告诉字符串是否为字谜。
text = input('Enter a string: ')
text1 = input('Enter a string: ')
text,text1 = text.lower(),text1.lower()
count = 0
count1=0
for i in range(97,123):
if chr(i) in text and chr(i) in text1:
count1+=1
if text.count(chr(i)) == text1.count(chr(i)):
count +=1
if len(text) >= len(text1):
num1 = len(text)
else:
num1 = len(text1)
if count == count1:
print("they are anagrams")
else :
print("they are not anagrams")
答案 6 :(得分：1)
使用词典检查两个字符串是否是彼此的字谜： 注意：偶数，特殊字符可用作输入
def anagram(s):
string_list = []
for ch in s.lower():
string_list.append(ch)
string_dict = {}
for ch in string_list:
if ch not in string_dict:
string_dict[ch] = 1
else:
string_dict[ch] = string_dict[ch] + 1
return string_dict
s1 = "master"
s2 = "stream"
a = anagram(s1)
b = anagram(s2)
if a == b:
print "Anagram"
else:
print "Not Anagram"
答案 7 :(得分：1)
>>> s1 = 'vivid'
>>> s2 = 'dvivi'
>>> s3 = 'vivid'
>>> def is_anagram(s1, s2):
... if s1.lower() == s2.lower():
... return False
... return sorted(s1.lower()) == sorted(s2.lower())
...
>>> is_anagram(s1, s2)
True
>>> is_anagram(s1, s3)
False
>>> s2 = 'dvivii'
>>> is_anagram(s1, s2)
False
>>> s2 = 'evivi'
>>> is_anagram(s1, s2)
False
>>>
答案 8 :(得分：0)
def check_(arg):
mark = hash(str(set(sorted(arg))))
return mark
def ana(s1, s2):
if check_(s1) != check_(s2):
pass
elif len(s1) != len(s2):
pass
else:
print("{0} could be anagram of {1}".format(s1, s2))答案 9 :(得分：0)
这里是使用字典理解的解决方案。
def is_anagram(s1, s2):
return {c:s1.count(c) for c in s1} == {c:s2.count(c) for c in s2}
答案 10 :(得分：0)
不确定是否在那里提出了建议，但我同意了：
def is_anagram(a, b):
return sorted(a.lower()) == sorted(b.lower())
答案 11 :(得分：0)
Anagram的Java代码
static void anagram(String s1,String s2){
if(s1.length()!=s2.length()){
System.out.println("not anagram");
return;
}
else{
int []arr=new int[256];
int size=s1.length();
for(int i=0;i<size;i++){
arr[s1.charAt(i)]++;
arr[s2.charAt(i)]--;
}
for(int i=0;i<256;i++){
if(arr[i]!=0){
System.out.println("not anagram");
return;
}
}
System.out.println("anagram");
}
}
答案 12 :(得分：0)
def anagram(a,b):
x=[]
y=[]
for i in a:
if i!=' ': # This will ignore the spaces in the sentence
x+=[i] # Adds only letters into a list and ignore the spaces
for i in b:
if i!=' ':
y+=[i]
if len(x)==len(y): # if length of two lists are not same, They are not anagrams anyway. So it directly returns False.
for i in range(len(x)):
for j in range(len(y)):
if x[i].lower()==y[j].lower():
y.pop(j) # If the letter matched between first and second list, that letter is poped from that list.
break
return len(y)==0 # If the given sentences are anagrams, all the letters are poped out from the second list and function returns True(as the lenght of the second list is 0. If not, function will return False.
return False
anagram（a，b）
答案 13 :(得分：0)
这是一种典型的分配解决方案：
def anagram(s1, s2):
""" (str, str) -> bool
Return True if s1 and s2 are anagrams
>>> anagram(s1, s2)
True
"""
s1 = s1.replace(" ", "")
s2 = s2.replace(" ", "")
s1_new = list(s1)
s2_new = list(s2)
if len(s1_new) == len(s2_new):
dupe_found = True
while dupe_found:
dupe_found = False
for i in s1_new:
for j in s2_new:
if i == j:
s1_new.remove(i)
s2_new.remove(j)
dupe_found = True
break
break
return s1_new == s2_new
答案 14 :(得分：0)
我认为我们可以像这样
s1 = "listen"
s2 = "silent"
s1=list(s1);s1.sort()
s2 = list(s2);s2.sort()
if s1 == s2:
print ("Given Strings are Anagram")
else:
print ("Given String are not anagrams")
答案 15 :(得分：0)
最短的解决方案
def anagram(word1, word2):
return sorted(word1) == sorted(word2)
检查
print(anagram("xyz","zyx"))
>>True
print(anagram("xyz","zyy"))
>>False
答案 16 :(得分：0)
#An anagram is the result of rearranging the letters of a word to produce a new word. Anagrams are case insensitive
#Examples:
# foefet is an anagram of toffee
# Buckethead is an anagram of DeathCubeK
# The shortest my function style ***************************************
def is_anagram1(test, original):
"""Сhecks 'test' is anagram of 'original' strings based on:
1. length of the both string and length of the sets made from the strings is equivalent
2. then checks equivalents of sorted lists created from test and original strings
>>> is_anagram1('Same','same')
False
>>> is_anagram1('toffee','foeftt')
False
>>> is_anagram1('foefet','toffee')
True
>>> is_anagram1("Buuckk",'kkkcuB')
False
>>> is_anagram1('Buckethead','DeathCubeK')
True
>>> is_anagram1('DeathCubeK','Buckethead')
True
"""
# check the length of the both string
if len(test) != len(original):
return False
# check is the strings are the same
t,o = test.lower(), original.lower()
if t == o:
return False
# check the sorted lists
return sorted(t) == sorted(o)
# The final my one line code **************************************
def is_anagram(test, original):
"""Сhecks 'test' is anagram of 'original' in one line of code
>>> is_anagram('Same','same')
False
>>> is_anagram('toffee','foeftt')
False
>>> is_anagram('foefet','toffee')
True
>>> is_anagram("Buuckk",'kkkcuB')
False
>>> is_anagram('Buckethead','DeathCubeK')
True
>>> is_anagram('DeathCubeK','Buckethead')
True
"""
return False if len(test) != len(original) or test.lower() == original.lower() else sorted(test.lower()) == sorted(original.lower())
if __name__ == "__main__":
import doctest
doctest.testmod(verbose=True)
### 2 items passed all tests:
### 6 tests in __main__.is_anagram
### 6 tests in __main__.is_anagram1
### 12 tests in 3 items.
### 12 passed and 0 failed.
### Test passed
答案 17 :(得分：0)
str1="abcd"
str2="bcad"
word1=[]
word2=[]
for x in range(len(str1)):
word1.append(str1[x])
for x in range(len(str2)):
word2.append(str2[x])
if(len(word1)==len(word2)):
for letter in word1:
if letter in word2:
word2.remove(letter)
if len(word2)==0:
print "anagram"
else:
print "not anagram"
答案 18 :(得分：-1)
在这种情况下，我们检查每个排序的字符串是否使用两个容器。
def anagram(s1, s2):
str1 = ''
str2 = ''
for i in s1:
str1 += i
for j in s2:
str2 += j
if str1 == str2:
return True
return False
答案 19 :(得分：-1)
我认为最简单的方法可以是：
fstr=input("enter first string:")
sstr=input("enter second string:")
if(fstr==sstr[::-1]):
print("it's anagram")
答案 20 :(得分：-1)
说明：在下面的代码中，我们可以回答两个问题：1）两个字符串是否是字谜，2）如果w2是w1的子序列的字谜。我们使用O（1）空间（常数）和O（n）时间。字典d0可以扩展为包含任何字符，并且我们保持在O（1）空间范围内。
def anagrams(w1,w2):
d0={chr(i):0 for i in range(ord('a'),ord('z'))}
for char in w1:
d0[char]+=1
for char in w2:
if d0[char]==0:
return False
else:
d0[char]-=1
return sum([d0[x] for x in d0])==0 #return True (for subseqence anagram)
答案 21 :(得分：-1)
str1='ohaha'
str2='hahao1'
set3=set(str1)
set4=set(str2)
if(len(set3.difference(set4))==0 and len(set4.difference(set3))==0):
print('anagrams')
else:
print('not anagrams')
答案 22 :(得分：-1)
Anagrams是由两个不同的单词组成的相同字符：例如：EAT和TEA同样可以有很多例子。
查看是否给出两个单词或句子是anagrams的一个好方法是设置一个大小为256的计数器数组，并且最初将所有值设置为0.（如果输入更大，这可能是一个很好的选择，至少现在开始读取第一个字符串（单词或句子），并将数组中相应的ASCII位置增加一个。对完整的字符串重复此操作。 现在开始读取第二个字符串并继续减少数组中每个字母的相应ASCII计数器。 最后，解析数组;如果所有值都为零，那么输入是字谜，否则不是。 以下是用于更好理解的注释代码。
#include<iostream>
#include<string>
using namespace std;
bool is_anagram(string s1, string s2)
{
//Following statement chechs the base condition; if either of the strings is empty,
//return False
if(s1.length() == 0 || s2.length() == 0)
return false;
//initializing the counter array and setting it's values to 0
int counter[256] = {0};
//Calculating the lengths of both the strings
int len1 = s1.length();
int len2 = s2.length();
//Following is also a base condition that checks whether the strings are equal in
//length, if not we return False
if(len1 != len2)
return false;
//Following for loop increments the values of the counter array for the first
//string
for(int i = 0; i < len1; i++)
{
counter[s1[i]]++;
}
//This for loop decrements the values of the counter array for the second string
for(int i = 0; i < len2; i--)
{
counter[s2[i]]--;
}
//Now we check whether the counter array is empty/(or as it was initialized); if
//yes then the two strings are anagrams
for(int i = 0; i < 256; i++)
{
if(counter[i] != 0)
return false;
}
return true;
}
答案 23 :(得分：-2)
另一种不使用sort的解决方案：
s1 = "aaabbbccc"
s2 = "abcabcabc"
def are_anagram1(s1, s2):
return [False, True][sum([ord(x) for x in s1]) == sum([ord(x) for x in s2])]
print are_anagram1(s1,s2)
注意：这仅适用于字母而不是数字
答案 24 :(得分：-2)
def areAnagram(s1,s2):
if len(s1) != len(s2):
return False
count = [0]*256
for i in range(len(s1)):
count[ord(s1[i])] += 1
count[ord(s2[i])] -= 1
for x in count:
if x != 0:
return False
return True
a = input("Enter a string:")
b = input("Enter b string: ")
print(areAnagram(a,b))