Comment vérifier palindrome en utilisant la logique Python [fermé]

Une alternative à la syntaxe [::-1] plutôt non intuitive est la suivante:

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

La fonction reversed renvoie une séquence inversée des caractères dans test.

''.join() joins ces personnages ensemble à nouveau avec rien entre les deux.

Juste pour l'enregistrement, et pour ceux qui recherchent un moyen plus algorithmique de valider si une chaîne donnée est palindrome, deux façons d'obtenir la même chose (en utilisant while et for boucles):

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

Et....la seconde:

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

La partie géniale de python est ce que vous pouvez faire avec. Vous n'avez pas besoin d'utiliser des index pour les chaînes.

Ce qui suit fonctionnera (en utilisant des tranches)

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

Ce qu'il fait est simplement inverse n, et vérifie si elles sont égales. n[::-1] inverse n (Le -1 signifie décrémenter)

"2) Ma boucle for (dans l'aire de répartition (999, 100, -1), est-ce une mauvaise façon de le faire en Python?"

En ce qui concerne ce qui précède, vous voulez utiliser xrange au lieu de range (car range créer une liste réelle, alors que xrange est un générateur rapide)

Mon avis sur la question 3

J'ai appris C avant Python, et je viens de lire les documents, et j'ai joué avec en utilisant la console. (et en faisant des problèmes de projet Euler aussi:)

Ci-Dessous le code d'impression 0 si c'est Palindrome else, il permet d'imprimer -1

Code Optimisé

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

Sortie: 0

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

Sortie: -1

Explication:

Lors de la recherche la chaîne de la valeur retournée est la valeur de l'emplacement que la chaîne commence.

Ainsi, lorsque vous vous word.find(word[::-1]), il trouve nepalapen emplacement 0 et [::-1] renverse nepalapen et il l'est toujours nepalapen emplacement 0, donc 0 est retourné.

Maintenant, lorsque nous recherchons nepalapend et que nous inversons nepalapend vers dnepalapen, une instruction FALSE nepalapend a été inversée vers dnepalapen, ce qui fait que la recherche ne parvient pas à trouver nepalapend résultant en une valeur de -1 qui indique une chaîne introuvable.

Une Autre méthode d'impression true si palindrome else print false

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

Sortie: Vrai

Il y a aussi une manièrefonctionnelle :

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

Je sais que cette question a été répondue il y a un moment et j'appologize pour l'intrusion. Cependant, je travaillais sur une façon de le faire en python aussi et je pensais juste que je partagerais la façon dont je l'ai fait est la suivante,

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)

Il y a beaucoup plus facile que je viens de trouver. C'est seulement 1 ligne.

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

Voici une fonctioninsensible à la casse puisque toutes les solutions ci-dessus sont sensibles à la casse.

def Palindrome(string): 

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

Cette fonction renverra une valeurbooléenne .

Faire le cours Watterloo pour python, les mêmes questions sont soulevées comme un "Lesseon" trouver l'info ICI:

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

Étant un novice, j'ai résolu le problème de la manière suivante:

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

La fonction est appelée isPalindrome(S) et nécessite une chaîne de caractères "S". La valeur de retour est par défaut TRUE , pour avoir la vérification initiale sur la première instruction if.

Après cela, la boucle for s'exécute à moitié la longueur de la chaîne pour vérifier si le caractère de string "S" à la position "i" est le même à partir de l'avant et de l'arrière. Si une fois ce n'est pas le cas, la fonction s'arrête, imprime FALSE et renvoie false.

Cheers.kg

Si la chaîne a un caractère majuscule ou non alphabétique, la fonction convertit tous les caractères en minuscules et supprime tous les caractères non alphabétiques en utilisant regex enfin, elle applique la vérification palindrome récursivement:

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

La sortie est True pour l'entrée ci-dessus.

Peut-être que vous pouvez essayer celui-ci:

list=input('enter a string:')

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

Vous demandez palindrome en python. palindrome peut être effectué sur des chaînes, des nombres et des listes. Cependant, je viens de poster un code simple pour vérifier le palindrome d'une chaîne.

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

Le vrai moyen facile de le faire est

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

Et si / sinon ici juste pour les regards de fantaisie. La question sur palindrome était sur L'interview D'Amazon pour QA

En supposant une chaîne ' 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

C'était une question dans Udacity comp 101, chapitre 1. Donne un 0 pour palindrome donne un -1 pour non. C'est simple, et n'utilise pas de boucles.

J'ai écrit ce code:

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

Et ça marche. il obtient le mot, puis supprime les espaces et se transforme en une liste ensuite, il teste si la première lettre est égal à la dernière et si le 2ème est égale à la 2e dernier et ainsi de suite.

Alors le ' if x + 1 = = Len (word)' signifie que puisque x commence à 0 Il devient 1 et ensuite pour chaque suivant .. bla bla bla ça marche donc ça marche.

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

Vous pouvez utiliser Deques en python pour vérifier 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)

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

La manière "algorithmique":

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

Il existe un autre moyen d'utiliser des fonctions, si vous ne voulez pas utiliser reverse

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

Il semble plus joli avec la récursivité!

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

C'est la manière typique d'écrire le code d'une seule ligne

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

J'ai essayé d'utiliser ceci:

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

Et cela a fonctionné pour un nombre mais je ne sais pas si une chaîne

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) 

Sortie

testset True
testsest False

Voici un exemple de l'entrée d'un utilisateur et vérifie si l'entrée est un palindrome:

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

Cependant, il n'est même pas nécessaire de configurer le if/else déclaration. Vous pouvez directement imprimer le résultat de la comparaison logique, comme indiqué ici:

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"

C'est très facile

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

Merci