Project Euler #211 - efficiency issue
I've been slowly working my way through the list of Project Euler problems, and I've come to one that I know how to solve, but it seems like I can't (given the way my solution was written).

I am using Common Lisp to do this with and my script has been running for over 24 hours (well over their one minute goal).

For the sake of conciseness, here's my solution (it's a spoiler, but only if you have one hell of a fast processor):

    (defun square? (num)
      (if (integerp (sqrt num)) T))
    
    (defun factors (num)
      (let ((l '()))
        (do ((current 1 (1+ current)))
            ((> current (/ num current)))
          (if (= 0 (mod num current))
              (if (= current (/ num current))
                  (setf l (append l (list current)))
                  (setf l (append l (list current (/ num current)))))))
        (sort l #'< )))
    
    (defun o_2 (n)
      (reduce #'+ (mapcar (lambda (x) (* x x)) (factors n))))
    
    (defun sum-divisor-squares (limit)
      (loop for i from 1 to limit when (square? (o_2 i)) summing i))
    
    (defun euler-211 ()
     (sum-divisor-squares 64000000))

The time required to solve the problem using smaller, more friendly, test arguments seems to grow larger than exponentialy... which is a real problem.

It took:

  - 0.007 seconds to solve for 100
  - 0.107 seconds to solve for 1000
  - 2.020 seconds to solve for 10000
  - 56.61 seconds to solve for 100000
  - 1835.385 seconds to solve for 1000000
  - 24+ hours to solve for 64000000

I'm really trying to figure out which part(s) of the script is causing it to take so long. I've put some thought into memoizing the factors function, but I'm at a loss as to how to actually implement that.

Any ideas on how to make this thing go faster would be greatly appreciated.

**sorry if this is a spoiler to anyone, it's not meant to be.... but if you have the computing power to run this in a decent amount of time, more power to you.
Project Euler #211 - efficiency issue
===

I've been slowly working my way through the list of Project Euler problems, and I've come to one that I know how to solve, but it seems like I can't (given the way my solution was written).

I am using Common Lisp to do this with and my script has been running for over 24 hours (well over their one minute goal).

For the sake of conciseness, here's my solution (it's a spoiler, but only if you have one hell of a fast processor):

    (defun square? (num)
      (if (integerp (sqrt num)) T))
    
    (defun factors (num)
      (let ((l '()))
        (do ((current 1 (1+ current)))
            ((> current (/ num current)))
          (if (= 0 (mod num current))
              (if (= current (/ num current))
                  (setf l (append l (list current)))
                  (setf l (append l (list current (/ num current)))))))
        (sort l #'< )))
    
    (defun o_2 (n)
      (reduce #'+ (mapcar (lambda (x) (* x x)) (factors n))))
    
    (defun sum-divisor-squares (limit)
      (loop for i from 1 to limit when (square? (o_2 i)) summing i))
    
    (defun euler-211 ()
     (sum-divisor-squares 64000000))

The time required to solve the problem using smaller, more friendly, test arguments seems to grow larger than exponentialy... which is a real problem.

It took:

  - 0.007 seconds to solve for 100
  - 0.107 seconds to solve for 1000
  - 2.020 seconds to solve for 10000
  - 56.61 seconds to solve for 100000
  - 1835.385 seconds to solve for 1000000
  - 24+ hours to solve for 64000000

I'm really trying to figure out which part(s) of the script is causing it to take so long. I've put some thought into memoizing the factors function, but I'm at a loss as to how to actually implement that.

Any ideas on how to make this thing go faster would be greatly appreciated.

**sorry if this is a spoiler to anyone, it's not meant to be.... but if you have the computing power to run this in a decent amount of time, more power to you.