palindromo - python palabra palindrome

Cómo verificar para palindrome usando la lógica de Python

Question

Estoy intentando buscar un palíndromo con Python. El código que tengo es muy for -loop intensive.

Y me parece que el mayor error que comete la gente al pasar de C a Python es implementar la lógica C utilizando Python, lo que hace que las cosas funcionen lentamente, y simplemente no aprovecha al máximo el idioma.

Veo en this sitio web. Busque "C-style for", que Python no tiene estilo C para bucles. Puede ser obsoleto, pero interpreto que quiere decir que Python tiene sus propios métodos para esto.

Intenté buscar, no encuentro consejos actualizados (Python 3) para esto. ¿Cómo puedo resolver un desafío palindrome en Python, sin usar el bucle for?

He hecho esto en C en clase, pero quiero hacerlo en Python, de forma personal. El problema es del Proyecto Euler , gran sitio Por cierto ,.

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

Me falta mucho código aquí. Los cinco hashes son solo recordatorios para mí.

Preguntas concretas:

1. En C, haría un bucle for para comparar el índice 0 con el índice máximo, y luego el índice 0 + 1 con max-1, hasta que algo sea cierto. ¿Cómo hacer esto mejor en Python?

2. Mi bucle for (en el rango (999, 100, -1), ¿es esta una mala manera de hacerlo en Python?

3. ¿Alguien tiene algún buen consejo, buenos sitios web o recursos para personas en mi posición? No soy programador, no aspiro a serlo, solo quiero aprender lo suficiente para que cuando escriba mi tesis de licenciatura (ingeniería eléctrica), no tenga que APRENDER simultáneamente un lenguaje de programación aplicable mientras lo intento para obtener buenos resultados en el proyecto. "Cómo pasar de la C básica a la gran aplicación de Python", ese tipo de cosas.

4. Cualquier fragmento de código específico para hacer una gran solución a este problema también sería apreciado, necesito aprender buenos algoritmos. Estoy imaginando 3 situaciones. Si el valor es cero o un solo dígito, si es de longitud impar y si tiene una longitud pareja. Estaba planeando para escribir bucles ...

PD: El problema es: encontrar el producto de mayor valor de dos enteros de 3 dígitos que también es un palíndromo.

Answer 1

¡Se ve más bonito con la recursión!

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

Answer 2

Aquí hay un ejemplo que toma la entrada de un usuario y verifica si la entrada es un palíndromo:

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

Sin embargo, no hay necesidad de configurar la instrucción if / else . Puede imprimir directamente el resultado de la comparación lógica, como se muestra aquí:

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

Answer 3

Aquí una función insensible a las mayúsculas ya que todas las soluciones anteriores son sensibles a mayúsculas y minúsculas.

def Palindrome(string): 

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

Esta función devolverá un valor booleano .

Answer 4

Asumiendo una cadena ''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

Answer 5

Debajo del código se imprimirá 0 si es Palindrome, de lo contrario se imprimirá -1

Código optimizado

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

Salida: 0

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

Salida: -1

Explicación

Al buscar en la cadena, el valor que se devuelve es el valor de la ubicación en la que comienza la cadena.

Entonces cuando haces word.find(word[::-1]) encuentra nepalapen en la ubicación 0 y [::-1] invierte nepalapen y todavía está nepalapen en la ubicación 0 por lo que se devuelve 0 .

Ahora cuando buscamos nepalapend y luego nepalapend a dnepalapen , hace que una sentencia FALSE nepalapend se invirtiera en dnepalapen provoca que la búsqueda no encuentre nepalapend lo que nepalapend resultado un valor de -1 que indica cadena no encontrada.

Otro método print true if palindrome else print false

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

salida: VERDADERO

Answer 6

Escribí este código:

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

y funciona. recibe la palabra, luego quita los espacios y los convierte en una lista, luego prueba si la primera letra es igual a la última y si la segunda es igual a la 2ª, y así sucesivamente.

entonces el ''si x + 1 == len (palabra)'' significa que como x comienza en 0 se convierte en 1 y luego en cada próximo ... bla, bla, bla, funciona para que funcione.

Answer 7

Estás preguntando palindrome en python. palindrome se puede realizar en cadenas, números y listas. Sin embargo, acabo de publicar un código simple para verificar palindrome de una cadena.

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

Answer 8

Hay otra forma de usar funciones, si no quieres usar el inverso

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

Answer 9

Hay una manera mucho más fácil que acabo de encontrar. Es solo 1 linea

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

Answer 10

La manera más fácil de hacerlo es

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

Y si / aquí solo para looks sofisticados. La pregunta sobre el palíndromo fue en la entrevista de Amazon para QA

Answer 11

La parte impresionante de Python son las cosas que puedes hacer con ella. No tiene que usar índices para cadenas.

Lo siguiente funcionará (usando rebanadas)

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

Lo que hace es simplemente invierte ny verifica si son iguales. n[::-1] invierte n (el -1 significa decrementar)

"2) Mi bucle for (dentro del rango (999, 100, -1), ¿es esta una mala manera de hacerlo en Python?"

Con respecto a lo anterior, desea utilizar xrange lugar de range (porque range creará una lista real, mientras que xrange es un generador rápido)

Mis opiniones sobre la pregunta 3

Aprendí C antes que Python, y acabo de leer los documentos y jugué con la consola. (y al hacer los problemas del Proyecto Euler también :)

Answer 12

Sé que esta pregunta fue respondida hace un tiempo y me disculpo por la intrusión. Sin embargo, estaba trabajando en una forma de hacer esto en Python y pensé que compartiría la forma en que lo hice es la siguiente,

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)

