Desonte Jolivet's Blog

Euler Problems 6 To 10

2018-07-25T00:00:00+00:00

Euler problems solved using a functional Java library I created called jFunc.

Euler 06
Euler 07
Euler 08
Euler 09
Euler 10

Euler 06

The sum of the squares of the first ten natural numbers is,

12 + 22 + ... + 102 = 385

The square of the sum of the first ten natural numbers is,

(1 + 2 + ... + 10)2 = 552 = 3025

Hence the difference between the sum of the squares of the first ten natural numbers and the square of the sum is 3025 − 385 = 2640. Find the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum.

    F1<FList<Long>, Long> sqrs = F1.compose(Longs::sum, map(i -> i * i));
    F1<FList<Long>, Long> sums = F1.compose(i -> i * i, Longs::sum);
    F1<FList<Long>, Long> go   = l -> sums.call(l) - sqrs.call(l);
    return go.call(range(1, 100));

This problem is broken down into three parts: finding the sum of the squares, finding the square of the sums and finding their difference. Since there are three distinct pieces of the problem it is very natural to create three distinct functions(sqrs, sums, go).

sqrs and sums can be created by composing other functions.

F1<A,C> F1.compose(F1<B,C> f2, F1<A,B> f1) composes functions, if we observe the types closely we can see that the functions given to F1.compose are composed from right to left.

Longs::sum is a function of arity two that sums two Long values.

F1<FList<A>, FList<B>> map(F<A,B> f) takes a function from A -> B and returns a function from FList<A> -> FList<B>.

And go simply combines the two functions sqrs and sums into one neat package.

Complete Code | Answer

25164150

Euler 07

By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13. What is the 10 001st prime number?

    return Numbers.primes.get(10000);

jFunc defines an infinite list of primes, Numbers.primes. Because jFuncs list type is 0-based indexed, the number 10000 is used instead of 10001.

Complete Code | Answer

104743

Euler 08

The four adjacent digits in the 1000-digit number that have the greatest product are 9 × 9 × 8 × 9 = 5832.

73167176531330624919225119674426574742355349194934 96983520312774506326239578318016984801869478851843 85861560789112949495459501737958331952853208805511 12540698747158523863050715693290963295227443043557 66896648950445244523161731856403098711121722383113 62229893423380308135336276614282806444486645238749 30358907296290491560440772390713810515859307960866 70172427121883998797908792274921901699720888093776 65727333001053367881220235421809751254540594752243 52584907711670556013604839586446706324415722155397 53697817977846174064955149290862569321978468622482 83972241375657056057490261407972968652414535100474 82166370484403199890008895243450658541227588666881 16427171479924442928230863465674813919123162824586 17866458359124566529476545682848912883142607690042 24219022671055626321111109370544217506941658960408 07198403850962455444362981230987879927244284909188 84580156166097919133875499200524063689912560717606 05886116467109405077541002256983155200055935729725 71636269561882670428252483600823257530420752963450

Find the thirteen adjacent digits in the 1000-digit number that have the greatest product. What is the value of this product?

    F1<String,Long> go = showStr() // convert String to FList<Character>
        // Converts each Character into an Integer
      .then(fc  -> fc.map(c -> Character.getNumericValue(c)))
        // Converts each Integer to Long
      .then(fi  -> fi.map(Integer::longValue))
        // A sliding window that creates a FList<FList<Long>>
      .then(fl  -> fl.window(13))
        // Converts each FList<Long> to a product.
      .then(ffl -> ffl.map(Longs::product))
        // Find the maximum product within the FList.
      .then(f   -> f.maximum(Long::compare));

    Try<Long> digits = Try.with(() -> Euler08.class.getResource("euler08.txt").openStream())
      .bind(IO.readFileFromStream)
      .map(go);
    
    return stream.get();

If we break the problem into a series of steps we end up with:

Obtain 1000 digit String from file.
Convert String into a FList of Characters.
Convert each Character into an Integer
Convert each Integer into a Long
Convert FList to FList<FList> using a sliding window to break the FList of longs into smaller FLists of size 13
Find the product of each FList.
Find the largest Long within the FList.

The Function go is a composition of the steps from 2 to 7.

Step 1. Is accomplished with a Try. A Try is used because reading the 1000 digits from a file throws a checked Exception.

