module Main where
 
main :: IO ()
main = do
       let x = [1..100]
       let sum2 = sum $ map (^2) x
       let sum1 = (sum x) ^2
       print (sum1 - sum2)

#!/usr/bin/python3
"""Project Euler solution using generators."""
 
sum1 = 0
sum2 = 0
 
for i in ((x,x ** 2) for x in range(1,100+1)):
    sum1 += i[0]
    sum2 += i[-1]
 
print(sum1 ** 2 - sum2)

#!/usr/bin/perl
 
my $sum1 = 0;
my $sum2 = 0;
 
for (1..100)
{
  $sum1 += $_;
  $sum2 += $_ **2;
}
 
print ($sum1 **2 - $sum2);

public class problem6
{
    public static void main( String[] args)
    {
      int sum1 = 0;
      int sum2 = 0;
 
      for( int i = 0; i < 100; i++)
      {
        sum1 += i;
        sum2 += i ^ 2;
      }
 
      System.out.println(sum1 ^ 2 - sum2);
    }
}

module Main where
 
import Data.List
 
divisible_11_to_20 number = 10 == (length $ unfoldr(\x -> if (snd $ quotRem number x) /= 0 || x < 11
  then Nothing
  else Just(x,x - 1)) 20)
 
-- solved this by the help on this URL:
-- (http)basildoncoder.com/blog/2008/06/10/project-euler-problem-5/
-- by increaing the loop from 2 to 2520, problem solves in seconds
main :: IO ()
main = print $ until (divisible_11_to_20) (+2520) 2520

#!/usr/bin/python
 
def div_11_to_20(divided):
  return all([not bool(divided % x) for x in xrange(11,20+1)])
 
if __name__ == "__main__":
  count = 2520
  while div_11_to_20(count) == False:
    count += 2520
 
  print "%s" % count

#!/usr/bin/perl
 
sub divide_11_to_20
{
  my ( $divided ) = @_;
 
  foreach (11..20)
  {
     return 0 if ($divided % $_);
  }
 
  return 1;
}
 
my $main_count = 2520;
while ( !divide_11_to_20($main_count) )
{
	$main_count += 2520;
}
 
print $main_count;

module Main where
 
import Data.List
 
--Stole numberToList code from:
--http://www.rhinocerus.net/forum/lang-functional/95473-converting-number-list-haskell.html
numberToList = reverse . unfoldr (\x -> if x == 0 then Nothing else let (a,b) = x `quotRem` 10 in Just (b,a))
 
is_palimdrome number = num_list == reverse num_list
  where
    num_list = numberToList number
 
main :: IO ()
main = print . maximum . filter is_palimdrome $ zipWith (*) y z
  where y = [1000,999..100]
        z = [1000,999..100]

#!/usr/bin/python
 
def int_to_list(number):
  return map(int, str(number))
 
def is_palindrome(number):
  local_list = int_to_list(number)
  return local_list == list(reversed(local_list))
 
if __name__ == "__main__":
  second_list = first_list = list(reversed(range(100,1000+1)))
  prod_set = map(lambda i,j: i*j, first_list, second_list)
 
  print "%s" % max(filter(is_palindrome,prod_set))

#!/usr/bin/perl
 
use strict;
use warnings;
use List::MoreUtils qw(pairwise);
 