Answer 13

Si la cadena tiene un carácter en mayúscula o no alfabético, la función convierte todos los caracteres en minúsculas y elimina todos los caracteres no alfabéticos utilizando expresiones regulares, finalmente aplica palindrome check recursively:

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 salida es True para la entrada anterior.

Answer 14

Solo para el registro, y para los que buscan una forma más algorítmica para validar si una cadena dada es palíndromo, dos formas de lograr lo mismo (usando ciclos while y 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

Y .... el segundo:

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

Answer 15

También hay una forma funcional :

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

Answer 16

Una alternativa a la sintaxis bastante poco intuitiva [::-1] es esta:

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

La función reversed devuelve una secuencia invertida de los caracteres en test .

''''.join() unir esos personajes sin nada en el medio.

Answer 17

Una forma pythonic para determinar si un valor dado es un palíndromo:

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

Explicación:

• Estamos comprobando si la representación de cadena de n es igual a la representación de cadena invertida de n
• El segmento [::-1] se encarga de invertir la cadena
• Después de eso, comparamos por igualdad usando ==

Answer 18

es muy fácil

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

Gracias

Answer 19

haciendo el curso de Watterloo para Python, las mismas preguntas se plantean como un "Lesseon" encontrar la información aquí:

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

siendo un novato, resolví el problema de la siguiente manera:

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 función se llama isPalindrome (S) y requiere una cadena "S" . El valor de retorno es TRUE por defecto, para tener la verificación inicial en la primera instrucción if.

Después de eso, el bucle for ejecuta la mitad de la longitud de la cuerda para comprobar si el carácter de la cuerda "S" en la posición "i" es el mismo desde el frente y desde la parte posterior. Si, una vez que este no es el caso, la función se detiene, imprime FALSO y devuelve falso.

Cheers.kg

Answer 20

la manera "algorítmica":

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

Answer 21

tal vez puedes probar este:

list=input(''enter a string:'')

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

Answer 22

Puede usar Deques en python para verificar 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)

Answer 23

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

Answer 24

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

Answer 25

def is_palindrome(string):
   return string == ''''.join([letter for letter in reversed(string)])

Answer 26

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

Answer 27

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

Answer 28

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

Esta es la forma típica de escribir código de una sola línea

Answer 29

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

Esta fue una pregunta en Udacity comp 101, capítulo 1. Da un 0 para palindrome da un -1 para no. Es simple, y no usa bucles.