Oops... (still learning, Thanks Robby) ... New results run under Racket.exe:<div><br></div><div><div style><div><div>(define (pythagorean-triple n)</div><div class="im" style="color:rgb(80,0,80)"><div>  (let loop-ab ([a 1] [b 2])</div>
<div>    (define c (- n a b))</div></div><div>    (cond [(right-triangle? a b c) (list a b c)]</div><div>          [(&gt;= a (ceiling (/ n 3))) &#39;()]</div><div class="im" style="color:rgb(80,0,80)"><div>          [(&lt;= c b) (loop-ab (add1 a) (+ a 2))]</div>
</div><div class="im" style="color:rgb(80,0,80)"><div>          [else (loop-ab a (add1 b))])))</div></div></div><div><br></div><div>Ave cpu time = 0.46 seconds  </div><div><br></div><div>(define (pythagorean-triple2 n)</div>
<div class="im" style="color:rgb(80,0,80)"><div>  (for*/first ([a (in-range 1 (ceiling (/ n 3)))]</div><div>               [b (in-range (add1 a) (ceiling (/ (- n a) 2)))]</div><div>               [c (in-value (- n a b))]</div>
<div>               #:when (and (&lt; b c)</div><div>                           (right-triangle? a b c)))</div><div>    (list a b c)))</div><div><br></div></div><div>Ave cpu time = 0.69 seconds</div><div><br></div><div>(define (pythagorean-triple4 n)<br>
</div></div><div style><div>  (for*/or ([a (in-range 1 (ceiling (/ n 3)))]</div><div>            [b (in-range (add1 a) (ceiling (/ (- n a) 2)))])</div><div class="im" style="color:rgb(80,0,80)"><div>    (define c (- n a b))</div>
</div><div class="im" style="color:rgb(80,0,80)"><div>    (and (right-triangle? a b c) (list a b c))))</div></div></div><div style><br></div><div style>Ave cpu time = 0.46 seconds</div><div style><br></div><div style>Notes:</div>
<div style> - pre-defining a-limit didn&#39;t help any algorithm</div><div style> - trying to further limit b slowed down the first algorithm a small amount</div><div style> - DrRacket does add quite a bit of overhead</div>
<div style><br></div><div style>-Joe</div><br><div class="gmail_quote">On Mon, Mar 19, 2012 at 11:39 AM, Robby Findler <span dir="ltr">&lt;<a href="mailto:robby@eecs.northwestern.edu">robby@eecs.northwestern.edu</a>&gt;</span> wrote:<br>
<blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">Apologies if this is old news, but if you&#39;re running timing tests, be<br>
sure to run them in &#39;racket&#39;, from a command-line, not in DrRacket.<br>
DrRacket is doing lots of stuff at the same time as running your<br>
program that can make measurements significantly less accurate.<br>
<br>
Robby<br>
<div><div class="h5"><br>
On Mon, Mar 19, 2012 at 1:34 PM, Joe Gilray &lt;<a href="mailto:jgilray@gmail.com">jgilray@gmail.com</a>&gt; wrote:<br>
&gt; Hi again Rodolfo,<br>
&gt;<br>
&gt; After a some mods, I ran several trials with n = 10000 on my ancient laptop<br>
&gt; and got the following results:<br>
&gt;<br>
&gt; (define (pythagorean-triple n)<br>
&gt;   (define a-limit (ceiling (/ n 3)))<br>
&gt;   (let loop-ab ([a 1] [b 2])<br>
&gt;     (define c (- n a b))<br>
&gt;     (cond [(right-triangle? a b c) (list a b c)]<br>
&gt;           [(&gt;= a a-limit) &#39;()]<br>
&gt;           [(&lt;= c b) (loop-ab (add1 a) (+ a 2))]<br>
&gt;           [else (loop-ab a (add1 b))])))<br>
&gt;<br>
&gt; Ave cpu time = 3.90 seconds  (note that trying to limit b slowed down the<br>
&gt; performance considerably, but pre-defining a-limit helped a little compared<br>
&gt; to not limiting a at all)<br>
&gt;<br>
&gt; (define (pythagorean-triple2 n)<br>
&gt;   (for*/first ([a (in-range 1 (ceiling (/ n 3)))]<br>
&gt;                [b (in-range (add1 a) (ceiling (/ (- n a) 2)))]<br>
&gt;                [c (in-value (- n a b))]<br>
&gt;                #:when (and (&lt; b c)<br>
&gt;                            (right-triangle? a b c)))<br>
&gt;     (list a b c)))<br>
&gt;<br>
&gt; Ave cpu time = 5.25 seconds (pre-defining a-limit didn&#39;t improve performance<br>
&gt; like it did above)<br>
&gt;<br>
&gt; (define (pythagorean-triple3 n)<br>
&gt;   (for*/or ([a (in-range 1 n)]<br>
&gt;             [b (in-range a n)]<br>
&gt;             #:when (&lt; (* 2 b) (- n a)))<br>
&gt;     (define c (- n a b))<br>
&gt;     (and (right-triangle? a b c) (list a b c))))<br>
&gt;<br>
&gt; Ave cpu time = 4.90 seconds<br>
&gt;<br>
&gt; (define (pythagorean-triple4 n)<br>
&gt;   (for*/or ([a (in-range 1 (ceiling (/ n 3)))]<br>
&gt;             [b (in-range (add1 a) (ceiling (/ (- n a) 2)))])<br>
&gt;     (define c (- n a b))<br>
&gt;     (and (right-triangle? a b c) (list a b c))))<br>
&gt;<br>
&gt; Ave cpu time = 2.50 seconds (!!, note that pre-defining a-limit didn&#39;t<br>
&gt; improve performance here either)<br>
&gt;<br>
&gt; I&#39;m learning a lot from these examples.  I&#39;d love to see other idioms as<br>
&gt; well.<br>
&gt;<br>
&gt; Thanks,<br>
&gt; -Joe<br>
&gt;<br>
&gt; On Mon, Mar 19, 2012 at 12:44 AM, Rodolfo Carvalho &lt;<a href="mailto:rhcarvalho@gmail.com">rhcarvalho@gmail.com</a>&gt;<br>
&gt; wrote:<br>
&gt;&gt;<br>
&gt;&gt; On Mon, Mar 19, 2012 at 04:35, Joe Gilray &lt;<a href="mailto:jgilray@gmail.com">jgilray@gmail.com</a>&gt; wrote:<br>
&gt;&gt;&gt;<br>
&gt;&gt;&gt; Thanks Rodolfo and Eli for the education, very elegant solutions.<br>
&gt;&gt;&gt;<br>
&gt;&gt;&gt; I really like the clever use of the &quot;(and (right-triangle? a b c) (list a<br>
&gt;&gt;&gt; b c))))&quot; idiom.<br>
&gt;&gt;&gt;<br>
&gt;&gt;&gt; I had to look up in-value... unfortunately the manual is a bit sparse<br>
&gt;&gt;&gt; there, but I got the gift by running some examples... thanks.<br>
&gt;&gt;&gt;<br>
&gt;&gt;&gt; After going &quot;D&#39;oh&quot; about the infinite loop, here is the code I ended up<br>
&gt;&gt;&gt; with:<br>
&gt;&gt;&gt;<br>
&gt;&gt;&gt; (define (pythagorean-triple n)<br>
&gt;&gt;&gt;   (let loop-ab ([a 1] [b 2])<br>
&gt;&gt;&gt;     (define c (- n a b))<br>
&gt;&gt;&gt;     (cond [(&gt;= a n) &#39;()]<br>
&gt;&gt;&gt;           [(&lt;= c b) (loop-ab (add1 a) (+ a 2))]<br>
&gt;&gt;&gt;           [(right-triangle? a b c) (list a b c)]<br>
&gt;&gt;&gt;           [else (loop-ab a (add1 b))])))<br>
&gt;&gt;&gt;<br>
&gt;&gt;&gt; I noticed that the sequence-based solutions are quite a bit slower than<br>
&gt;&gt;&gt; the code above probably because they don&#39;t short-cut on (&lt;= c b), is there<br>
&gt;&gt;&gt; an elegant way to speed them up?<br>
&gt;&gt;&gt;<br>
&gt;&gt;<br>
&gt;&gt; Before you asked I wrote this:<br>
&gt;&gt;<br>
&gt;&gt; ; by Rodolfo Carvalho<br>
&gt;&gt; (define (pythagorean-triple/alt n)<br>
&gt;&gt;   (for*/first ([a (in-range 1 (ceiling (/ n 3)))]<br>
&gt;&gt;                [b (in-range (add1 a) (ceiling (/ (- n a) 2)))]<br>
&gt;&gt;                [c (in-value (- n a b))]<br>
&gt;&gt;                #:when (and (&lt; b c)<br>
&gt;&gt;                            (right-triangle? a b c)))<br>
&gt;&gt;     (list a b c)))<br>
&gt;&gt;<br>
&gt;&gt;<br>
&gt;&gt; ; by Eli on the mailing list, modified by Rodolfo<br>
&gt;&gt; (define (pythagorean-triple/alt2 n)<br>
&gt;&gt;   (for*/or ([a (in-range 1 n)]<br>
&gt;&gt;             [b (in-range (add1 a) n)]) ; start from `a+1&#39; instead of `a&#39;.<br>
&gt;&gt;     (define c (- n a b))<br>
&gt;&gt;     (and (&lt; b c) (right-triangle? a b c) (list a b c)))) ; added `(&lt; b c)&#39;<br>
&gt;&gt; check.<br>
&gt;&gt;<br>
&gt;&gt;<br>
&gt;&gt;<br>
&gt;&gt; And counted how many times they call right-triangle -- the same number of<br>
&gt;&gt; times.<br>
&gt;&gt; Indeed your (first) solution with let loops seems slightly faster, but not<br>
&gt;&gt; by a significant margin in my experiments.<br>
&gt;&gt;<br>
&gt;&gt; I didn&#39;t take the time to analyze it much, but looking at the code<br>
&gt;&gt; expansion using the Macro Stepper suggested that the for macros generate a<br>
&gt;&gt; lot more code to be executed than the nested lets.<br>
&gt;&gt;<br>
&gt;&gt;<br>
&gt;&gt; []&#39;s<br>
&gt;&gt;<br>
&gt;&gt; Rodolfo Carvalho<br>
&gt;&gt;<br>
&gt;&gt;<br>
&gt;&gt;<br>
&gt;<br>
&gt;<br>
</div></div>&gt; ____________________<br>
&gt;  Racket Users list:<br>
&gt;  <a href="http://lists.racket-lang.org/users" target="_blank">http://lists.racket-lang.org/users</a><br>
&gt;<br>
</blockquote></div><br></div>