Jak sprawdzić palindrom za pomocą logiki Pythona [zamknięty]

Alternatywą dla raczej nieintuitywnej składni [::-1] jest to:

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

Funkcja reversed zwraca odwrócony ciąg znaków w test.

''.join() / align = "left" /

Dla przypomnienia i dla tych, którzy szukają bardziej algorytmicznego sposobu sprawdzania, czy dany ciąg jest palindromem, dwa sposoby osiągnięcia tego samego (za pomocą pętli while i 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

I....drugi:

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

Niesamowita część Pythona to rzeczy, które możesz z nim zrobić. Nie musisz używać indeksów jako ciągów.

Poniższe będą działać (przy użyciu plastrów)

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

To, co robi, to po prostu odwraca n i sprawdza, czy są równe. n[::-1] odwraca n (-1 oznacza zmniejszenie)

" 2) My for loop (in in range (999, 100, -1), czy to zły sposób, aby to zrobić w Pythonie?"

Odnośnie powyższego, chcesz użyć xrange zamiast range (ponieważ range będzie tworzy aktualną listę, podczas gdy xrange jest szybkim generatorem)

Moje opinie na temat pytania 3

Nauczyłem się C przed Pythonem, i po prostu czytałem dokumenty, i bawiłem się z nim za pomocą konsoli. (i robiąc również problemy z projektem Euler:)

Poniżej kodu zostanie wydrukowany 0 jeśli jest to palindrom w przeciwnym razie wydrukuje -1

Zoptymalizowany Kod

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

Wyjście: 0

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

Wyjście: -1

Wyjaśnienie:

Podczas wyszukiwania łańcucha zwracana wartość jest wartością miejsca, w którym łańcuch się rozpoczyna.

Więc kiedy robisz word.find(word[::-1]) znajduje nepalapen w miejscu 0 i [::-1] odwraca nepalapen i nadal jest nepalapen at location 0 So 0 jest zwracane.

Teraz, gdy szukamy nepalapend, a następnie odwracamy nepalapend do dnepalapen, renderujemy FALSE polecenie nepalapend zostało odwrócone do dnepalapen powodując, że wyszukiwanie nie znajduje nepalapend, co daje wartość -1, która wskazuje, że łańcuch nie został znaleziony.

Inna metoda print true if palindrom else print false

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

Wyjście: TRUE

Istnieje również funkcjonalny sposób:

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

Wiem, że na to pytanie już jakiś czas temu odpowiedziałam i za wtargnięcie Jednak pracowałem nad sposobem zrobienia tego również w Pythonie i pomyślałem, że podzielę się sposobem, w jaki to zrobiłem, jest następujący]}

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)

Znalazłem łatwiejszy sposób. To tylko 1 linia.

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

Tutaj rozróżnia wielkość liter ponieważ wszystkie powyższe rozwiązania uwzględniają wielkość liter.

def Palindrome(string): 

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

Ta funkcja zwróci wartość boolean .

Robiąc kurs Watterloo dla Pythona, te same pytania są zadawane jako "Lesseon" znajdź info tutaj:

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

Funkcja nazywa się isPalindrome(s) i wymaga ciągu " S " . Wartość zwracana jest domyślnie TRUE , aby mieć początkowe sprawdzenie na pierwszej instrukcji if.

Następnie pętla for biegnie w połowie Długość łańcucha, aby sprawdzić, czy znak z łańcucha " S " w pozycji "i" jest taki sam z przodu i z tyłu. Jeśli tak się nie stanie, funkcja zatrzyma się, wyświetli FALSE I zwróci false.

Cheers.kg

Jeśli łańcuch znaków ma wielkie lub nie-Alfabetyczne znaki, to funkcja konwertuje wszystkie znaki na małe i usuwa wszystkie Nie-Alfabetyczne znaki za pomocą regex wreszcie stosuje palindrom sprawdź rekurencyjnie:

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))

Wyjście to True dla powyższego wejścia.

Może spróbujesz tego:

list=input('enter a string:')

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

Pytacie palindrom w Pythonie. palindrom może być wykonywany na ciągach, numerach i listach. Jednak po prostu opublikowałem prosty kod, aby sprawdzić palindrom łańcucha znaków.

# 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"

Naprawdę łatwym sposobem na to jest

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

I jeśli / else tutaj tylko dla fantazyjnych wygląd. Pytanie o palindrom było w wywiadzie dla Amazona dla QA

Zakładając łańcuch " s "

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

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

Napisałem ten kod:

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")

Wtedy 'if x+1 = = len (word)' oznacza, że ponieważ x zaczyna się od 0, staje się 1, a następnie dla każdego następnego .. bla bla bla to działa, więc działa.

#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]

Możesz użyć Deques w Pythonie, aby sprawdzić palindrom

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)

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')

"algorytmiczny" sposób:

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

Jest inny sposób, używając funkcji, jeśli nie chcesz używać odwrotnej

#!/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")

Wygląda ładniej z rekurencją!

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

print ["Not a palindrome","Is a palindrome"][s == ''.join([s[len(s)-i-1] for i in range(len(s))])]

Jest to typowy sposób pisania kodu jednowierszowego

def pali(str1):
    l=list(str1)
    l1=l[::-1]
    if l1==l:
        print("yess")
    else:
        print("noo")
str1="abc"
a=pali(str1)
print(a)

Próbowałem użyć tego:

def palindrome_numer(num):
num_str = str(num)
str_list = list(num_str)
if str_list[0] == str_list[-1]:
    return True
return False

I zadziałało na liczbę ale nie wiem czy ciąg

def isPalin(checkWord):
    Hsize = len(lst)/2
    seed = 1
    palind=True
    while seed<Hsize+1:
        #print seed,lst[seed-1], lst [-(seed)]
        if(lst[seed-1] != lst [-seed]):
            palind = False
            break
        seed = seed+1
    return palind

lst = 'testset'
print lst, isPalin(lst)    
lst = 'testsest'
print lst, isPalin(lst) 

Wyjście

testset True
testsest False

Oto przykład, który pobiera dane wejściowe użytkownika i sprawdza, czy dane wejściowe są palindromem:

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")

Nie ma jednak potrzeby nawet konfigurowania if/else oświadczenie. Możesz bezpośrednio wydrukować wynik porównania logicznego, jak pokazano tutaj:

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

#!/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"

It is very easy

#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")

Thanks