[Find largest numeric plaindrome] codewar challenge: Largest Numberic Plain drome #algorithm #challenge #python

largest-numeric-plaindrome.py

from operator import mul
from functools import reduce
from itertools import combinations

def all_combinations_from(arr, start=2):
  result = list()
  for i in range(start, len(arr) + 1):
    for t in combinations(arr, i):
      result.append(reduce(mul, t))
  print('combinations result: ', result)
  return result

def numeric_palindrome(*args):
    sorted_numbers = sorted(args, key=lambda x: -x)
    prods = all_combinations_from(sorted_numbers)
    prods_digits = map(lambda prod: sorted(list(str(prod))), prods)
    # print('prods digits: ',list (prods_digits))
    plaindromes = list()
    for prod_digits in prods_digits:
      plaindrome = list()
      while True:
        if not len(prod_digits): break
        if len(prod_digits) == 1 and len(plaindrome) % 2 == 1: break
        if len(prod_digits) == 1 and len(plaindrome) % 2 == 0:
          plaindrome = plaindrome[:int(len(plaindrome) / 2)] + prod_digits + plaindrome[int(len(plaindrome) / 2):]
          break
        last_1, last_2 = prod_digits.pop(), prod_digits.pop()
        if last_1 != last_2:
          prod_digits.append(last_2)
          cur_len = len(plaindrome)
          if cur_len % 2 == 0:
            plaindrome = plaindrome[:int(cur_len / 2)] + [last_1] + plaindrome[int(cur_len / 2):]
        elif last_1 == '0' and len(plaindrome) > 2 or last_1 != '0':
          cur_len = len(plaindrome)
          mid = int(cur_len / 2)
          left, mid, right = plaindrome[:mid], [] if cur_len % 2 == 0 else plaindrome[mid:mid+1], plaindrome[mid + cur_len % 2:]
          plaindrome = left + [last_1] + mid + [last_2] + right
      plaindromes.append(plaindrome)
    sorted_plaindromes_by_len = sorted(plaindromes, key=lambda x: -len(x))
    longest_plaindromes = list(filter(lambda x: len(x) == len(sorted_plaindromes_by_len[0]), sorted_plaindromes_by_len))
    biggest_plaindrome = sorted(longest_plaindromes, key=lambda x: -int(x[0]))[0]
    return int(''.join(biggest_plaindrome))