Complete Code | Answer

23514624000

Euler 09

A Pythagorean triplet is a set of three natural numbers, a < b < c, for which,

a^2 + b^2 = c^2 For example, 32 + 42 = 9 + 16 = 25 = 52. There exists exactly one Pythagorean triplet for which a + b + c = 1000. Find the product abc.

    FList<Integer> list = 
      start(1)
      .For( a        -> range(a + 1, 1000)
            // After genertating a and b, c is limited to only one possiblilty.
          ,(a, b)    -> flist(1000 - b - a)
          ,(a, b, c) -> guard(a*a + b*b == c*c)
          .semi(flist(a*b*c)));
    return list.head();

The For method sequences monadic operations and is analogous to a do-block in Haskell.

(a, b) -> flist(1000 - b - a) after genertating a and b, c is limited to only one possiblilty.

(a, b, c) -> guard(a*a + b*b == c*c) filters any value from the FList where the statement a*a + b*b == c*c is false.

Because there exits only one Pythagorean triplet where a + b + c = 1000 we only have to return the head of the generated list.

Complete Code | Answer

31875000

Euler 10

The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17. Find the sum of all the primes below two million.

    FList<Long> p = Numbers.primes
      .takeWhile(i -> i < 2000000L);
    return Longs.sum(p);

Since jFunc comes with an infinite FList of primes we only have to filter the list of all the values above 2000000, then sum the remaining values. The method takeWhile(P1<A> predicate) does the filtering and Longs.sum sums the remaining values.

Complete Code | Answer

142913828922

Jfunc

2018-06-07T00:00:00+00:00

I’m creating yet another functional java library, called jFunc. Why would I do such a thing, we already have cycylops-react and highj why would i waste my time creating another one. A better question is why not, and maybe an even better question would be why don’t we just all program in haskell. But it began by me just trying to grasp concepts in haskell and the funcitonal paradiams presented there in. This is my attempt at making useful documentation for jFunc.

Star

Fork

jFunc is a functional java library by functional I mean the libray containes data types that are immutable and lazy. Along with lots of tools to create composble operations and functions.

Persistent Data Structures
- FList
- DList
- Either
- Maybe
- Dequeue
- Stack
- Tuples
- Map
Functions
- F0-F8
- P1-P8
Trampoline
Eval
Exception Handling
- Try0-Try8
- Try
Parsing
Monads
- MaybeT
- ReaderT
- WriterT
- StateT
- TryT

Persistent Data Structures

FList

FList is immutable and Lazy, FList is analogous to a stream of values.

Becuase FList is lazy we can create infinite list of elements. The below example is an infinite lists of even numbers.

  FList<Integer> evenNumber = start(2).filter(i -> i % 2 == 0);

Below is an example of creating an infite list of prime numbers.

  public static boolean isPrime(Integer i) {
   final int sqrtOfi = (int)Math.sqrt(i);
   return allTrueWhile(primes, p -> p <= sqrtOfi
       , p -> i % p != 0);
  }

  public static FList<Integer> primes = flist(2, 3, () -> start(4).filter(Numbers::isPrime));

  print(primes.take(12)); //[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]

DList

DList also known as a difference list support constant time append, unlike FList where append is O(n) where n is the numbr of elements in the FList.

If an algorithm builds a list by appending smaller lists repeatdly then DList can greatly improve performnace.

Either

Either is paramatized by two types. Each parameter represents a possible value that the Either can hold, so a Either<L,R> can contain a value of type L (the left value) or a value of type R (the right value).

The Either type is vary useful for describing computation that can return one of two possible values, makeing it very useful for error handling.

In the below code userRead checks a if a username exists, returning a type of Either<Exception,User>. If the the user name ecautally exist then the either contains a User otherwise it contains an Exception.

  @POST
  @Path("/login")
  @Produces(MediaType.APPLICATION_JSON)
  public Response getToken(Login login) {

    EntityManger em = getEntityManager();

    Either<Exception, User> userRead =
      read(User.class, login.username)
        .runAndClose(em);

    Either<Response, Response> response =
      userRead.bimap(forbidden,validate.call(login))

    return either(response);
  }

bimap(F1<L,A> left, F1<R,B> right) maps the two given functions to the contains of the either the function the is mapped over the contnents of the eiterh depened on if the either has a left value or a right value.

