Как проверить палиндром с помощью логики Python

Ответ 1

Питонический способ определить, является ли данное значение палиндром:

str(n) == str(n)[::-1]

Пояснение:

• Мы проверяем, является ли строковое представление n равным инвертированному строковому представлению n
• Нарезка [::-1] заботится о том, чтобы инвертировать строку
• После этого мы сравним для равенства с помощью ==

Ответ 2

Альтернативой довольно неинтуитивному синтаксису [::-1] является следующее:

>>> test = "abcba"
>>> test == ''.join(reversed(test))
True

Функция reversed возвращает обратную последовательность символов в test.

''.join() снова объединяет эти символы, между которыми нет ничего.

Ответ 3

Удивительная часть python - это то, что вы можете с ней сделать. Вам не нужно использовать индексы для строк.

Следующее будет работать (используя срезы)

def palindrome(n):
    return n == n[::-1]

Что он делает, просто меняет n и проверяет, равны ли они. n[::-1] отменяет n (значение -1 означает уменьшение)

"2) Мой цикл for (в диапазоне (999, 100, -1), это плохой способ сделать это в Python?"

В отношении вышеизложенного вы хотите использовать xrange вместо диапазона (потому что диапазон создаст фактический список, а xrange - быстрый генератор)

Мое мнение по вопросу 3

Я изучил C перед Python, и я просто прочитал документы и играл с ним с помощью консоли. (и, выполняя также задачи Project Euler:)

Ответ 4

Только для записи, а для тех, кто ищет более алгоритмический способ проверить, является ли данная строка палиндром, двумя способами добиться того же (используя циклы while и for):

def is_palindrome(word):

    letters = list(word)    
    is_palindrome = True
    i = 0

    while len(letters) > 0 and is_palindrome:       
        if letters[0] != letters[(len(letters) - 1)]:
            is_palindrome = False
        else:
            letters.pop(0)
            if len(letters) > 0:
                letters.pop((len(letters) - 1))

    return is_palindrome

И.... второй:

def is_palindrome(word):

    letters = list(word)
    is_palindrome = True

    for letter in letters:
        if letter == letters[-1]:
            letters.pop(-1)
        else:
            is_palindrome = False
            break

    return is_palindrome

Ответ 5

Ниже кода будет напечатан 0, если он Palindrome, иначе он будет печатать -1

Оптимизированный код

word = "nepalapen"
is_palindrome = word.find(word[::-1])
print is_palindrome

Вывод: 0

word = "nepalapend"
is_palindrome = word.find(word[::-1])
print is_palindrome

Вывод: -1

Explaination:

при поиске строки возвращаемое значение является значением местоположения, в котором начинается строка.

Итак, когда вы делаете word.find(word[::-1]), он находит nepalapen в местоположении 0 и [::-1] меняет значение nepalapen и по-прежнему находится nepalapen в точке 0, поэтому возвращается 0.

Теперь, когда мы ищем nepalapend, а затем обрамляем nepalapend на dnepalapen, он выводит инструкцию FALSE nepalapend на dnepalapen, в результате чего поиск не находит nepalapend, что приводит к значение -1, которое указывает, что строка не найдена.

Другой метод напечатает true, если palindrome else напечатать false

word = "nepalapen"
print(word[::-1]==word[::1])

выход: TRUE

Ответ 6

Существует также функциональный способ:

def is_palindrome(word):
  if len(word) == 1: return True
  if word[0] != word[-1]: return False
  return is_palindrome(word[1:-1])

Ответ 7

Я знаю, что этот вопрос был дан ответ некоторое время назад, и я приговариваю к вторжению. Тем не менее, я работал над тем, как это сделать на python, и я просто подумал, что я бы разделил способ, которым я это сделал, следующим образом:

word = 'aibohphobia'

word_rev = reversed(word)

def is_palindrome(word):
if list(word) == list(word_rev):
    print'True, it is a palindrome'
else:
    print'False, this is''t a plindrome'

is_palindrome(word)

Ответ 8

