Как найти симметричные слова

Code first. Discussion below the code.

import string

# get alphabet and reversed alphabet
try:
    # Python 2.x
    alpha1 = string.lowercase
except AttributeError:
    # Python 3.x and newer
    alpha1 = string.ascii_lowercase

alpha2 = alpha1[::-1]  # use slicing to reverse alpha1

# make a dictionary where the key, value pairs are symmetric
# for example symd['a'] == 'z', symd['b'] == 'y', and so on
_symd = dict(zip(alpha1, alpha2))

def is_symmetric_word(word):
    if not word:
        return False  # zero-length word is not symmetric
    i1 = 0
    i2 = len(word) - 1
    while True:
        if i1 >= i2:
            return True  # we have checked the whole string
        # get a pair of chars
        c1 = word[i1]
        c2 = word[i2]
        if _symd[c1] != c2:
            return False # the pair wasn't symmetric
        i1 += 1
        i2 -= 1

# note, added a space to list of chars to filter to a space
_filter_to_space = ",.?!:'/ "
def _filter_ch(ch):
    if ch in _filter_to_space:
        return ' '  # return a space 
    elif ch in alpha1:
        return ch # it's an alphabet letter so return it
    else:
        # It's something we don't want.  Return empty string.
        return ''

def clean(text):
    return ''.join(_filter_ch(ch) for ch in text.lower())

def symmetrics(text):
    # filter text: keep only chars in the alphabet or spaces
    for word in clean(text).split():
        if is_symmetric_word(word):
            # use of yield makes this a generator.
            yield word

lst = list(symmetrics("The boy...is a yob."))
print(lst)  # prints: ['boy', 'a', 'yob']

• No need to type the alphabet twice; we can reverse the first one.

• We can make a dictionary that pairs each letter with its symmetric letter. This will make it very easy to test whether any given pair of letters is a symmetric pair. The function zip() makes pairs from two sequences; they need to be the same length, but since we are using a string and a reversed copy of the string, they will be the same length.

• It’s best to write a simple function that does one thing, so we write a function that does nothing but check if a string is symmetric. If you give it a zero-length string it returns False, otherwise it sets i1 to the first character in the string and i2 to the last. It compares characters as long as they continue to be symmetric, and increments i1 while decrementing i2. If the two meet or pass each other, we know we have seen the whole string and it must be symmetric, in which case we return True; if it ever finds any pair of characters that are not symmetric, it returns False. We have to do the check for whether i1 and i2 have met or passed at the top of the loop, so it won’t try to check if a character is its own symmetric character. (A character can’t be both 'a' and 'z' at the same time, so a character is never its own symmetric character!)

• Now we write a wrapper that filters out the junk, splits the string into words, and tests each word. Not only does it convert the chosen punctuation characters to spaces, but it also strips out any unexpected characters (anything not an approved punctuation char, a space, or a letter). That way we know nothing unexpected will get through to the inner function. The wrapper is «lazy»… it is a generator that yields up one word at a time, instead of building the whole list and returning that. It’s easy to use list() to force the generator’s results into a list. If you want, you can easily modify this function to just build a list and return it.

If you have any questions about this, just ask.

EDIT: The original version of the code didn’t do the right thing with the punctuation characters; this version does. Also, as @heltonbiker suggested, why type the alphabet when Python has a copy of it you can use? So I made that change too.

EDIT: @heltonbiker’s change introduced a dependency on Python version! I left it in with a suitable try:/except block to handle the problem. It appears that Python 3.x has improved the name of the lowercase ASCII alphabet to string.ascii_lowercase instead of plain string.lowercase.

Вы пытаетесь сделать все сразу! Программирование часто является упражнением в том, чтобы разбить большую проблему на несколько простых проблем.

Вам действительно нужно только проверить наличие симметричного слова в конце каждого слова. Я предлагаю иметь строку, которая представляет текущее слово. Когда вы встретите каждый символ на входе, посмотрите, является ли он пробелом. Если это не пробел, добавьте этот символ к currentWord строковая переменная.

Каждый раз, когда вы сталкиваетесь с пробелом, вы должны проверить currentWord для симметрии, затем очистите currentWord переменная.

Ваш код пытается отдельно отслеживать длину слова. Это просит ошибок. Вы можете запросить строку для ее текущей длины, используя length функция.

Итак, ваш код должен сводиться к следующему:

Обратите внимание, что это псевдо-Паскаль — я стараюсь не давать вам ответ «копировать и вставить», чтобы вы узнали

currentWord := ''
for each character do
begin
    if this character is not a space then
        add the character to the currentWord
    else
        if wordIsSymmetrical(currentWord) then
            print word or add to count as needed
        end
        currentWord := ''
    end
