Vérification des chaînes les unes contre les autres (Anagrammes)
L’attribution consiste à écrire un programme qui accepte deux groupes de mots de l’utilisateur, puis affiche un énoncé "Vrai" si les deux sont des anagrammes (ou au moins si toutes les lettres de l’un sont présentes dans l’autre) et un "Faux". déclaration sinon.
Étant très nouveau pour la programmation dans son ensemble, je ne sais pas comment aller au-delà de l'indexation d'une chaîne et de la comparaison de tous les éléments les uns par rapport aux autres. Je souligne que je suis débutant; J'ai lu beaucoup d'autres articles taggés avec Python et Anagram, et ils sont uniformément au-dessus de ma tête et font référence à des choses qu'on ne m'a pas enseignées. Donc, le plus simple sera le mieux. Voici mon code qui ne fonctionne pas jusqu'à présent:
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.")
Vous devez réfléchir un peu plus à votre logique conditionnelle. La boucle est sur la bonne voie, mais s'il existe une lettre dans s1 qui N'EST PAS dans s2, vous devez break sortir de cette boucle et imprimer l'instruction "False". Pensez à utiliser une variable telle que all_s1_in_s2 = True, puis définissez-la sur false si vous trouvez une lettre qui ne correspond pas.
Quelques autres conseils:
for l in s1va parcourir la chaîne s1 en vous donnant accès à chaque lettre en séquence en tant quel- vous n'avez pas besoin derangeoulendu toutL'instruction
if .. inpeut vous aider à vérifier si une lettre existe dans une chaîne, par exemple.if letter in mystring:est une déclaration valide et cela pourrait vous aider beaucoup, encore une fois sans avoir besoin derangeoulenÉvitez autant que possible d’utiliser des nombres dans les noms de variables - mieux vaut
Word_oneetWord_two, par exemple.
Pourquoi ne pas simplement trier les chaînes?
>>> sorted('anagram')
['a', 'a', 'a', 'g', 'm', 'n', 'r']
>>> sorted('nagaram')
['a', 'a', 'a', 'g', 'm', 'n', 'r']
>>> sorted('anagram') == sorted('nagaram')
True
Vous pouvez utiliser la magie Counter from collections library. D'après la documentation:
Il s’agit d’une collection non ordonnée dans laquelle les éléments sont stockés en tant que clés de dictionnaire et leur nombre en tant que valeurs de dictionnaire.
Ainsi, vous pouvez initialiser un objet Counter avec une chaîne (un itérable) et le comparer à un autre compteur à partir d'une chaîne
from collections import Counter
def is_anagram(str1, str2):
return Counter(str1) == Counter(str2)
def is_anagram(w1, w2):
w1, w2 = list(w1.upper()), list(w2.upper())
w2.sort()
w1.sort()
return w1 == w2
Pour vérifier si deux chaînes sont des anagrammes avec des dictionnaires à l’aide de dictionnaires: Remarque: Même nombre, les caractères spéciaux peuvent être utilisés comme entrée.
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"
>>> 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
>>>
Vous pouvez utiliser le code suivant: il ne comptera pas les caractères spéciaux ni les chiffres et renverra "ils sont des anagrammes" si le nombre total de caractères a été identique dans les deux chaînes, indiquant ainsi que les chaînes sont des anagrammes ou non.
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")
Voici une solution si vous êtes déterminé à utiliser le dictionnaire Python et que vous ne pouvez pas utiliser la programmation fonctionnelle:
Créez un dictionnaire utilisant la compréhension et comparez les dictionnaires des deux mots avec un simple opérateur ==.
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
Je pense qu'on peut avoir ça comme ça
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")
La solution la plus courte et la plus simple
def anagram(Word1, Word2):
return sorted(Word1) == sorted(Word2)
vérifier
print(anagram("xyz","zyx"))
>>True
print(anagram("xyz","zyy"))
>>False
#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 __== "__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
Juste une pensée:
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))Nous vérifions ce cas en utilisant deux conteneurs pour chaque chaîne triée.
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
Je pense que le plus court chemin peut être:
fstr=input("enter first string:")
sstr=input("enter second string:")
if(fstr==sstr[::-1]):
print("it's anagram")
Cela a fonctionné pour moi
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"