The Problem – Euler Problem 5

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?

My Solution

Initially I had a couple of thoughts. The raw solution would be to have a for loop, simply test the remainder of the division from 1 to 20.. until the right number was found. This could be coded long handed with numerous indented if… statements for each of the numbers 1..20. Then a while loop would have presented a better way of avoiding the nested loops. If the counter got to 0 for the while loop, then I’d found my number.

My next consideration was to think about what numbers wouldn’t need to be tested if bigger numbers succeeded, e.g anything divisible by 20 would also be divisible by 2 etc… This led me to a path to stop my calculations when hitting 8 as the counter.

Finally, the for loop didn’t need to go through all the numbers. It could start at 20, and then increment by 20 every time.

To test any efficiency gains, rather than using the default output from NetBeans I also logged the in milliseconds before starting and upon completion. Interestingly (and I can’t explain why), I took slightly longer to stop dividing at 8 rather than just continue through checking the lower numbers. When I say slower, only by 1 millisecond or so.

And so my final solution is as below, and takes approximately 70 milliseconds to complete.

boolean found = false;
int sum = 0;

for (int i = 20; !found; i = i + 20) {
   int starting = 19;
   boolean breakOut = false;

   while (!found && !breakOut) {
      if ((i % starting) == 0) {
         starting--;

         if (starting == 0) {
            sum = i;
            found = true;
         }
      } else {
         breakOut = true;
      }
   }
}

Again, I didn’t think the following solution would be very quick or efficient, but decided to go with the coding principle of make it work, make it pretty, make it fast. Java though completed the task in approximately 0 seconds according to NetBeans, so I was able to skip the make it fast step for the time being.

Update: Whilst typing out this post a slightly more efficient way to do things would be to only read in the next number from the string and overwrite the oldest – some kind of LIFO queue or list. It wouldn’t be difficult to implement, but having been out of the office yesterday, think I need to divert my attention elsewhere for a while.

Solution:

        int index = 5;
        int max = 0;

        for (int i = 0; i < inputNumber.length() - index; i++) {
             String sub = inputNumber.substring(i, i + index);
             int j = Integer.parseInt(sub.substring(0, 1));
             int k = Integer.parseInt(sub.substring(1, 2));
             int l = Integer.parseInt(sub.substring(2, 3));
             int m = Integer.parseInt(sub.substring(3, 4));
             int n = Integer.parseInt(sub.substring(4, 5));
             int sum = j * k * l * m * n;

             if (sum > max) {
                max = sum;
             }
        }

     System.out.println("Max = " + max);

I chose Problem 4 this week, @am_doherty will choose the problem next week.

Euler Problem 4

int max = 0;
int param1 = 0;
int param2 = 0;
int jMin = 99;

for (int i = 999; i > 99; i--) {
  for (int j = 999; j > jMin; j--) {
    String result = Integer.toString(i * j);
    String reversed = reverseStr(result);

    if (result.equals(reversed)) {
      if (i * j > max) {
        param1 = i;
        param2 = j;
        jMin = j;
        max = i * j;
        break;
      }
    }
  }
}

System.out.println("param1 = " + param1 + ", param2 = " + param2 + ", max = " + max);

public static String reverseStr(String orgStr) {
  StringBuilder reverseStr = new StringBuilder();
  for (int i = orgStr.length(); i > 0; i--) {
    reverseStr.append(orgStr.charAt(i - 1));
  }

  return reverseStr.toString();
}

Euler Problem 3

The prime factors of 13195 are 5, 7, 13 and 29.

What is the largest prime factor of the number 600851475143 ?

Solution / Thoughts

My 1st thought which I knew would clearly take far too long was to loop from i = 3 to 600851475143. This posed 2 problems – (a) looping for that long would take forever, and also (b) the largest prime factor was likely to be found long before the large number involved. Another thought was to loop backwards, but again this wouldn’t overcome reason (b).

The loop was speeded up slightly by incrementing by 2 rather than the traditional 1 in a for…loop, but that really didn’t do anything to overcome the problems already identified.

My way of solving it still relied on the loop thought, but worked with the idea of finding the correlating value for the earlier successful divisions. So my final implementation was:

        long number = 600851475143L;
        
        for (long i = 3; i < number; i = i + 2) {
            if ((number % i) == 0) {
                long temp = number / i;
                if (isPrime(temp)) {
                    System.out.println(temp);
                    break;
                }
            }
        }

* There are plenty of isPrime() sample methods available on the Internet.

Answer: 6857

Euler Problem 2

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.

Solution

int prev = 1;
        int now = 2;
        int temp = 0;
        int total = 0;
        
        while (prev < 4000000) {
            if ((now % 2) == 0) {
                total += now;
            }
            
            temp = now + prev;
            prev = now;
            now = temp;
        }
        
        System.out.println(“Total: ” + total);

Answer: 4613732