forbidden and validate both return a type of Response because of this we can use either(Either<R,R> either) either return the left or right value within an either, we can use either when the left and right value are the same type. Theres no need to inspect the content of the either since we transform the left and right sie of the either into the approritea reposone.

  public static F1<Excpetion,Response> forbidden = 
    e -> Response.status(Response.Status.FORBIDDEN).entity(new ErrorResponse(e.getMessage())).build();

  public static F2<Login,User,Response> validate =
    (l,u) -> {
      String ps = u.getPassword();
      if (ps.equals(l.password)) {
        return Response.ok().entity(tokenGen(u)).build();
      } else {
        return Response.status(Response.Status.UNAUTHORIZED).build();
      }
    };

Maybe

Maybe is a control structure that repesent a value that is something or nothing. We can refactor functions that may return null with Maybe.

  public static F2<Integer, Integer, Maybe<Integer>> div = (num, den) ->  {
    if(den == 0)
      return Maybe.noting();
    else
      return Maybe.maybe(num / den);
  }

Because dividing by zero would result in an error we may return a Maybe containing nothing. We can bind and map over the returned Maybe to manipulate the possible value within the value.

  publilc static F2<Integer, Integer> double = i -> 2 * i;

  Maybe<Integer> num = div.call(4, 2);
  num.map(double); // Maybe 4

  num = div.call(4, 0);
  num.map(double); // Nothing

Tuples

Similar to FList Tuples are a sequence of values unlike FList a tuple is heterogenous and has a fixed length. jFunc’s Tuples may have a size of 2 to 8(T2, T3, T4, T5, T6, T7, T8)

Map `TODO`

Functions

F0-F8

jFunc has functional interfaces for functions from arity 0 to 8(F0, F1,F2, F3, F4, F5, F6, F7, F8). all functions can be paritablly applied.

F2<Integer, Integer, Integer> add = (i, i1) -> i + i1;

F1<Integer,Integer> add3 = add.call(3);

F1<Integer,Integer> add4 = add.call(4);

Integer seven = add3.call(0) + add4.call(0);

Integer seven$ = add.call(3,4);

//seven == seven$

P1-P8

jFunc contains functional interface for functins that speciifcally return boolean values. These interfaces are called predicates(P1, P2, P3, P4, P5, P6, P7, P8). P1 is a predicate of arity one, P2 is a pridctaice of arity two and so on.

Trampoline

  public static Trampoline<BigInteger> fib(Integer i) {
    return fib_prime(BigInteger.ZERO, BigInteger.ONE, i);
  }

  public static Trampoline<BigInteger> fib_prime(BigInteger a, BigInteger b, Integer i) {
    if(i == 0) return done(a);
    if(i == 1) return done(b);
    return fib_prime(b, a.add(b), i - 1);
  }

  public static Trampoline<BigInteger> fact(BigInteger n) {
    if(n.equals(BigInteger.ZERO))
      return done(BigInteger.ONE);
    else if(n.equals(BigInteger.ONE))
      return done(BigInteger.ONE);
    else{
      return more(() -> {
        return fact(n.add(BigInteger.ONE.negate())).map(i -> n.multiply(i));
      });
    }
  }

Eval

Eval allows the evaluation of expressions to be derfered, additionall the computed value is cached for later use.

Example To Come

Exception Handling

Try

Try0-Try8

Monads

MaybeT

Example To Come

ReaderT

Example To Come

WriterT

Example To Come

StateT

The StateT monad allows for the threading of some state through a series of functions.

/*
 * Example use of State monad
 * Passes a string of dictionary {a,b,c}
 * Game is to produce a number from the string.
 * By default the game is off, a C toggles the
 * game on and off. A 'a' gives +1 and a b gives -1.
 * E.g 
 * 'ab'    = 0
 * 'ca'    = 1
 * 'cabca' = 0
 * State = game is on or off & current score
 *       = (Boolean, Int)
 */