sub is_palimdrone
{
  my ($number) = @_;
 
  my @digits = split(//, $number);
  my @reversed_digits = reverse(@digits);
 
  for (my $i = 0; $i < @digits; $i++)
  {
    return 0 if $digits[$i] != $reversed_digits[$i];
  }
 
  return 1;
}
 
my @two = my @one = reverse((1..1000));
 
my @join = pairwise { $a * $b } @one, @two;
 
foreach(@join)
{
  if ( is_palimdrone($_))
  {
    print "$_\n";
    last;
  }
}

module Main where
 
import Data.List
 
--Stole numberToList code from:
--http://www.rhinocerus.net/forum/lang-functional/95473-converting-number-list-haskell.html
numberToList = reverse . unfoldr (\x -> if x == 0 then Nothing else let (a,b) = x `quotRem` 10 in Just (b,a))
 
is_palimdrome number = num_list == reverse num_list
  where
    num_list = numberToList number
 
main :: IO ()
main = print . maximum $ [ x * y | x <- nums, y <- nums, is_palimdrome (x * y)] 
  where nums = [1000,999..100]

#!/usr/bin/python
 
def int_to_list(number):
  return map(int, str(number))
 
def is_palindrome(number):
  local_list = int_to_list(number)
  return local_list == list(reversed(local_list))
 
if __name__ == "__main__":
  print "%s" % max([x * y for x in range(1000,100, -1) \
                          for  y  in range(1000,100,-1) \
                          if is_palindrome(x * y)])

#!/usr/bin/perl
 
use strict;
use warnings;
use List::Util qw(max);
 
sub is_palimdrone
{
  my ($number) = @_;
 
  my @digits = split(//, $number);
  my @reversed_digits = reverse(@digits);
 
  for (my $i = 0; $i < @digits; $i++)
  {
    return 0 if $digits[$i] != $reversed_digits[$i];
  }
 
  return 1;
}
 
my @two = my @one = reverse((100..999));
my @three;
 
for my $one (@one)
{
  for my $two (@two)
  {
    my $three = $two * $one;
    next unless is_palimdrone($three);
    push @three, $three;
  }
}
 
print max(@three);

module Main where
 
factors count top_number
  | count >= top_number = []
  | zero_mod count = count : new_top: factors (count + 2) new_top
  | otherwise = factors (count + 2) top_number
  where new_top = round . fromIntegral $ top_number `div` count
 
zero_mod divisor
  | divide == 0 = True 
  | otherwise = False
  where divide = mod 600851475143 divisor
 
--prime :: Integer -> Integral -> Bool
prime divisor divided
  | divided == 1 = True
  | divisor >= sqrt_divided = True
  | mod divided divisor == 0 = False
  | otherwise = next_prime
  where next_prime = prime (divisor + 2) divided
        sqrt_divided = round . sqrt . fromIntegral $ divided
 
is_prime :: Integer -> Bool
is_prime input = prime 3 input
 
main :: IO ()
main = do
       let x = factors 3 600851475143
       let y = map is_prime x
       putStrLn $ show $ snd $  maximum ( zip y x)

#!/usr/bin/python
 
import math
 
top_number = 600851475143
 
def zero_mod(divisor):
  if top_number % divisor == 0:
    return True
  else:
    return False
 
def is_prime(divided):
  divisor = 3
  sqrt_divided = math.sqrt(divided)
  if divided == 1:
    return True
  else:
    while divisor <= sqrt_divided:
      if divided == divisor:
        return True
      elif divided % divisor == 0:
        return False
      else:
        divisor += 2
    return True
 
def main():
  count = 3
  go_to = top_number
 
  first_list =[]
 
  while count <= go_to:
    if zero_mod(count):
      first_list.append(count)
      go_to = top_number / count
      first_list.append(go_to)
 
    count += 2
 
  second_list = map(is_prime, first_list)
  print "%s" % max(zip(second_list, first_list))[-1] 
 
 
if __name__ == "__main__":
  main()

#!/usr/bin/perl
 
use strict;
use warnings;
 
my $top_number = 600851475143;
 
sub is_prime
{
  my ($divided) = @_;
  return 1 if ($divided == 1);
 
  my $divisor = 3;
  my $sqrt_divided = sqrt($divided);
 
  while($divisor <= $sqrt_divided)
  {
    return 0 unless ($divided % $divisor);
    $divisor += 2;
  }
 
  1;
}
 
my @f;
my $new_top = $top_number;
 
for(my $i = 3; $i <= $new_top; $i += 2)
{
  unless ($top_number % $i)
  {
    if (is_prime($i))
    {
      push @f, $i;
    }
  }
    $new_top = $top_number / $i;
}
 
print $f[-1];