Выписать все слова, которые являются анаграммами друг для друга

#Функция проверяет являются ли слова
#word1 и word2 анаграммами
def test(word1, word2):
    a1 = list(word1)
    a2 = list(word2)
    if set(a1) == set(a2):
        return True
    else:
        return False
 
#Ввод n
n = int(input())
 
#Ввод слов
words = []
for _ in range(n):
    word = input().lower()
    if not word in words:
        words.append(word)
 
#Сортировка слов как в словаре
words = sorted(words, key=lambda w: w)
 
while len(words) > 0:
    w = [words.pop(0)]
 
    k = 0
    while k < len(words):
        word2 = words[k]
 
        if test(w[0], word2):
            w.append(word2)
            words.remove(word2)
        else:
            k += 1
 
    if len(w) > 1: print(*w)

def test(word1, word2):
    return set(word1) == set(word2):

>>> a = 'окорок'
>>> b = 'рок'
>>> set(a) == set(b)
True
>>>

def test(word1, word2):
    return sorted(word1) == sorted(word2)

>>> a = 'окорок'
>>> b = 'рок'
>>> sorted(a) == sorted(b)
False
>>> a = 'окорок'
>>> b = 'рококо'
>>> sorted(a) == sorted(b)
True
>>>

def test(a, b):
    return len(a) == len(b) and all(t in b for t in a)

In [3]: %timeit test("jhdsajkdas", "ghjalkskdsad;lasjdklsajdklsajlhfaks89")
The slowest run took 37.60 times longer than the fastest. This could mean that an intermediate result is being cached.
10000000 loops, best of 3: 133 ns per loop
 
In [4]: %timeit test1("jhdsajkdas", "ghjalkskdsad;lasjdklsajdklsajlhfaks89")
The slowest run took 8.96 times longer than the fastest. This could mean that an intermediate result is being cached.
100000 loops, best of 3: 3.11 µs per loop
 
In [8]: %timeit test("jhdsajkdas", "hdsakjdasj")
The slowest run took 8.85 times longer than the fastest. This could mean that an intermediate result is being cached.
1000000 loops, best of 3: 808 ns per loop
 
In [9]: %timeit test1("jhdsajkdas", "hdsakjdasj")
The slowest run took 5.23 times longer than the fastest. This could mean that an intermediate result is being cached.
1000000 loops, best of 3: 1.32 µs per loop

words = sorted(words, key=lambda w: w)

while k < len(words):
        word2 = words[k]
 
        if test(w[0], word2):
            w.append(word2)
            words.remove(word2)
        else:
            k += 1

while len(words) > 0:
    w = [words.pop(0)]
    # k = 0
 
    for k in range(len(words)):
        word2 = words[k]
        if test(w[0], word2):
            w.append(word2)
            words.remove(word2)
            k -= 1
        # else:
        #     k += 1

a = {}
n = int(input())
for i in range(n):
    s = input().lower()
    sort_line = ''.join(sorted(s))
    a[sort_line] = a.get(sort_line, set())
    a[sort_line].add(s)
new_words = [' '.join(sorted(i)) for i in a.values() if len(i) > 1]
print('\n'.join(sorted(new_words)))

arr = []
d1 = {}
for i in range(n := int(input())):
    arr.append(s := input().lower())
    d = "".join(sorted(s))
    if d in d1:
        d1[d].append(s)
    else:
        d1[d] = [s]
for j in sorted(list(d1.keys()), key=lambda x: sorted(d1[x])[0]):
    if len(set(d1[j])) > 1:
        print(*sorted(list(set(d1[j]))))