Encuentra el mayor palíndromo

.
.

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

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