def test_anagram(self):
self.assertEqual(anagram.anagram('aaabbb'), 3)
self.assertEqual(anagram.anagram('ab'), 1)
self.assertEqual(anagram.anagram('abc'), -1)
self.assertEqual(anagram.anagram('mnop'), 2)
self.assertEqual(anagram.anagram('xyyx'), 0)
self.assertEqual(anagram.anagram('xaxbbbxx'), 1)
self.assertEqual(anagram.anagram('asdfjoieufoa'), 3)
self.assertEqual(anagram.anagram('fdhlvosfpafhalll'), 5)
self.assertEqual(anagram.anagram('mvdalvkiopaufl'), 5)
def test_anagram(self):
self.assertTrue(anagram('abcd', 'bdca'), True)
self.assertFalse(anagram('abcd', 'caad'), False)
with self.assertRaises(TypeError):
anagram(1234, 4321)
anagram("adcd", 2345)
anagram(1234, "haja")
def run(self, screen):
# "Or full stop " <icon> to quit
# a-z are accepted, other characters generate an error.
# Error if there are no anagrams of the chosen word.
while True:
try:
for event in pygame.event.get():
if event.type == QUIT:
return
if event.type == KEYDOWN:
if event.unicode == '\x08': # delete
self._user_text = self._user_text[:-1]
elif event.unicode == '.':
return
elif event.unicode in ('\n', '\r'):
words = anagram(self._user_text)
PoemAction("Anagrams of " + self._user_text, ' '.join(words), None, False).run(screen)
elif event.unicode.isalpha():
if event.unicode.islower():
self._error = ''
self._user_text = self._user_text + event.unicode
else:
self._error = event.unicode + ' : you can only use lower case letters'
else:
self._error = event.unicode + ' : only letters (a-z)'
except Exception as e:
self._error = str(e)
self.refresh(screen)
pygame.display.update()
fpsClock.tick(30)
def my_form_post():
morphit = openmorphit()
text = request.form['fname']
listofanagrams = anagram(text, morphit)
if len(listofanagrams) == 0:
return "Ci spiace, nessun anagramma disponibile per questo nome. Puoi tornare a dedicarti alle cose importanti della tua giornata."
else:
return render_template("templates/anagrammi.html", data=listofanagrams)
async def change_word():
global current_word
current_word = next(py_act).replace("\n", "")
print(current_word)
anag = anagram(current_word)
anag = anag.replace("\n", "")
print(anag)
await bot.change_presence(status=discord.Status.online,
activity=discord.Game(name=anag))
def test_annagram(self):
word = 'dog'
word_list = ['cat', 'dog', 'got', 'sheep', 'GOT', 'cat', 'DOG', 'god']
self.assertEqual(['god'], anagram(word, word_list))
word_list = ['cat', 'dog', 'got', 'sheep', 'GOT', 'cat', 'DOG']
self.assertEqual([], anagram(word, word_list))
word_list = ['god', 'god', 'god']
self.assertEqual(['god'], anagram(word, word_list))
word = 'aeprs'
# has 12 anagrams
word_list = ['cat', 'dog', 'got', 'sheep', 'GOT', 'cat', 'DOG', 'god',
'apers', 'apres', 'asper', 'pares', 'parse', 'pears',
'prase', 'presa', 'rapes', 'reaps', 'spare', 'spear']
self.assertEqual(['apers', 'apres', 'asper', 'pares',
'parse', 'pears', 'prase', 'presa',
'rapes', 'reaps', 'spare',
'spear'], anagram(word, word_list))
self.assertEqual(12, len(anagram(word, word_list)))
def test_repetition(self):
self.assertEqual(anagram("aabbcc", "aabbc"), False)
array = [3, 2, 11, -1, 0]
quick_sort.sort(array, left=0, right=len(array) - 1)
selection_sort.sort(array=[3, 2, 11, -1, 0])
lexicographic_order.order(words=['aab', 'aaa', 'aa', 'aaa'])
""" SEARCHING """
pattern_search.search(text=list('karykatura'), pattern=list('ka'))
bisection_root_finding.bisect(a=-4, b=4, error=0.001)
bisection_search.search(array=[-1, 0, 2, 3, 11], target=3)
""" STRING OPS """
anagram.anagram(word1=list('arbuz'), word2=list('burza'))
palindrome.palindrome(word=list('kajak'))
caesar_cipher.cipher(key=2, text=list('xyz'))
transposition_cipher.cipher(text=list('SLOWO'))
""" NUMERAL SYSTEMS """
dec_to_base_iterative.change_base(number=10, base=2)
array = []
dec_to_base_recursive.change_base(number=10, base=2, callback=array)
""" NUMERIC OPTIMISATION """
gcd_iterative.gcd(a=5, b=10)
def test_uppercase_anagram_choices():
assert (anagram("save", ["DESK", "WATER", "VASE", "BALL"])) == ["VASE"]
def test_given_word_uppercase():
assert (anagram("SAVE", ["vase", "desk", "folder", "pens"])) == ["vase"]
def test_return_true_when_anagram(self):
expected = True
result = a.anagram(self.example1, 'rail safety')
self.assertEqual(result, expected)
def test_caps(self):
self.assertFalse(anagram.anagram("hellO", "lelho"))
self.assertTrue(anagram.anagram("hellO", "lelhO"))
def test_chars_only(self):
self.assertEqual(anagram("abc", "cba"), True)
def read_key(key, db):
"""key: string
db: database file
Prints value(s) of given key in db file.
"""
open_db = anydbm.open(db, "r")
print pickle.loads(open_db[key])
def read_anagrams(word, db):
"""word: string
db: database file
Prints a list of anagrams of given word.
"""
open_db = anydbm.open(db, "r")
res = open_db["".join(sorted(word))]
print "Anagrams of {word}:".format(word=word)
for item in pickle.loads(res):
if item != word:
print "-", item
if __name__ == "__main__":
test_dictionary = anagram.anagram("words.txt")
dict_to_db(test_dictionary)
read_anagrams("traced", "dict_to_db.db")
def test_anagram(self):
self.assertEqual(anagram.anagram("cat"), {"cat", "act", "atc", "tca", "tac", "cta"})
def test_return_type_error_if_not_string(self):
with self.assertRaises(TypeError):
a.anagram(self.example4, 'any string')
with self.assertRaises(TypeError):
a.anagram('any string', self.example4)
def run(self, screen):
words = anagram(self._word, 20)
PoemAction("Anagrams of " + self._word, ' '.join(words), None, False).run(screen)
return True
def test_return_false_when_not_anagram(self):
expected = False
result = a.anagram(self.example2, 'bedfes')
self.assertEqual(result, expected)
def test_fail(self):
self.assertEqual(anagram("123", "1 2"), False)
def test_numbers(self):
self.assertTrue(anagram.anagram("123456", "546321"))
self.assertTrue(anagram.anagram("215 21", "152 12"))
self.assertFalse(anagram.anagram("215 21", "15212"))
def test_spaces(self):
self.assertEqual(anagram("go go go", "gggooo"), True)
def test_anagram(self):
self.assertTrue(anagram("adam", "dama"))
self.assertTrue(anagram("fraktal", "kartafl"))
def get_bag(s): return [word for word in anagram(s)]
def test_given_word_with_capitalized_letter():
assert (anagram("Cat", ["folder", "act", "paper", "garbage"])) == ["act"]
def test_string(self):
self.assertTrue(anagram.anagram("vienas", "asnvei"))
self.assertTrue(anagram.anagram("kaip", "ipak"))
def test_return_value_error_if_string_empty(self):
with self.assertRaises(ValueError):
a.anagram(self.example3, 'anystring')
with self.assertRaises(ValueError):
a.anagram('any string', self.example3)
'''def freq(str, num):
# break string into a list of words
str_list = str.split()
#gives a set of new words
unique_words = set(str_list)
for words in unique_words:
print(words, ' :', str_list.count(words))
'''
if __name__ == '__main__':
words = list(open("/usr/share/dict/words", "r"))
dict = create_dict_hash(words)
print(
read_words(words, int(sys.argv[1]))
) #run python file and type a number to receive a random number of words
word1 = random.choice(words)
# word1 = word1[:len(word1)-2]
word2 = random.choice(words)
# word2 = word2[:len(word2)-2]
# if(sorted(word1) in dict):
# print("1111")
while (anagram(word1, word2) == False):
word1 = random.choice(words)
word1 = word1[:len(word1) - 2]
word2 = random.choice(words)
word2 = word2[:len(word2) - 2]
def test_false_anagram():
assert anagram("ABC", "XYZ") == False
def test_multiple_anagrams():
assert (anagram("listen", ["enlists", "google", "silent", "inlets"])) == [
"silent",
"inlets",
]
def test_simple_anagram():
assert anagram("bored", "robed")
def test_anagram_choices_with_capitalized_letters():
assert (anagram("brag", ["Big", "Small", "Grab", "House'"])) == ["Grab"]
def test_complex_anagram():
assert anagram("The Morse Code", "Here come dots")
def test_no_anagrams():
assert (anagram("nature", ["book", "job", "swimming", "desk"])) == []
def test_multiple_spaces(self):
self.assertEqual(anagram("hi man", "hi man"), True)
def test_one_anagram():
assert (anagram("listen", ["enlists", "google", "inlets"])) == ["inlets"]
def test_ana_2():
assert (anagram("amazing", "zingama"))
