¡Te damos la bienvenida a este reto!

1

Empezando con Python desde 0

Día 1

2

Variables, funciones y sintaxis básica

3

Tipos de datos: Numbers, Strings y Diccionarios

4

Playground - Retorna el tipo

Día 2

5

Operadores

6

Playground - Calcula la propina

Día 3

7

Condicionales

8

Playground - Averigua si un año es bisiesto

9

Ciclos

10

Playground - Dibuja un triangulo usando bucles

Día 4

11

Listas

12

Encuentra a los gatitos más famosos

13

Diccionarios

14

Obtén el promedio de los estudiantes

15

Tuplas

16

Obten la información de los paquetes

Día 5

17

Calcula la cantidad de letras en una oración

18

Encuentra el mayor palíndromo

Día 6

19

Sets

20

Encuentre la intersección de conjuntos

Día 7

21

List comprehension

22

Encuentra palabras con dos vocales

23

Dictionary Comprehension

24

Calcula la longitud de las palabras

Día 8

25

Funciones Lambda

26

Filtra mensajes de un user específico

27

Higher order functions

28

Crea tu propio método map

Día 9

29

Manejo de Errores y excepciones

30

Maneja correctamente los errores

31

Maneja las excepciones

Día 10

32

Playground - Crea un task manager usando closures

Día 11

33

Lectura de archivos de texto y CSV

Día 12

34

Programación orientada a objetos

35

Crea un auto usando clases

Día 13

36

Abstracción en Python

37

Playground - Crea un sistema de carrito de compras

38

Encapsulamiento en Python

39

Playground - Encapsula datos de los usuarios

Día 14

40

Herencia en Python

41

Playground - Jerarquía de animales usando herencia

Día 15

42

Polimorfismo en Python

43

Playground - Implementa un sistema de pagos

Día 16

44

Estructuras de datos en Python

45

Playground - Crea tu propia lista en python

46

Hash tables en Python

47

Playground - Implementación de una HashTable para Contactos

Día 17

48

Maps en Python

49

Playground - Crea un task manager con Maps

Día 18

50

Singly Linked List en Python

51

Playground - Implementación de una singly linked list

Día 19

52

Stacks en Python

53

Playground - Implementación de un stack

Día 20

54

Queues en Python

55

Playground - Implementación de una queue

Día 21

56

¡Lo lograste!

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Encuentra el mayor palíndromo

18/56

Aportes 48

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?


.
.

def find_largest_palindrome(words):
   largest = 0
   palindrome = ""

   for word in words:
      if word == word[::-1]:
         if len(word) > largest:
            palindrome = word
            largest = len(word)
      
   return palindrome if palindrome else None

Lo solucioné, pero me daba error en dos test, era por el “largest” y después quise simplificarlo. buena aplicación…
.
.
.
.


.
.
.
.
Muy buen reto! 🐍👌🏼
.
.
.
.

def find_largest_palindrome(words):
  #variables
  longitudMayor = 0
  palindromo=""
  #iterando para cada palabra
  for i in words:
    #condicion 1 comprueba que la palabra sea palíndromo usando slicing
    #condicion 2 comprueba si es el mayor palíndromo
    if i == i[::-1] and len(i)>longitudMayor:
      palindromo = i
      longitudMayor = len(i)

  #si no hay palindromo se regresa "None"
  if palindromo=="":
    return None
  
  return (palindromo)

No pude resolver como iterar en una lista para saber que palabra es más larga, a seguir estudiando