public static State<T2<Boolean,Integer>, Integer> playGame(FList<Character> s) {
  return CaseOf.caseOf(s)
    .of( FList::isEmpty, () -> State.<T2<Boolean,Integer>>get().bind(t -> ret(t._2())) )
    .otherwise( list -> {
      return State.<T2<Boolean,Integer>>get()
        .bind(t -> {
          boolean on = t._1();
          int score  = t._2();
          return CaseOf.caseOf(list.head())
             .of(eq('a').AND(on), () -> put( T2.t2( on, score + 1) ) )
             .of(eq('b').AND(on), () -> put( T2.t2( on, score - 1) ) )
             .of(eq('c')        , () -> put( T2.t2(!on, score    ) ) )
             .otherwise(          () -> put( T2.t2( on, score    ) ) )
             .semi(playGame(list.tail()));
        });
    });
}

public static void main(String[] args) {
  T2<Boolean,Integer> initState = T2.t2(false,0);
  Integer i = playGame(flist('c', 'a', 'b', 'c', 'a'))
              .evalState(initState);
  System.out.println(i); // 0
}

The above code snippets are translation of Haskell code found here.

ParserT `TODO`

Waypoints

2018-06-07T00:00:00+00:00

Waypoints allows you to quickly move through directories while in the terminal. This is done by allowing the user to create waypoints, waypoints are basically bookmarks. Users assgin a waypoint an alias and the alias allows you quickly move to that waypoint.

Usage

list

List all the waypoints you have created.

drjoliv@mango:~/projects/waypoints$ wp list
way-points: (total 0)

add

Add a waypoint. the supcommand add takes two arguments, the waypoint name and direcotry(wp add <NAME> <DIRECTORY>).

drjoliv@mango:~/projects/waypoints$ wp add ways .
creating way-point      ways

drjoliv@mango:~/projects/waypoints$ wp list
way-points: (total 1)
ways    /home/drjoliv/projects/waypoints

warp

Usign a waypoint. No subcommand is need to use a waypoint jsut the name of the waypoint(wp <NAME>).

drjoliv@mango:~/projects/waypoints$ cd ~/
drjoliv@mango:~$ wp ways
drjoliv@mango:~/projects/waypoints$ 

remove

Remove a way-point. The subcommand rm deletes way-points.(wp rm <NAME>)

drjoliv@mango:~/projects/waypoints$ wp rm ways
removing way-point:     ways
drjoliv@mango:~/projects/waypoints$ wp list
way-points: (total 0)
drjoliv@mango:~/projects/waypoints$ 

help

To print usage information:

wp help

Euler Problems 1 To 5

2018-05-25T00:00:00+00:00

The first five Euler problems. All the Euler problems are solved using a Java library I’m working on called jFunc, which implements many functional programming concepts.

Euler 01
Euler 02
Euler 03
Euler 04
Euler 05

Euler 01

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23. Find the sum of all the multiples of 3 or 5 below 1000.

Loops are seen throughout mathematics and computer science. The first code snippet shows the use of a plain old for loop, each iteration of the plain old for loop counter is incremented and its divisibility is checked if the number is divisble by 3 or 5 its added to the overall sum.

  int sum = 0;
  for(int i = 1; i > 1000; i++) {
    if(i % 3 == 0 || i % 5 == 0)
      sum += i;
  }

We can abstract over the idea of a loop with a list of numbers, each number in the list represents an iteration of the loop. The below code snippet uses jFunc instead of a plain old for loop. The functions range(int from, int to) creates a list of integers between from and to where from and to are inclusive. The method filter(P1<A> predicate) uses the given predicate to test each element within the list and removes elements that fail that test. The foldr(F2<B,A,B> fn, B b) reduces the list into a single value representing the sum of all the multiples of 3 and 5 below 1000. Declarative code really gets me going and is the reason I’m so interested in functional programming and like most list types in functional languages the sequential list type in jFunc is also lazy.

FList<Integer> list = range(1,999) // 
              .filter(i -> i % 3 == 0 || i % 5 == 0);
return list.foldr(Integers::add, 0);

Complete Code | Answer

233168

Euler 02

Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be: 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, … By considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms.

FList<Integer> list = FList.sequence(1,2, Integers::add) // 1, 2, 3, 5, 8, 12, 20 ...
  .filter(i -> i % 2 == 0)
  .takeWhile(i -> i < 4000000);
return list.foldr(Integers::add,0);

