Project Euler #4 - Largest Palindrome Product

def palindrome_number():
    _range = xrange(100, 1000)
    palindrome = None
    for i in _range:
        for j in _range:
            prod = i * j
            if str(prod) == str(prod)[::-1]:
                if prod > palindrome:
                    palindrome = prod
    return palindrome

print(palindrome_number())

function reverseInteger(n: number): number {
  return Number(String(n).split('').reverse().join(''));
}

function isPalindrome(num: number): boolean {
  if (num === reverseInteger(num)) {
    return true;
  }
  return false;
}

// I had this in separate files sorry if its confusing X)
import { max } from 'mathjs';

let number = 0;
let a = 999;

const palindromes: number[] = [];

while (a > 1) {
  for (let i = 2; i <= 999; i += 1) {
    number = a * i;
    if (isPalindrome(number)) {
      palindromes.push(number);
    }
  }
  a -= 1;
}
console.log(`Max palindrome ${max(...palindromes)}`);

function isPalindrome(num) {
  const stringifiedNum = num.toString();

  return (
    Array.from(stringifiedNum).toString() ===
    Array.from(stringifiedNum)
      .reverse()
      .toString()
  );
}

function findLargestPalindrome() {
  const start = 100;
  const end = 999;

  let largestPalindrome = 0;

  for (let i = start; i <= end; i += 1) {
    for (let j = start; j <= end; j += 1) {
      const product = i * j;
      if (isPalindrome(product) && product > largestPalindrome) {
        largestPalindrome = product;
      }
    }
  }

  return largestPalindrome;
}

findLargestPalindrome();

#include <stdio.h>
#include <stdlib.h>

int palindrome(long x)
{
    int i,j=0;
    char ch[7];
    sprintf(ch,"%ld",x);

    char ch1[7]="";
    for(i=strlen(ch)-1;i>=0;i--,j++)
    {
        ch1[j]=ch[i];
    }

    if(strcmp(ch,ch1)==0)
        return 1;
    return 0;
}


int main()
{
    int i,j;
    long s,max=100*100;
    for(i=100;i<=999;i++)
    {
        for(j=100;j<=999;j++)
        {
            s=i*j;
            if (palindrome(s) && s>max)
                max=s;
        }
    }
    printf("Result = %ld",max);
}

fn main() {
    let max = max_palindrome();
    println!("Max palindrome is {}, product of {} * {}", max.1, (max.0).0, (max.0).1);
}

fn max_palindrome() -> ((i32, i32), i32) {
    let range = 100..1000;
    let mut ans = ((0, 0), 0);
    for a in range.clone() {
        for b in range.clone() {
            let p = a * b;
            if is_palindrome(p) && p > ans.1 {
                ans.1 = p;
                ans.0 = (a ,b);
            }
        }
    }
    ans
}

fn is_palindrome(num: i32) -> bool {
    let str_num = num.to_string();
    str_num
        .chars()
        .zip(str_num.chars().rev())
        .all(|(c1, c2)| c1 == c2)
}

const array = new Array(900).fill(0).map((e, i) => i + 100);

const isPalindrome = num => {
  return (
    String(num) ===
    String(num)
      .split("")
      .reverse()
      .join("")
  );
};

const maxProduct = range => {
  let palindrome = 0;
  for (let i = 0; i < range.length; i++) {
    for (let j = i + 1; j < range.length; j++) {
      const product = array[i] * array[j];
      if (isPalindrome(product) && product > palindrome) {
        palindrome = product;
      }
    }
  }

  return palindrome;
};

console.log(maxProduct(array));

$largestThreeDig = 999;
$largestPalindrome = 0;
for($l = $largestThreeDig; $l > 0 && $l * $largestThreeDig > $largestPalindrome; $l--) {
    for($p = $l * $largestThreeDig; $p > $largestPalindrome; $p -= $l) {
        if((string)$p === strrev((string)$p)) {
            $largestPalindrome = $p;
        }
    }
}
 echo "Largest Palindrome: $largestPalindrome\n";

# Find the largest palindrome number that is the product of two three digit factors.

def check_equality(num)
  num.to_s == num.to_s.reverse
end


def find_palindrome
  r1 = (999..1)
  r2 = r1

  (r1.first).downto(r1.last).each do |i|
    (r2.first).downto(r2.last).each do |j|
      if check_equality( i * j )
        puts "#{i} * #{j} = #{i*j}"
        return
      end
    end
  end
end


find_palindrome

const digits = 3;
const upper = 10 ** digits - 1;   // 999
const lower = 10 ** (digits - 1); // 100
function palindromize(num) {
  const padded = String(num).padStart(digits,'0');
  return +(padded + padded .split('').reverse().join(''));
}

let p, b;
out: for (let a = upper; a >= lower; a--) {
  p = palindromize(a);
  for (b = Math.floor(p ** .5); p/b <= upper; b--) {
    if (p % b === 0) break out;
  }
}
console.log(p / b, b);

public class Problem4 {
    public static boolean isPalindrome(long val) {
            boolean isPalindrome = true;
            String str = Long.toString(val);
            int len = str.length();
            int i = 0;
            while (isPalindrome && i <= (len-1)/2){
                isPalindrome = str.charAt(i) == str.charAt(len-1-i);
                i++;
            }
            return isPalindrome;
        }

        public static void main(String[] args) {
            int i = 999;
            long largest = 1;
            String str = "";
            long val = 1;
        while (i>=100)
        {
            int j = i;
            while (j>=100)
            {
                val = i * j;
                if(isPalindrome(val) && largest < val)
                {
                    largest = val;
                    str = i + " x " + j;
                }
                isPalindrome (val);
                j--;
            }
            i--;
        }
        System.out.println(str+ "= "+ largest);

    }
}

auto larget_palindrome_product(size_t n_digits) -> size_t {

    const auto is_palidrome = [](size_t x) -> bool {
        const auto as_string = std::to_string(x);
        auto fst = as_string.begin();
        auto lst = as_string.rbegin();
        for (; fst != as_string.end(); fst++, lst++)
            if (*fst != *lst) return false;
        return true;
    };

    size_t result = 0;
    const auto lower_bound = std::pow(10, n_digits - 1);
    const auto upper_bound = std::pow(10, n_digits) - 1;

    for (size_t fst = lower_bound; fst <= upper_bound; fst++) {
        for (size_t snd = fst; snd <= upper_bound; snd++) {
            if (auto n = fst * snd;
                is_palidrome(n) && n > result) {
                result = fst * snd;
            }
        }
    }

    return result;
}