Comment vérifier le palindrome à l'aide de la logique Python
J'essaie de vérifier s'il y a un palindrome avec Python. Le code que j'ai est très for- boucle intensive.
Et il me semble que la plus grande erreur que font les gens quand ils passent de C à Python est d’implémenter la logique C en utilisant Python, ce qui ralentit les choses et ne permet pas de tirer le meilleur parti du langage.
Je vois sur this website. Recherchez "C-style for", Python n’a pas de style C pour les boucles. Peut-être obsolète, mais j’interprète cela comme signifiant que Python a ses propres méthodes à cet effet.
J'ai essayé de regarder autour de moi, je ne trouve pas beaucoup de conseils récents (Python 3) à ce sujet. Comment puis-je résoudre un défi palindrome en Python sans utiliser la boucle for?
Je l'ai fait en C en classe, mais je veux le faire en Python, à titre personnel. Le problème vient du Euler Project , excellent site Par ailleurs ,.
def isPalindrome(n):
lst = [int(n) for n in str(n)]
l=len(lst)
if l==0 || l==1:
return True
Elif len(lst)%2==0:
for k in range (l)
#####
else:
while (k<=((l-1)/2)):
if (list[]):
#####
for i in range (999, 100, -1):
for j in range (999,100, -1):
if isPalindrome(i*j):
print(i*j)
break
Il me manque beaucoup de code ici. Les cinq hachages ne sont que des rappels pour moi.
Questions concrètes:
En C, je ferais une boucle for comparant l'index 0 à l'index max, puis l'index 0 + 1 avec max-1, jusqu'à obtenir quelque chose. Comment mieux faire cela en Python?
Ma boucle for (dans la plage (999, 100, -1), est-ce une mauvaise façon de le faire en Python?
Quelqu'un a-t-il de bons conseils, de bons sites Web ou des ressources pour les personnes occupant mon poste? Je ne suis pas un programmeur, je n'aspire pas à l'être, je veux juste apprendre suffisamment pour que, lorsque j'écris ma thèse de baccalauréat (génie électrique), je n'ai pas à apprendre simultanément un langage de programmation applicable en essayant pour obtenir de bons résultats dans le projet. "Comment passer de C basique à une excellente application de Python", ce genre de chose.
Tous les morceaux de code spécifiques permettant de résoudre ce problème seraient également appréciés. Je dois apprendre de bons algorithmes. J'envisage trois situations. Si la valeur est zéro ou un chiffre, si elle est de longueur impaire et si elle est de longueur paire. Je comptais écrire pour les boucles ...
PS: Le problème est le suivant: trouver le produit le plus élevé de deux entiers à 3 chiffres qui est également un palindrome.
Une façon pythonique de déterminer si une valeur donnée est un palindrome:
str(n) == str(n)[::-1]
Explication:
- Nous vérifions si la représentation de chaîne de
nest égale à la représentation de chaîne inversée den - La tranche
[::-1]se charge d'inverser la chaîne - Après cela, nous comparons pour l'égalité en utilisant
==
Une alternative à la syntaxe plutôt non intuitive [::-1] 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() réunit à nouveau ces caractères, sans rien entre eux.
Pour mémoire, et pour ceux qui recherchent un moyen plus algorithmique de valider si une chaîne donnée est palindrome, deux façons d'obtenir le même résultat (en utilisant les boucles while et 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
Et .... le second:
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'êtes pas obligé d'utiliser des index pour les chaînes.
Ce qui suit fonctionnera (en utilisant des tranches)
def palindrome(n):
return n == n[::-1]
Cela revient simplement à inverser n et à vérifier s’ils sont égaux. n[::-1] inverse n (le -1 signifie décrémenter)
"2) Ma boucle for (dans la plage (999, 100, -1), est-ce une mauvaise façon de le faire en Python?"
En ce qui concerne ce qui précède, vous souhaitez utiliser xrange au lieu de range (car range créera une liste réelle, alors que xrange est un générateur rapide)
Mes opinions sur la question 3
J'ai appris le C avant Python, je viens de lire la documentation et de jouer avec la console. (et en faisant aussi des problèmes avec Project Euler :)
En dessous, le code imprimera 0 s'il s'agit de Palindrome sinon, il imprimera -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 dans la chaîne, la valeur renvoyée est la valeur de l'emplacement de début de la chaîne.
Donc, lorsque vous faites Word.find(Word[::-1]), il trouve nepalapen à l'emplacement 0 et [::-1] inverse nepalapen et il est toujours nepalapen à l'emplacement 0 so 0 est renvoyé.
Maintenant, lorsque nous recherchons nepalapend puis inversons nepalapend en dnepalapen, il restitue une instruction FALSE, nepalapend a été inversé en dnepalapen, ce qui a entraîné la recherche impossible de trouver nepalapend, ce qui donne une valeur de -1 qui indique une chaîne introuvable.
Une autre méthode print true if palindrome else print false
Word = "nepalapen"
print(Word[::-1]==Word[::1])
sortie: TRUE
Il y a aussi un fonctionnel chemin:
def is_palindrome(Word):
if len(Word) == 1: return True
if Word[0] != Word[-1]: return False
return is_palindrome(Word[1:-1])
Il y a beaucoup plus facile que je viens de trouver. C'est seulement 1 ligne.
is_palindrome = Word.find(Word[::-1])
Je sais que cette question a reçu une réponse il y a quelque temps et je m'excuse pour l'intrusion. Cependant, je travaillais aussi sur une façon de faire cela en python 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)
Vous demandez le palindrome en python. Le palindrome peut être exécuté 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"
Ici une insensible à la casse / puisque toutes les solutions ci-dessus sont sensibles à la casse.
def Palindrome(string):
return (string.upper() == string.upper()[::-1])
Cette fonction retournera une valeur boolean .
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
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
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 à l'aide de regex. La vérification du palindrome est appliquée de manière récursive:
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.
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
#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]
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 du code simple ligne
Il existe un autre moyen d’utiliser des fonctions, si vous ne voulez pas utiliser le 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")
Vous pouvez utiliser Deques en python pour vérifier le 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)
def is_palindrome(string):
return string == ''.join([letter for letter in reversed(string)])
C'est 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
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')
Word = "<insert palindrome/string>"
reverse = Word[::-1]
is_palindrome = Word.find(reverse)
print is_palindrome
C'était une question de Udacity comp 101, chapitre 1. Donne un 0 pour palindrome donne un -1 pour non C'est simple et n'utilise pas de boucles.
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")
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 cela fonctionne… .. il obtient le mot, puis supprime les espaces et le transforme en une liste puis il vérifie si la première lettre est égale à la dernière et si le deuxième est égal au deuxième dernier et ainsi de suite.
alors le 'si x + 1 == len (Word)' signifie que, puisque x commence à 0, il devient 1 et ensuite pour chaque prochain .. bla bla bla ça marche donc ça marche.
def pali(str1):
l=list(str1)
l1=l[::-1]
if l1==l:
print("yess")
else:
print("noo")
str1="abc"
a=pali(str1)
print(a)
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 le palindrome était sur l'interview d'Amazon pour QA
en faisant le cours Watterloo pour le python, les mêmes questions se posent lorsqu'un "Lesseon" trouve l'info ici:
http://cscircles.cemc.uwaterloo.ca/13-lists/
étant 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 s'appelle isPalindrome (S) et nécessite une chaîne "S" . La valeur de retour est par défaut TRUE, pour que la vérification initiale soit effectuée le premier si déclaration.
Après cela, la boucle for exécute la moitié de la longueur de la chaîne pour vérifier si le caractère de la chaîne "S" à la position "i" est identique à l'avant et à l'arrière . Si ce n'est pas le cas, la fonction s'arrête, affiche FALSE et renvoie false.
Cheers.kg
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