```js def find_largest_palindrome(words): mayor=0 mas_largo=None for palabra in words: if es_palindromo(palabra): longitud=len(palabra) if longitud > mayor: mayor=longitud mas_largo=palabra return mas_largo def es_palindromo(word): word=word.lower() letras=len(word) for letra in range(0, letras): if word[letra]!= word[letras-letra-1]: return False return True ```
Comparto versión reducida, saludos! ```python def find_largest_palindrome(words): return max([word for word in words if word == word[::-1]], key = len, default = None) ```
hi, i did it!! ![](https://static.platzi.com/media/user_upload/image-e27fb6f2-4b90-4422-a07f-754e251c6395.jpg)
![](https://static.platzi.com/media/user_upload/anti%20spoiler3-0838bae1-e602-42ef-ab87-3ec49fd7363f.jpg) . . . ```python def find_largest_palindrome(words): # maximo = max(list(map(lambda palabra : len(palabra) , words)))) filtro= [] palindrome = [] for item in words: if len(item) // 2 != 0: filtro.append(item) # print(filtro) cont = 0 coincide = -1 while cont <= len(filtro)-1: inv = len(filtro[cont])-1 for num, letra in enumerate(filtro[cont]): # print( filtro[cont][num],filtro[cont][inv]) if filtro[cont][num] == filtro[cont][inv]: coincide += 1 # print("num",num,"incide",coincide,"inv",inv,filtro[cont][num] , filtro[cont][inv],filtro[cont],) if num == coincide and coincide == inv: # print(coincide,num,inv) # print("palindramo", filtro[cont] ) palindrome.append(filtro[cont]) inv -= 1 cont += 1 coincide = -1 if len(palindrome) > 0: len_max = max(list(map(lambda palabra : len(palabra) , palindrome))) # 9 # print("len_max",len_max) for letra in palindrome: if len(letra) == len_max: # print("encontrado", letra) palindrome = [] return letra #palindrome.append(letra) break else: #palindrome = [ "None"] return None ```

.
.
.
.
.
.
.
.
.
Se podría optimizar para bajar complejidad pero bueeee 😄

def find_largest_palindrome(words):
    words_List = []
    words_list_reverse = []
    palindromos = []

    for phrase_or_word in words:
        list_by = list(phrase_or_word.split(" ")[0])
        words_List.append(''.join(list_by))
        reverse = ''.join(list_by[::-1])
        words_list_reverse.append(reverse)

    for phrase_or_word in words_List:
        if phrase_or_word in words_list_reverse:
            palindromos.append(phrase_or_word)

    palindromos_ordenados = sorted(palindromos, key=len, reverse=True)

    if len(palindromos_ordenados) == 0:
        return None

    return palindromos_ordenados[0]
def find_largest_palindrome(words):
    # Tu código aquí 👈
    mayor = 0
    devolver = None
    for palabra in words:
        if palabra == palabra[::-1]:
            if len(palabra) > mayor:
                mayor = len(palabra)
                devolver = palabra
    return devolver

Hola, les comparto mi solución:

def find_largest_palindrome(words):
  # Tu código aquí 👈
  palindrome = ''
  for word in words:
    if word[::-1] == word and len(word) > len(palindrome):
      palindrome = word
    
  if palindrome == '':
    palindrome = None
    
  return palindrome
  pass
def find_largest_palindrome(words):

  palindromos = []
  mayor_palindromo =''

  
  for word in words:
    if word[::-1] == word:
      palindromos.append(word)

  for palindromo in palindromos:
    if len(mayor_palindromo) < len(palindromo):
      mayor_palindromo = palindromo
    
  if mayor_palindromo != '':
    return mayor_palindromo
  else:
    return None

🛡️🛡️Escudo anti-spoilers🛡️🛡️

Mi solución al reto:

def find_largest_palindrome(words):
  palindromes = list()
  for w in words:
    is_palindrome = True 
    for i,v in enumerate(w):
      if v != w[len(w)-i-1]:
       is_palindrome = False 
    if is_palindrome: 
      palindromes.append(w)  
  if len(palindromes) <=0:
    return None
  return max(palindromes, key=len)

Palabras = [“racecar”, “level”, “world”, “hello”]
#Palabras = [“Platzi”, “Python”, “django”, “flask”]
def Palindromos(Palabras):
Longitud = 0
Palindromo = ""
for Palabra in Palabras:
if Palabra == Palabra[::-1]:
if len(Palabra) > Longitud:
Palindromo = Palabra
Longitud = len(Palabra)
print(Palindromo if Palindromo else None)

Palindromos(Palabras)

...
def find_largest_palindrome(words):
  # Tu código aquí 👈
  palindromo = "None"
  mayor = []
  for word in words:
    invertido = word[::-1]
    if word == invertido:
      palindromo = word
      #print(palindromo)
      #print(len(mayor))
      if len(mayor) < len(word):
        mayor = word
      

  if palindromo == "None":
    return None
  else:
    return mayor 
  
words = find_largest_palindrome(["racecar", "level", "world", "hello", "jjjjjjjjjj"])
print(words)  

solución: utilizando lambda

def find_largest_palindrome(words):
    #creando el diccionario
    dictresultfinal={ 
    }

    dictresultfinal={propword: propword for propword in words if propword[::-1]==propword }
    #print(dictresultfinal)
     
    return max(dictresultfinal, key=lambda x: len(x), default=None)

if __name__ == '__main__':
    response=find_largest_palindrome(["racecar", "level", "world", "hello"])
    print(response)

    response=find_largest_palindrome(["Platzi", "Python", "django", "flask"])
    print(response)

Solución:

def find_largest_palindrome(words):
  pal = None
  max_len = -1
  for i in words:
    if i == i[::-1] and len(i) > max_len:
      max_len = len(i)
      pal = i
  return pal

Siempre que exista un palindrome ambas variables serán actualizadas, ya que el valor inicial de max_len es -1.

Solución 😄…
.

.
.
.
.

def find_largest_palindrome(words):
  return max(
    (word for word in words if word[::-1] == word), 
    key=len, 
    default=None
    )

Les comparto mi codigo, fue mi solucion inicial, vi que se puede evitar el if else conociendo mas a fondo la funcion max sin embargo me llevo su conocimiento para futuros desafíos

def find_largest_palindrome(words):
    palindromes = [word for word in words if word == word[::-1]]
    if palindromes == []:
        return None
    else:
        higher_len = max((len(word) for word in palindromes))
        result = [word for word in palindromes if len(word) >= higher_len]
        return result[0]
def find_largest_palindrome(words):
  palindromes = []
  largest_palindrome = []
  
  for i in words:
    if i == i[::-1]:
      palindromes.append(i)
      largest_palindrome.append(len(i))

  if palindromes == []:
    largest_palindrome_is = None
  
  else:
    index = largest_palindrome.index(max(largest_palindrome))
  
    largest_palindrome_is = palindromes[index]
  
  return largest_palindrome_is

Entiendo que python tiene utilidades geniales como voltear listas y cosas así, pero me parece importante de todas formas mostrar esta forma que es como se podría hacer en otros lenguajes, lo que se hace es que se salta la letra de la mitad, y las letras las va agregando y si la encuentra nuevamente debe sacarla, esto puede quizas no estar bien en una palabra como racecccar pero de resto funciona. Otro método que no le ocurre esto es hacer comparacion para que una letra con indice i sea igual a la del indice (length - i), para toda letra

// Spoileerrr

//

mport math
def find_largest_palindrome(words):
  largest = ""
  for word in words:
    letterList = []
    for i, letter in enumerate(word):
      if(i != math.floor(len(word) / 2)):
        if(len(letterList) > 0 and letterList[-1] == letter):
          print("sale", letter)
          letterList.pop()
        else:
          print("entra", letter)
          letterList.append(letter)

    if(len(letterList) == 0 and len(word) > len(largest)):
      largest = word
  return largest if largest else None

find_largest_palindrome(["racecar", "level", "world", "hello"])

Este tipo de ejercicios son el dia a dia, muy recomendado para quienes hacemos Backend.

def find_largest_palindrome(words):
  palindrome = ""
  mayorLongitud =  0
  for word in words:
    if word == word[::-1] and len(word) > mayorLongitud:
        palindrome = word
        mayorLongitud = len(word)

  return palindrome if mayorLongitud != 0 else None

Yo lo que hice fue tomar la solución de platzi y mejorarla


*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
Mentira 😏
*
*
*
*
*
*
*
*
*
*
*
*
*
*
Bromita jeje 🤡

def find_largest_palindrome(words):
  largest_palindrome = None
  for word in words:
    reversed_word = None
    
    for value in range(len(word), 0, -1):
      letter = word[value - 1]
      reversed_word += letter
    
    if reversed_word == word:
      if(len(word) > len(largest_palindrome)):
        largest_palindrome = word
  
  return largest_palindrome

Se me olvidó poner la del palíndromo


.
.
.
.
.
.
.


.
.
.
.
.

def find_largest_palindrome(words):
  palindrome = None
  for word in words:
    if word == word[::-1] and (palindrome == None or len(word) > len(palindrome)):
      palindrome = word

  return palindrome

Mi solución:
.
.
.
.
.
.
.
.
.
.

def find_largest_palindrome(words):
  largest_palindrome = max([word for word in words if word == word[::-1]], default=None)
  return(largest_palindrome)


.
.
.
.
.
.
.
.
.
.

Mi solución:

def find_largest_palindrome(words):
  """
  Encuentra el palíndromo más largo en una lista de palabras.

  Args:
    words: Una lista de palabras.

  Returns:
    El palíndromo más largo en la lista, o None si no hay ningún palíndromo.
  """

  longest_palindrome = None
  for word in words:
    if is_palindrome(word):
      if longest_palindrome is None or len(word) > len(longest_palindrome):
        longest_palindrome = word

  return longest_palindrome


def is_palindrome(word):
  """
  Determina si una palabra es un palíndromo.

  Args:
    word: Una palabra.

  Returns:
    True si la palabra es un palíndromo, False de lo contrario.
  """

  for i in range(len(word) // 2):
    if word[i] != word[len(word) - 1 - i]:
      return False

  return True


.
.
.
.
.
.
.
.
.
.

Mi aporte:
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

def find_largest_palindrome(words):
  # Tu código aquí 👈
  sizeWord = 0
  palindrome = None
  for word in words:
    if is_palindrome(word):
      if len(word) > sizeWord:
        sizeWord = len(word)
        palindrome = word
  return palindrome
  pass

def is_palindrome(word):
  word = word.lower()
  for i in range(len(word) // 2):
    if word[i] != word[len(word) - 1 - i]:
      return False
  return True

**

**
*

def find_largest_palindrome(words):
  largest_palindrome = None
  # iteramos en cada elemento de la lista
  for word in words:
    # comprobamos si es un palindromo
    if word == word[::-1]:
      if largest_palindrome is None or len(word) > len(largest_palindrome):
        largest_palindrome = word
      
  return largest_palindrome


response = find_largest_palindrome(["racecar", "level", "world", "hello"])

print(response)

response = find_largest_palindrome(["Platzi", "Python", "django", "flask"])

print(response)


Les comparto dos soluciones, la primera es un refactor de la segunda!

def find_largest_palindrome(words):
  pals = [w for w in words if w == w[::-1]]
  if pals:
    pal = max(pals, key=len)
    return pal if pal else None

def find_largest_palindrome(words):
  pals = [w for w in words if w == w[::-1]]
  pal = ""
  for i in pals:
    if len(i) > len(pal):
      pal = i
  return pal if pal else None
def find_largest_palindrome(words):

    palindrome = ""

    for word in words:
        reverse_word = word[::-1]
        if word == reverse_word and len(word) > len(palindrome):
            palindrome = word

    return palindrome if palindrome else None
    pass


.
.
.
.

def find_largest_palindrome(words):
  
  palindrome = tuple(
    word for word in words if word == word[::-1]
  )

  if palindrome:
    return max(palindrome, key=len)   
  
  return None

print(find_largest_palindrome(["racecar", "level", "world", "hello"]))

Mi aporte

.
.
.
.

def find_largest_palindrome(words):
    
    largo_palindrome = 0
    listapalindrome = []
    Mayor_palindrome = ''
     
    for palabra in words:
        if palabra == palabra[::-1]:
            
            if len(palabra) > largo_palindrome:
                largo_palindrome = len(palabra)
                Mayor_palindrome = palabra
                
                listapalindrome = Mayor_palindrome
            
    if Mayor_palindrome == '':
        return None
    else:
        return listapalindrome
        
    

resultado = find_largest_palindrome(["racecar", "level", "world", "hello","arenera","sometemos"])
print(resultado)


resultado = find_largest_palindrome(["Platzi", "Python", "django", "flask"])
print(resultado) 


.
.
.
.
.
.

def find_largest_palindrome(words):

    palindrome = ""
    largest = 0

    for word in words:
        if word == word[::-1] and len(word) > largest:
            palindrome = word
            largest = len(word)

    return palindrome if palindrome else None

print(find_largest_palindrome(["racecar", "level", "world", "hello"]))

No tiene nada de especial esta solución pero me inclino por la legibilidad del código

.
.
.
.
.
.

def find_largest_palindrome(words):
  word_final = ""
  palindrome = False
  for word in words:
    if word == word[::-1]:
      palindrome = True
      if len(word) > len(word_final):
        word_final = word
  
  return palindrome if palindrome else None


.
.
.
.
.
.
.
.
.
.
.

Aqui mi solucion:
.
.
.
.
.
.
.
.

def find_largest_palindrome(words):
  # Tu código aquí 👈
  list_word = []
  for word in words:
    if word == word[::-1]:
      list_word.append(word)
  word_largest = max(list_word, key = len) if len(list_word) >= 1 else None
  return word_largest 

Abajo mi solución
*
*
*
*
*
*
*
*
*

def find_largest_palindrome(words):
    # Tu código aquí 👈
  largest_palindrome = ""    
  for word in words:
    reversed_word = ""
    for letter in word:
      reversed_word = letter + reversed_word     
    if reversed_word == word:
      if (len(word) > len(largest_palindrome)):
        largest_palindrome = word
    
  return largest_palindrome if largest_palindrome else None


o
o
o
o
o
o
Extraño: cuando corri pruebas el codigo por primera vez daba errores. Revise y estaba seguro de mi codigo, reinicie la pagina, probe de nuevo y funciono …

def find_largest_palindrome(words):
  resultado = None
  maximo = 0
  for palabra in words:
    palabra_reversa = palabra[::-1]
    if (palabra == palabra_reversa):
      if len(palabra) > maximo:
        maximo = len(palabra)
        resultado = palabra
  return resultado    

print(find_largest_palindrome(["racecar", "level", "world", "hello"]))
print(find_largest_palindrome(["Platzi", "Python", "django", "flask"]))  
def find_largest_palindrome(words):
  palindromos=[]
  max=0
  for i in words:
    palabra_invertida = i[::-1] 
    if i ==palabra_invertida:
      palindromos.append(i)
  if len(palindromos)>0:
    for i in palindromos:
      if len(i)>max:
        max = len(i)
        word = i
    return word
  else: return None



*
*
*
*
*
*
*
*
*

Aquí les dejo mi código. Al final, cuando estaba haciendo las pruebas, fue que me di cuenta que tenía que agregar el palíndromo más largo, solamente estaba agregando el primero que me encontraba jeje

def find_largest_palindrome(words):
  palindrom = ""
  

  for word in words:
    word_array = list(word)
    word_array.reverse()
    reversed_word = "".join(word_array)
    if reversed_word == word and len(palindrom) < len(word):
      palindrom = word
  
  if palindrom == "":
    return None
  else:
    return palindrom


.
.
.
.
.

def find_largest_palindrome(words):
  # Tu código aquí 👈
  index_greater_palindrome = -1
  size_greater_palindrome = 0

  for i in range(0, len(words)):
    word = words[i]
    word_length = len(word)

    if (word == word[::-1] and size_greater_palindrome < word_length):
      index_greater_palindrome = i
      size_greater_palindrome = word_length
  
  if index_greater_palindrome != -1:
    return words[index_greater_palindrome]
  else:
    return None


*
*
*
*
*

def find_largest_palindrome(words):
    reverse_word = ''
    palindromo = ''
    for word in words:
        reverse_word = ''
        for letter in range(1, len(word) + 1):
            reverse_word += word[-letter]
        if word == reverse_word:
            if len(word) > len(palindromo):
                palindromo = word
    if palindromo:
        return palindromo
    else:
        return 
undefined