Scanning through my Twitter stream over the Christmas break I came across an article about Euler Programming site, which provides puzzles to be solved. I’ve decided to start doing these, attempting to do at least 1 a day to try and re-activate my mind. The 1-a-day routine isn’t really succeeding at this stage though – I’ve just solved Problem 3, and this is the 10th day of January. Ah well.

I’ll attempt to post my solution to each problem, in the hope that if I’ve gone wrong, or there is a better way someone might point me in the right direction. All solutions will be done in Java.

Euler Problem 1

After considering various solutions, we’re currently monitor one implementation that appears to have promising indications at the moment for being a permanent solution (although perhaps a little early to be certain).

The solution appears to be to use the ‘Connection Validation’ properties under the Advanced Tab. We’re currently enabled to perform a select before the actual query attempted to run (and we’ve nominated the DUAL table for the select to be carried out on). If this fails, then that connection is dropped from the pool, and the next available connection is sourced. If all available connections fail, then fresh connections are made within the pool.

There appears to be an omission for RAC failover support in the Oracle-Thin library, hence the requirement for using this setting.

Further reading:

http://alexandru-ersenie.com/tag/glassfish/
http://old.nabble.com/how-do-I-avoid-a-connection-pool-filling-up–td21432580.html

http://docs.oracle.com/cd/E18930_01/html/821-2431/abehp.html

From some reading around it turns out having a mixture of CLOBs and varchar2(4000) fields in a database causes some issues for Oracle, especially during an insert. To overcome this the CLOB(s) must be the last parameters inserted in the SQL statement.

Unfortunately we use TopLink/JPA and so aren’t in control of our query structure.

Solution 1

Alter all varchar2(4000) to be CLOBs. In order to do this you’d need to run the following queries:

alter table <table> add <field>_copy varchar2(4000)
update <table> set <field>_copy = <field>
update <table> set <field> = null
commit</div>
alter table <table> modify <field> long
alter table <table> modify <field> clob
update <table> set <field> = <field>_copy
alter table <table> drop column <field>_copy
commit

After doing this I encountered an issue with the index link to this table not being correct. To resolve this issue:

alter index <index> rebuild

Solution 2

Run the query as normal and omit the setting of the CLOB(s) field.
After persisting the original query, lookup the bean and update the CLOBs fields before persisting again.

References

Ask Tom – Change a Column varchar2 to CLOB
Indexes Left in an Unstable State

So yesterday I returned to the issue. Having listened to This Developers Life podcast about the downtime at StackOverflow I decided StackOverflow was a resource I was aware of, but had never really used (other than via the occasional Google result). I searched StackOverflow for information on Java Message Queuing, and go directed towards OpenMQ.

Heading back to Google I found a couple of useful articles about using OpenMQ and from the contents of both managed to get myself sending messages to a local GlassFish instance. However, I’m fairly certain I’d be able to alter this code slightly to send to a remote machine – just something I don’t currently have the capabilities (or the pressing need) to confirm.

As per most of my posts, this is primarily for my own reference when I need to return to it at some point in the future – but it may prove of use to others.

The two resources of particular use were: http://kalali.me/openmq-the-open-source-message-queuing-for-beginners-and-professionals-openmq-from-a-to-z/ and http://mq.java.net/mqmonitor/mqmonitor.html

The actual code that worked for sending a message for me was:

public static void main(String[] args) throws JMSException {
   com.sun.messaging.ConnectionFactory connectionFactory = new com.sun.messaging.ConnectionFactory();
   connectionFactory.setProperty(com.sun.messaging.ConnectionConfiguration.imqAddressList,
                                 "mq://127.0.0.1:7676");
   javax.jms.QueueConnection queueConnection = connectionFactory.createQueueConnection("xxx", "xxx");
   javax.jms.QueueSession queueSession = queueConnection.createQueueSession(false,
                                 Session.AUTO_ACKNOWLEDGE);
   javax.jms.Queue smsQueue = queueSession.createQueue("gbTestQueue");
   javax.jms.MessageProducer producer = queueSession.createSender(smsQueue);
   Message msg = queueSession.createTextMessage("A sample sms message");
   producer.send(msg);
}

So after overcoming my fears, I needed to quickly see if I could generate some data for testing. We repeat this numerous times at work when nearing a release date and it becomes quite an arduous and time consuming process. The longest and hardest part of getting Selenium going was downloading the Firefox plugin and trying to figure out why it wasn’t running it automatically, before remembering I’ve recently switched to using Google Chrome as my default browser.

2 minutes later I had my first test script running and creating the data I was after, adding in the various tests along the way to indicate everything was going as expected.

Whilst this is fine, the bit I’m really looking forward to experimenting with the language export stuff to Selenium RC. This really will open some doors at work and hopefully really speed up some time consuming processes. I’m hoping we can take it a stage further by putting a GUI on the front to specify some of the values we’re interested in using.

So much like JMeter a few months ago, I really do need to start investigating more of these tools that I hear about from various day-to-day reading materials. They really will free up time in the long run.