In many sequences, the next element in a sequence is determined by the previous elements in the sequence. sequence(A a1, A a2, F2<A, A, A> fn) follows this idea a1 and a2 are the first two elements of the sequence and fn is a function that takes the previous two elements and produces the next element. filter(P1<A> predicate) removes any Fibnoacci numbers that are not even. takeWhile(P1<A> predicate) will take elements from the list as long as the predicate is true when the predicate is false the remaining elements in the list are dropped. sequence, filter, and takeWhile all return a type of FList which allows use to create fluent and readable code. On my Intel® Core™ i5-3339Y CPU @ 1.50GHz × 4, this computes in 0.076 seconds, which is fast enough for me.

Complete Code | Answer

4613732

Euler 03

The prime factors of 13195 are 5, 7, 13 and 29. What is the largest prime factor of the number 600851475143 ?

FList<Long> primes = Numbers.primeFactors(600851475143L);
return primes.maximum(Long::compare);

jFunc inlcudes a function that returns all the prime factors of a number primeFactors(long num) and FList contains the method maximum which returns the maximum number in a list. This makes the solution a nice two liner.

Complete Code | Answer

6857

Euler 04

A palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 × 99. Find the largest palindrome made from the product of two 3-digit numbers.

I didn’t think about this too hard, I just created a function that checks if a list of values is a palindrome. With my generic function, I ignored any fancy ways to check if an integer is a palindrome and decided to just convert each integer into a list of characters then used isPalindrome to check if it was indeed a palindrome. Two things to note that are unique, first the method visit(F1<Unit, B> nil, F2<A, FList<A>, B> cons) which return a value of type B and takes two functions. visit returns the value computed by nil or cons, which computed valued returned depends on if the FList on which visit is called on is empty. If the FList is empty then the first function nil is used otherwise cons is used. The values passed to cons are the head and tail of the list visit is called on. The second interesting piece of code is caseOf(A a), which is a beefed up switch statement. The function of takes a predicated and a supplier which yields a value. When the predicated passed to of is true the computed value supplier given to of is the value returned by the CaseOf.

  public static <A> boolean isPalindrome(FList<A> chars) {
    return chars.visit(n -> true
          , (h,t) -> {
            return CaseOf.caseOf(t)
              .of(FList::isEmpty, () -> true)
              .of(sizeOf(1),      () -> h == t.head())
              .of(lastEq(h),      l  ->  isPalindrome(l.init()))
              .otherwise(() -> false);
          });
  }

The For(F1<A, ? extends Monad<FList.μ, A>>, F2<A, B, ? extends Monad<FList.μ, A>> ) method sequences monadic operations and is analogous to a do-block in Haskell. guard(boolean b) returns an empty FList if b is false and FList<Unit> otherwise.

  public static int euler04() {
    Show<Integer> s = Show.showInt(); //Show<Integer> converts an Integer into a list of Characters.
    FList<Integer> l =
      range(100, 999)
      .For(a    -> range(a, 999)
         ,(a,b) -> { 
           int p = a * b;
           return guard(isPalindrome(s.show(p))).semi(flist(p)); //semi is bind but ignores the value within the monad being binded over.
         });
    return l.maximum(Integer::compare);
  }

Complete Code | Answer

906609

Euler 05

2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder. What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20?

lcm is a function of arity two that takes two numbers and returns the least common multiple of those two numbers. lcm is a very straightforward function and the details of how to implement it can be found here. Whats more interesting about lcm is the fact that its associative and commutative, that is lcm(lcm(2,3),4) == lcm(2, lcm(3,4)) == lcm(4, lcm(2,3)) == 12. Because of this, we can simply fold over a least of numbers to find the least common multiple of all those numbers.

    return range(1L,20L).foldr(Longs::lcm,1L);

Complete Code | Answer

232792560

Desonte Jolivet's Blog

Euler Problems 6 To 10

Euler 06

Euler 07

Euler 08

Euler 09

Euler 10

Jfunc

Persistent Data Structures

Maybe

Tuples

Map TODO

Functions

F0-F8

P1-P8

Exception Handling

Try0-Try8

Monads

StateT

ParserT TODO

Waypoints

Usage

list

add

warp

remove

help

Euler Problems 1 To 5

Euler 01

Euler 02

Euler 03

Euler 04

Euler 05

Map `TODO`

ParserT `TODO`