Python 相互检查字符串（字谜）

任务是编写一个程序，接受来自用户的两组单词，然后如果这两组单词是字谜（或者至少如果其中一组的所有字母都出现在另一组中），则打印一个“真”语句，如果不是，则打印一个“假”语句

作为一个全新的编程整体，我不知道如何超越仅仅索引一个字符串和比较一个字符串的所有片段。我强调我是一个初学者；我读过许多其他用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.")

---

你需要仔细考虑一下你的条件逻辑。循环在正确的轨道上，但如果s1中有一个字母不在s2中，则应

中断该循环并打印“False”语句。考虑使用一个变量，如<代码> AysS1In S2= true，然后如果发现一个不匹配的字母，将其设置为false。

其他一些提示：


s1中l的
将在字符串s1中循环，让您以
l
的顺序访问每个字母-您根本不需要
范围
或
长度

if。。in
语句可以帮助测试字符串中是否存在字母，例如，
如果mystring:
中的字母是有效的语句，这可以帮助您很多，同样不需要
范围
或
长度

在可能的情况下，应该避免在变量名中使用数字，例如
word\u one
和
word\u two

为什么不对字符串进行排序

>>> sorted('anagram')
['a', 'a', 'a', 'g', 'm', 'n', 'r']
>>> sorted('nagaram')
['a', 'a', 'a', 'g', 'm', 'n', 'r']
>>> sorted('anagram') == sorted('nagaram')
True

字谜是由相同的字符组成的两个不同的单词：例如：EAT和TEA。同样，也有许多例子

查看给定的两个单词或句子是否为字谜的一个好方法是设置一个大小为256的计数器数组，并首先将所有值设置为0。（如果输入更大，至少比几个单词大，这可能是一个很好的选择）现在开始读取第一个字符串（单词或句子），并将其在数组中对应的ASCII位置增加1。对整个字符串重复此操作。
现在开始读取第二个字符串，并不断减少数组中每个字母对应的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;
}

#包括
#包括
使用名称空间std；
布尔是字母组合（字符串s1、字符串s2）
{
//下面的语句检查基本条件；如果任一字符串为空，
//返回错误
如果（s1.length（）==0 | | s2.length（）==0）
返回false；
//初始化计数器数组并将其值设置为0
int计数器[256]={0}；
//计算两个字符串的长度
int len1=s1.length（）；
int len2=s2.length（）；
//下面也是一个基本条件，用于检查字符串的长度是否相等
//长度，否则返回False
if（len1！=len2）
返回false；
//Following for循环为第一个循环递增计数器数组的值
//串
对于（int i=0；i
只是另一个不使用排序的解决方案：

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)

注意：这只适用于字母而不是数字
只是一个想法：
>>> 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
>>> 

这对我有用
您可以使用收藏库中的魔法。
从文件：

它是一个无序集合，其中元素存储为字典键，其计数存储为字典值

因此，您可以使用字符串（iterable）初始化计数器对象，并与字符串中的另一个计数器进行比较

from collections import Counter

def is_anagram(str1, str2):
   return Counter(str1) == Counter(str2)

要使用字典检查两个字符串是否为彼此的字谜：
注：偶数，特殊字符可作为输入

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"


您可以使用以下代码，它既不会计算特殊字符，也不会计算数字，如果两个字符串中的字符总数相等，则将返回“它们是字谜”，因此将告诉字符串是否为字谜

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

Return True回答问题“w2是w1子序列的一个字谜吗？”
说明：在下面的代码中，我们可以回答两个问题：1）两个字符串是否为anagram，2）如果w2是w1子序列的anagram。我们使用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(word1, word2):
    return sorted(word1) == sorted(word2)

检查

在这种情况下，我们使用两个容器对每个排序字符串进行检查

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

我认为最短的方法是：

fstr=input("enter first string:")
sstr=input("enter second string:")

if(fstr==sstr[::-1]):
    print("it's anagram")

我想我们可以这样做


以下是一个典型的分配解决方案：

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

字谜（a，b）
字谜的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");
    }
    
}

static void anagram（字符串s1、字符串s2）{
如果（s1.length（）！=s2.length（））{
System.out.println（“非字谜”）；
返回；
}
否则{
int[]arr=新int[256]；
int size=s1.length（）；
对于（int i=0；i不确定是否有人在上面提议，但我同意：

def is_anagram(a, b):
    return sorted(a.lower()) == sorted(b.lower())

主要是关于算法，而不是特定的语言。我不确定我们是否提供了完整的su解决方案
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

fstr=input("enter first string:")
sstr=input("enter second string:")

if(fstr==sstr[::-1]):
    print("it's anagram")

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 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

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')

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

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");
    }
    
}

def is_anagram(a, b):
    return sorted(a.lower()) == sorted(b.lower())