任务是编写一个程序，从用户那里接受两组单词，然后如果这两个单词是字谜（或者至少如果一个单词的所有字母都出现在另一个单词中），则打印一个“True”语句和一个“False”语句如果没有，则声明。
作为一个整体编程的新手，我不知道如何超越仅仅索引一个字符串并将所有部分相互比较。我强调我是初学者；我已经阅读了许多用 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.")
为什么不只是对字符串进行排序？
>>> sorted('anagram')
['a', 'a', 'a', 'g', 'm', 'n', 'r']
>>> sorted('nagaram')
['a', 'a', 'a', 'g', 'm', 'n', 'r']
>>> sorted('anagram') == sorted('nagaram')
True
您可以使用收藏库中的魔术计数器。从文档：
它是一个无序集合，其中元素存储为字典键，其计数存储为字典值
因此，您可以使用字符串（可迭代）初始化 Counter 对象，并与字符串中的另一个 Counter 进行比较
from collections import Counter
def is_anagram(str1, str2):
return Counter(str1) == Counter(str2)
您需要更多地考虑条件逻辑。循环在正确的轨道上，但是如果 s1 中有一个字母不在 s2 中，则应该break退出此循环并打印“False”语句。all_s1_in_s2 = True如果发现不匹配的字母，请考虑使用类似的变量，然后将其设置为 false。
其他一些提示：
for l in s1将遍历字符串 s1 让您按顺序访问每个字母l- 您不需要range或len根本不需要
该if .. in语句可以帮助测试一个字母是否存在于字符串中，例如if letter in mystring:是一个有效的语句，这可以帮助你很多，再次不需要range或len
您应该尽可能避免在变量名中使用数字 - 最好是word_oneand word_two，例如
使用字典检查两个字符串是否是彼此的字谜：注意：偶数，特殊字符可以用作输入
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"
def is_anagram(w1, w2):
w1, w2 = list(w1.upper()), list(w2.upper())
w2.sort()
w1.sort()
return w1 == w2
>>> 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
>>>
您可以使用以下代码，它不会计算特殊字符，也不会计算数字，并且如果两个字符串中的总字符相同，则返回“它们是 anagrams”，因此会告诉字符串是否是 anagrams。
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")
如果你坚持使用 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
我想我们可以这样
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")
不确定它是否是在那里提出的，但我选择了：
def is_anagram(a, b):
return sorted(a.lower()) == sorted(b.lower())
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))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"
#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
最简单的最短解决方案
def anagram(word1, word2):
return sorted(word1) == sorted(word2)
查看
print(anagram("xyz","zyx"))
>>True
print(anagram("xyz","zyy"))
>>False
这是一个典型的分配解决方案：
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
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
字谜（a，b）
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");
}
}
这是使用dict理解的解决方案。
def is_anagram(s1, s2):
return {c:s1.count(c) for c in s1} == {c:s2.count(c) for c in s2}
字谜是由相同字符组成的两个不同单词： 例如：EAT 和 TEA 同样可以有很多例子。
查看给定两个单词或句子是否是字谜的一种好方法是设置一个大小为 256 的计数器数组，并最初将所有值设置为 0。（如果输入更大，至少比几个words) 现在开始读取第一个字符串（单词或句子），并将其在数组中的相应 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;
}
解释：在下面的代码中，我们可以回答两个问题：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)
在这种情况下，我们检查每个排序字符串使用两个容器。
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
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')
不使用排序的另一种解决方案：
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)
注意：这仅适用于字母而不是数字
我认为最短的方法可以是：
fstr=input("enter first string:")
sstr=input("enter second string:")
if(fstr==sstr[::-1]):
print("it's anagram")
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))
解决方案：
print('Strings are anagrams' if sorted(input("Enter 1st string: "))== sorted(input("Enter 2nd string: ")) else 'Strings are not anagrams')