Cómo verificar palíndromo usando la lógica de Python

Estoy intentando comprobar si hay un palíndromo con Python. El código que tengo es muy intensivo for -loop.

Y me parece que el mayor error que comete la gente al pasar de C a Python es tratar de implementar la lógica C con Python, lo que hace que las cosas se desarrollen lentamente y no aproveche al máximo el lenguaje.

Lo veo en este sitio web. Busque “estilo C para”, que Python no tiene estilo C para bucles. Podría estar desactualizado, pero lo interpreto en el sentido de que Python tiene sus propios métodos para esto.

He intentado mirar a mi alrededor, no puedo encontrar muchos consejos actualizados sobre este tema (Python 3). ¿Cómo puedo resolver un desafío de palíndromo en Python, sin usar el bucle for?

He hecho esto en C en clase, pero quiero hacerlo en Python, a título 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 mi.

    Preguntas concretas:

    1. En C, haría un bucle for comparando el índice 0 con el índice máximo, y luego indexaría 0 + 1 con un máximo de 1, hasta que aparezca algo. ¿Cómo hacer esto mejor en Python?

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

    3. ¿Alguien tiene algún buen consejo, o buenos sitios web o recursos para las personas en mi posición? No soy progtwigdor, 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 progtwigción aplicable al intentar 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 bit específico de código 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 es de longitud uniforme. Estaba planeando escribir para loops …

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

    Una forma pythonica 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
    • La [::-1] se encarga de invertir la cadena
    • Después de eso, comparamos la igualdad usando ==

    Una alternativa a la syntax 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() une a esos personajes otra vez con nada en medio.

    Solo para el registro, y para aquellos que buscan una forma más algorítmica de validar si una cadena dada es palíndromo, dos formas de lograr lo mismo (usando while y for bucles):

     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 … la segunda:

     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 parte impresionante de python es lo que puedes hacer con ella. No tienes que usar índices para cadenas.

    Lo siguiente funcionará (usando rebanadas)

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

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

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

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

    Mis opiniones sobre la pregunta 3

    Aprendí C antes de Python, y acabo de leer los documentos, y jugué con ellos usando la consola. (Y haciendo problemas de Project Euler también 🙂

    Debajo del código se imprimirá 0 si es Palindrome o si no 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

    Explicacion

    cuando se busca 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 a nepalapen y aún es nepalapen en la ubicación 0 por lo que devuelve 0 .

    Ahora, cuando buscamos nepalapend y luego nepalapend a dnepalapen , dnepalapen una sentencia FALSE nepalapend se invirtió a dnepalapen provocó que la búsqueda no pudiera encontrar nepalapend lo que nepalapend resultado un valor de -1 que indica que no se encontró la cadena.


    Otro método imprime verdadero si palindrome o imprime falso

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

    salida: VERDADERO

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

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

     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''ta plindrome' is_palindrome(word) 

    Hay una manera mucho más fácil que acabo de encontrar. Es sólo 1 línea.

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

    Aquí hay una función que distingue entre mayúsculas y minú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 .

    haciendo el curso de Watterloo para python, las mismas preguntas se plantean como “Lesseon”. Encuentra 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 comprobación inicial en la primera sentencia if.

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

    Cheers.kg

    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 usando expresiones regulares. Finalmente, se aplica la comprobación de palíndromo de forma recursiva:

     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.

    tal vez usted puede probar este

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

    Estás pidiendo palíndromo en python. palíndromo se puede realizar en cadenas, números y listas. Sin embargo, acabo de publicar un código simple para verificar el palíndromo 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" 

    La verdadera manera 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 / si no, aquí solo para looks de fantasía. La pregunta sobre palíndromo estaba en la entrevista de Amazon para control de calidad.

    Suponiendo 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 
     word = "" 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.

    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 la convierte en una lista, luego prueba si la primera letra es igual a la última y si la segunda es igual a la 2da última, y ​​así sucesivamente.

    luego ‘si x + 1 == len (palabra)’ significa que, dado que x comienza en 0, se convierte en 1 y luego en cada siguiente … bla bla bla funciona así.

     #compare 1st half with reversed second half # ie 'abba' -> 'ab' == 'ba'[::-1] def is_palindrome( s ): return True if len( s ) < 2 else s[ :len( s ) // 2 ] == s[ -( len( s ) // 2 ):][::-1] 

    Puedes usar Deques en python para verificar palíndromo

    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 forma “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 

    Hay otra forma de usar las funciones, si no quieres usar reversa

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

    ¡Se ve más bonita 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 
     def is_palindrome(string): return string == ''.join([letter for letter in reversed(string)]) 
     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

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

    Intenté usar esto:

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

    y funcionó para un número, pero no sé si una cadena

     def isPalin(checkWord): Hsize = len(lst)/2 seed = 1 palind=True while seed 

    Salida

     testset True testsest False 

    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  to check if the word is a palindrome.") if str(name) == str(name)[::-1]: print("True") else: print("False") 

    Sin embargo, no es necesario configurar la sentencia 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  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"