Существует намного более простой способ, который я только что нашел. Это только 1 строка.

is_palindrome = word.find(word[::-1])

Ответ 9

Здесь функция нечувствительная к регистру, поскольку все указанные выше решения чувствительны к регистру.

def Palindrome(string): 

  return (string.upper() == string.upper()[::-1]) 

Эта функция вернет значение boolean.

Ответ 10

выполняя курс Watterloo для python, те же вопросы поднимаются, как "Lesseon" найти информацию здесь:

http://cscircles.cemc.uwaterloo.ca/13-lists/

будучи новичком, я решил проблему следующим образом:

def isPalindrome(S):
    pali = True
    for i in range (0, len(S) // 2):
        if S[i] == S[(i * -1) - 1] and pali is True:
            pali = True
        else:
            pali = False
    print(pali)
    return pali

Функция называется isPalindrome (S) и требует строку "S" . Возвращаемое значение по умолчанию TRUE, для первоначальной проверки первого оператора if.

После этого цикл for выполняет половину длины строки, чтобы проверить, совпадает ли символ из строки "S" в позиции "i" по адресу спереди и сзади. Если это не так, функция останавливается, выдает FALSE и возвращает false.

Cheers.kg

Ответ 11

Если строка имеет строчный или неалфавитный символ, то функция преобразует все символы в нижний регистр и удаляет все неалфавитные символы с помощью регулярного выражения, наконец, рекурсивно применяет проверку палиндрома:

import re

rules = [
    lambda s: any(x.isupper() for x in s),
    lambda s: not s.isalpha()
]


def is_palindrome(s):
    if any(rule(s) for rule in rules):
        s = re.sub(r'[^\w]', '', s).lower()
    if len(s) < 2:
        return True
    if s[0] != s[-1]:
        return False
    return is_palindrome(s[1:-1])


string = 'Are we not drawn onward, we few, drawn onward to new era?'

print(is_palindrome(string))

для входа выше значение True.

Ответ 12

возможно, вы можете попробовать следующее:

list=input('enter a string:')

if (list==list[::-1]):
    print ("It is a palindrome")
else:
   print("it is not palindrome")

Ответ 13

Вы спрашиваете палиндром в python. палиндром можно выполнять по строкам, цифрам и спискам. Тем не менее, я просто разместил простой код для проверки палиндрома строки.

# Palindrome of string
str=raw_input("Enter the string\n")
ln=len(str)
for i in range(ln/2) :
    if(str[ln-i-1]!=str[i]):
        break
if(i==(ln/2)-1):
    print "Palindrome"
else:
    print "Not Palindrome"

Ответ 14

Реальный простой способ сделать это

word = str(raw_input(""))
is_palindrome = word.find(word[::-1])
if is_palindrome == 0:
    print True
else:
    print False

И если /else здесь просто для причудливых взглядов. Вопрос о палиндроме был на интервью Амазонки для QA

Ответ 15

Предполагая, что строка '

palin = lambda s: s[:(len(s)/2 + (0 if len(s)%2==0 else 1)):1] == s[:len(s)/2-1:-1]  
# Test
palin('654456')  # True
palin('malma')   # False
palin('ab1ba')   # True

Ответ 16

Reversed создает объект (<reversed object at 0x1041c6410>). Его нельзя сравнить с string.reversed(a).

Ответ 17

word = "<insert palindrome/string>"
reverse = word[::-1] 
is_palindrome = word.find(reverse)
print is_palindrome

Это был вопрос в Udacity comp 101, глава 1. Дает 0 для палиндрома, дает -1 для нет. Он прост и не использует циклы.

Ответ 18

Я написал этот код:

word = input("enter: ")
word = ''.join(word.split())`
for x in range(len(word)):
if list(word)[x] == ((list(word)[len(word)-x-1])):
if x+1 == len(word):
print("its pali")

и он работает. он получает слово, затем удаляет пробелы и превращает их в список то он проверяет, равна ли первая буква последней, а вторая равна второй и т.д.

то "if x + 1 == len (word)" означает, что, поскольку x начинается с 0, он становится равным 1, а затем для каждого следующего. blah blah blah работает, поэтому он работает.

Ответ 19

#compare 1st half with reversed second half
# i.e. 'abba' -> 'ab' == 'ba'[::-1]

def is_palindrome( s ):
   return True if len( s ) < 2 else s[ :len( s ) // 2 ] == s[ -( len( s ) // 2 ):][::-1]

Ответ 20

Вы можете использовать Deques в python для проверки palindrome

def palindrome(a_string): ch_dequeu = Deque() for ch in a_string: ch_dequeu.add_rear(ch) still_ok = True while ch_dequeu.size() > 1 and still_ok: first = ch_dequeu.remove_front() last = ch_dequeu.remove_rear() if first != last: still_ok = False return still_ok

class Deque: def __init__(self): self.items = [] def is_empty(self): return self.items == [] def add_rear(self, item): self.items.insert(0, item) def add_front(self, item): self.items.append(item) def size(self): return len(self.items) def remove_front(self): return self.items.pop() def remove_rear(self): return self.items.pop(0)

Ответ 21

import string

word = input('Please select a word to test \n')
word = word.lower()
num = len(word)

x = round((len(word)-1)/2)
#defines first half of string
first = word[:x]

#reverse second half of string
def reverse_odd(text):
    lst = []
    count = 1
    for i in range(x+1, len(text)):

        lst.append(text[len(text)-count])
        count += 1
    lst = ''.join(lst)
    return lst

#reverse second half of string
def reverse_even(text):
    lst = []
    count = 1
    for i in range(x, len(text)):
        lst.append(text[len(text)-count])
        count += 1
    lst = ''.join(lst)
    return lst


if reverse_odd(word) == first or reverse_even(word) == first:
    print(string.capwords(word), 'is a palindrome')
else:
    print(string.capwords(word), 'is not a palindrome')

Ответ 22

"алгоритмический" способ:

import math

def isPalindrome(inputString):
    if inputString == None:
        return False

    strLength = len(inputString)
    for i in range(math.floor(strLength)):
        if inputString[i] != inputString[strLength - 1 - i]:
            return False
    return True

Ответ 23

Существует другой способ использования функций, если вы не хотите использовать обратный

#!/usr/bin/python

A = 'kayak'

def palin(A):

    i = 0
    while (i<=(A.__len__()-1)):
        if (A[A.__len__()-i-1] == A[i]):
            i +=1
        else:
         return False

if palin(A) == False:

    print("Not a Palindrome")

else :

    print ("Palindrome")

Ответ 24

Он выглядит красивее с рекурсией!

def isPalindrome(x):
z = numToList(x)
length = math.floor(len(z) / 2)
if length < 2:
    if z[0] == z[-1]:
        return True
    else:
        return False
else:
    if z[0] == z[-1]:
        del z[0]
        del z[-1]
        return isPalindrome(z)
    else:
        return False

Ответ 25

Вот пример, который вводит пользовательский ввод и проверяет, является ли вход палиндром:

name = input("Write your word here:  ")
input("Press <enter> to check if the word is a palindrome.")
if str(name) == str(name)[::-1]:
    print("True")
else:
    print("False")

Однако нет необходимости даже устанавливать оператор if/else. Вы можете напрямую распечатать результат логического сравнения, как показано ниже:

name = input("Write your word here:  ")
input("Press <enter> to check if the word is a palindrome.")
print(str(name) == str(name)[::-1])

Ответ 26

#!/usr/bin/python

str = raw_input("Enter a string ")
print "String entered above is %s" %str
strlist = [x for x in str ]
print "Strlist is %s" %strlist
strrev = list(reversed(strlist)) 
print "Strrev is %s" %strrev
if strlist == strrev :
   print "String is palindrome"
else :
   print "String is not palindrome"

Ответ 27

это очень легко

#palindrome
a=raw_input("enter the word")
b=a[::-1]
if a==b:
 print("enter word is palindrome")
else:`enter code here`
 print("not a palindrome")

спасибо