end
if currentWord <> '' then
    if wordIsSymmetrical(currentWord) then
        print word or add to count as needed
    end
end

… и добавить функцию под названием wordIsSymmetrical который проверяет только строковый параметр, который мы передаем ему.

Обратите внимание, что в конце у вас может быть слово, не встречая пробела. Здесь снова вы можете использовать wordIsSymmetrical Проверять.

Кажется ли это легче сделать?

Код сначала. Обсуждение ниже кода.

import string

# get alphabet and reversed alphabet
try:
    # Python 2.x
    alpha1 = string.lowercase
except AttributeError:
    # Python 3.x and newer
    alpha1 = string.ascii_lowercase

alpha2 = alpha1[::-1]  # use slicing to reverse alpha1

# make a dictionary where the key, value pairs are symmetric
# for example symd['a'] == 'z', symd['b'] == 'y', and so on
_symd = dict(zip(alpha1, alpha2))

def is_symmetric_word(word):
    if not word:
        return False  # zero-length word is not symmetric
    i1 = 0
    i2 = len(word) - 1
    while True:
        if i1 >= i2:
            return True  # we have checked the whole string
        # get a pair of chars
        c1 = word[i1]
        c2 = word[i2]
        if _symd[c1] != c2:
            return False # the pair wasn't symmetric
        i1 += 1
        i2 -= 1

# note, added a space to list of chars to filter to a space
_filter_to_space = ",.?!:'/ "
def _filter_ch(ch):
    if ch in _filter_to_space:
        return ' '  # return a space 
    elif ch in alpha1:
        return ch # it an alphabet letter so return it
    else:
        # It something we don't want.  Return empty string.
        return ''

def clean(text):
    return ''.join(_filter_ch(ch) for ch in text.lower())

def symmetrics(text):
    # filter text: keep only chars in the alphabet or spaces
    for word in clean(text).split():
        if is_symmetric_word(word):
            # use of yield makes this a generator.
            yield word

lst = list(symmetrics("The boy...is a yob."))
print(lst)  # prints: ['boy', 'a', 'yob']

• Не нужно вводить алфавит дважды; мы можем отменить первый.

• Мы можем сделать словарь, который связывает каждую букву с ее симметричной буквой. Это позволит очень легко проверить, является ли любая пара букв симметричной. Функция zip() делает пары из двух последовательностей; они должны быть одинаковой длины, но поскольку мы используем строку и обратную копию строки, они будут иметь одинаковую длину.

• Лучше всего написать простую функцию, которая делает одно, поэтому мы пишем функцию, которая ничего не делает, кроме проверки симметричности строки. Если вы даете ему строку с нулевой длиной, она возвращает False, иначе она устанавливает i1 в первый символ в строке и i2 до последнего. Он сравнивает символы, пока они продолжают оставаться симметричными, и увеличивает i1 при уменьшении i2. Если они встречаются или проходят друг друга, мы знаем, что мы видели всю строку, и она должна быть симметричной, и в этом случае мы возвращаем True; если он когда-либо обнаруживает любую пару символов, которые не являются симметричными, он возвращает False. Мы должны сделать проверку, соответствуют ли i1 и i2 или переданы в верхней части цикла, поэтому он не будет пытаться проверить, является ли символ его собственным симметричным символом. (Символ не может быть одновременно 'a' и 'z', поэтому персонаж никогда не является его собственным симметричным символом!)

• Теперь мы пишем обертку, которая отфильтровывает мусор, разбивает строку на слова и проверяет каждое слово. Он не только преобразует выбранные символы пунктуации в пробелы, но также удаляет любые неожиданные символы (что-то вроде не утвержденного символа пунктуации, пробела или буквы). Таким образом, мы знаем, что ничего неожиданного не перейдет во внутреннюю функцию. Обертка «ленивая»… это генератор, который дает одно слово за раз, вместо того, чтобы строить весь список и возвращать его. Легко использовать list() чтобы заставить результаты генератора в список. Если вы хотите, вы можете легко изменить эту функцию, чтобы просто создать список и вернуть его.

Если у вас есть какие-либо вопросы по этому поводу, просто спросите.

EDIT: оригинальная версия кода не подходит для знаков пунктуации; эта версия делает. Кроме того, как предложил @heltonbiker, зачем вводить алфавит, когда у Python есть его копия? Поэтому я тоже сделал это изменение.

EDIT: изменение @heltonbiker ввело зависимость от версии Python! Я оставил его с подходящей try:/except block, чтобы справиться с этой проблемой. Похоже, что Python 3.x улучшил имя строчного ASCII-алфавита на string.ascii_lowercase вместо простой string.lowercase.