On 06 May 2016, at 18:03, [email protected] wrote:
Send Programming mailing list submissions to
[email protected]
To subscribe or unsubscribe via the World Wide Web, visit
http://jsoftware.com/mailman/listinfo/programming
or, via email, send a message with subject or body 'help' to
[email protected]
You can reach the person managing the list at
[email protected]
When replying, please edit your Subject line so it is more specific
than "Re: Contents of Programming digest..."
Today's Topics:
1. Re: Project Euler 1 (Martin Kreuzer)
2. Re: divide if not zero ('Bo Jacoby' via Programming)
3. Re: Project Euler 1 (Raul Miller)
4. Re: Project Euler 1 (Geoff Canyon)
----------------------------------------------------------------------
Message: 1
Date: Fri, 06 May 2016 14:11:54 +0000
From: Martin Kreuzer <[email protected]>
To: [email protected]
Subject: Re: [Jprogramming] Project Euler 1
Message-ID:
<572ca635.0c279d0a.62eb4.ffffbe7esmtpin_added_miss...@mx.google.com>
Content-Type: text/plain; charset="us-ascii"; format=flowed
In the effort of generalizing it more, I noticed that
(3 5) (0 +./ .= (|/ i.)) 10
1 0 0 1 0 1 1 0 0 1
works fine, but collapses when only on divider is given
(2) (0 +./ .= (|/ i.)) 10
1
(looks like the resulting vector being ORed).
Q1:
Is there a possible twist to bring these two cases (one | more than
one) together..?
In continuing toward solution to PE1 (generalized) I produced this line
pe1g=. 13 : '+/ (i.y) * (x) (0 +./ .= (|/ i.)) y'
which seems to deliver correct results
(3 5) pe1g 10
23
(3 5) pe1g 1000
233168
but still doesn't cover the special case:
(2) pe1g 10
45
*~~~~~*
Going tacid using the result of the "13 cheat"
pe1g=. [: +/ ([: i. ]) * 0 +./ .= (|/ i.)
I end up near, but not quite at Raul's 2nd suggestion
pe1=: [:+/ [:I. 0 +./ .= (|/ i.)
Q2:
Why is it, that sometimes the placeholder (]) is used to indicate the
right hand argument, and sometimes not..?
If I put two of those (i.]) in my version (as was my first thought),
I do even get a wrong answer:
pe1gf=. [: +/ ([: i. ]) * 0 +./ .= (|/ i.])
3 5 pe1gf 10
0
*~~~~~*
Progressing from
(2) (0 = (|/ i.)) 10
1 0 1 0 1 0 1 0 1 0
to
(I.) (2) (0 = (|/ i.)) 10
0 2 4 6 8
I now see how (I.) was used to compact it further by evaluating the
bit mask (instead of multiplying the elements). Neat.
-M
At 2016-05-06 08:43, you wrote:
Let me add that, following this thread so far, I too learned a few
things today - and pardon me for outlining the steps for further
reference. I (again) did a very base level approach: 3 + 8 9 10
11 12 13 5 + 8 9 10 13 14 15 3 5 + 8 9 10 |length error
| 3 5 +8 9 10 At that stage I realized that (/) isn't only
"Insert" but also used to force a "Table": 3 5 +/ 8 9 10 11 12
13 13 14 15 These lines take the "Modulo" and, in a second step,
throw a "1" for a match [division result zero], "0"
otherwise): 3 5 |/ 8 9 10 2 0 1 3 4 0 3 5 (0=|/) 8 9 10 0
1 0 0 0 1 I then combined these results by ORing (+.) the two
rows: +./ 3 5 (0=|/) 8 9 10 0 1 1 Here comes Raul for help with
his "first multiply, then add up" example 2 * 3 5 7 6 10
14 2 +/ .* 3 5 7 30 This technique seems to work for anything
dyadic, e.g. if I replaced the "multipy" (*) with [third] "root"
(%:) I got 3 %: 2 3 4 1.25992 1.44225 1.5874 3 +/ .%: 2 3 4
4.28957 As he (Raul) pointed out, if one replaces the "multiply"
with the "equal to zero comparison" one can rewrite thus 3 5 (0
+./ .=(|/)) 8 9 10 0 1 1 3 5 (0 +./ .=(|/8+i.)) 3 0 1 1 Going
back to the original example 3 5 (0 +./ .=(|/i.)) 20 1 0 0 1 0 1
1 0 0 1 1 0 1 0 0 1 0 0 1 0 which I now understand a bit better,
reading from right to left, as - take the current index (i.), -
check the modulo result (|/), - compare with zero(0 .=), - OR the
table rows (+./) produced by the left vector (to get the result
vector). And this is a fairly general notation; playing around (this
is fun): 3 5 7 (0=(|/i.)) 25 1 0 0 1 0 0 1 0 0 1 0 0 1 0 0 1 0 0
1 0 0 1 0 0 1 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0
0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 3 5 7 (0 +./
.=(|/i.)) 25 1 0 0 1 0 1 1 1 0 1 1 0 1 0 1 1 0 0 1 0 1 1 0 0 1
Thanks for your patience ... -M At 2016-05-05 22:03, you wrote: > >
3 5 (0 +./ .= (|/ i.)) 20 the ".=" is hard to read. Its >
equivalent to ". =" or in this case 3 5 (0 +./@:= (|/ i.)) 20
----- > Original Message ----- From: Geoff Canyon
<[email protected]> To: > [email protected] Sent: Thursday,
May 5, 2016 5:54 PM > Subject: Re: [Jprogramming] Project Euler 1 So
there are a few > learning opportunities here -- euphemism for
things I don't > understand ;-) I get how adding 0 = transforms the
modulo results > into a 1 for "divisible" and 0 for "not
divisible": 3 5 (0 = > (|/ i.)) 20 1 0 0 1 0 0 1 0 0 1 0 0 1 0
0 1 0 0 1 0 1 0 0 0 0 1 0 0 > 0 0 1 0 0 0 0 1 0 0 0 0 But I'm not
seeing how this combines those > results with an OR: 3 5 (0 +./ .=
(|/ i.)) 20 1 0 0 1 0 1 1 0 0 1 1 > 0 1 0 0 1 0 0 1 0 Maybe I'm just
not seeing how the forks/hooks > resolve themselves? I seem to
recall there was a command to get J > to box a command to show how
that flow works, but I don't remember > it. Or maybe that's not it
at all and I'm just confused. thx gc On > Wed, May 4, 2016 at 11:35
PM, Raul Miller <[email protected]> > wrote: > On Wed, May 4,
2016 at 10:35 PM, Geoff Canyon > <[email protected]> wrote: > > So I
tried to write code to solve > the general case of Project Euler >
problem > > 1. The problem > given is to find the sum of all the
positive integers less > > than > 1000 that are divisible by 3 or 5.
Obviously the specific case > is > > highly optimizable. But I
wanted to solve the general, with > any number of > > divisors and
any upper limit. > > ... > > Here's > the code. As always, I suck at
J, so improvements/suggestions > are > > welcome. > > > > pe1 =:
+/@(([:i.]) * > 1&-@(0&i.)@*/"1@|:@(|"0 1 i.)) > > Maybe: > pe1=:
[:+/@I. 0 +./ > .= (|/ i.) > > ? > > Assuming email anti-spam bots
do not eat my > line for including an @ > character. Maybe,
instead: > > pe1=: > [:+/ [:I. 0 +./ .= (|/ i.) > > ... > > -- >
Raul > >
----------------------------------------------------------------------
For information about J forums see >
http://www.jsoftware.com/forums.htm > >
----------------------------------------------------------------------
For information about J forums see >
http://www.jsoftware.com/forums.htm >
----------------------------------------------------------------------
For information about J forums see
http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
------------------------------
Message: 2
Date: Fri, 6 May 2016 14:56:27 +0000 (UTC)
From: "'Bo Jacoby' via Programming" <[email protected]>
To: "[email protected]" <[email protected]>
Subject: Re: [Jprogramming] divide if not zero
Message-ID:
<[email protected]>
Content-Type: text/plain; charset=UTF-8
x%y+y=0
Den 3:37 fredag den 6. maj 2016 skrev Joe Bogner <[email protected]>:
On 6 May 2016, at 10:53 AM, 'Pascal Jasmin' via Programming <
[email protected]> wrote:
I would go with first version. What don't you like about it?
Thanks - I don't particularly like using explicit rank. It also fails on
the atom case
It's also not particularly fast:
6!:2 '(?1e6#5) %^:(0~:])"0 (?1e6#5)'
0.703749
On Thu, May 5, 2016 at 9:25 PM, Ric Sherlock <[email protected]> wrote:
How about:
3 2 4 (% * 0 ~: ]) 6 0 3
0.5 0 1.33333
Nice!
6!:2 '(?1e6#5) (% * 0 ~: ]) (?1e6#5)'
0.0489602
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
------------------------------
Message: 3
Date: Fri, 6 May 2016 11:17:21 -0400
From: Raul Miller <[email protected]>
To: Programming forum <[email protected]>
Subject: Re: [Jprogramming] Project Euler 1
Message-ID:
<CAD2jOU-AdsYZZhR=ms-iqr3chmsmgkhg1xfyubadzmlunp-...@mail.gmail.com>
Content-Type: text/plain; charset=UTF-8
A1:
This does what I think you want:
(,2) (0 +./ .= (|/ i.)) 10
1 0 1 0 1 0 1 0 1 0
I think it's reasonable to expect that the left argument always be a
list (aka "a vector"). But, if you like, you could wrap this in code
that guarantees vectorness. Since the rank of the right argument
doesn't matter all that much, you could instead do it like this:
(2) (0 +./ .= (|/ i.))&, 10
Still... I would beware of overgeneralizing - unless you have specific
reasons to go there, you often wind up with "solutions looking for
problems" which then gets followed by "trying to find problems to fit
the solutions" and before long you are out shaving yaks.
Which, ok, might be a good thing if your yaks have been needing some grooming...
A2:
Try removing it..
Or, if that's too crude of an answer, consider this:
9 ( - ) 3
6
9 ([: - ]) 3
_3
Basically, ] in a dyadic context is the right argument.
9 ( ] ) 3
3
Combine this with trains (forks, mostly) and a ] in an odd position is
sort of like the y argument and a [ in an odd position is sort of like
the x argument.
--
Raul
On Fri, May 6, 2016 at 10:11 AM, Martin Kreuzer <[email protected]> wrote:
In the effort of generalizing it more, I noticed that
(3 5) (0 +./ .= (|/ i.)) 10
1 0 0 1 0 1 1 0 0 1
works fine, but collapses when only on divider is given
(2) (0 +./ .= (|/ i.)) 10
1
(looks like the resulting vector being ORed).
Q1:
Is there a possible twist to bring these two cases (one | more than one)
together..?
In continuing toward solution to PE1 (generalized) I produced this line
pe1g=. 13 : '+/ (i.y) * (x) (0 +./ .= (|/ i.)) y'
which seems to deliver correct results
(3 5) pe1g 10
23
(3 5) pe1g 1000
233168
but still doesn't cover the special case:
(2) pe1g 10
45
*~~~~~*
Going tacid using the result of the "13 cheat"
pe1g=. [: +/ ([: i. ]) * 0 +./ .= (|/ i.)
I end up near, but not quite at Raul's 2nd suggestion
pe1=: [:+/ [:I. 0 +./ .= (|/ i.)
Q2:
Why is it, that sometimes the placeholder (]) is used to indicate the right
hand argument, and sometimes not..?
If I put two of those (i.]) in my version (as was my first thought), I do
even get a wrong answer:
pe1gf=. [: +/ ([: i. ]) * 0 +./ .= (|/ i.])
3 5 pe1gf 10
0
*~~~~~*
Progressing from
(2) (0 = (|/ i.)) 10
1 0 1 0 1 0 1 0 1 0
to
(I.) (2) (0 = (|/ i.)) 10
0 2 4 6 8
I now see how (I.) was used to compact it further by evaluating the bit mask
(instead of multiplying the elements). Neat.
-M
At 2016-05-06 08:43, you wrote:
Let me add that, following this thread so far, I too learned a few things
today - and pardon me for outlining the steps for further reference. I
(again) did a very base level approach: 3 + 8 9 10 11 12 13 5 + 8 9
10 13 14 15 3 5 + 8 9 10 |length error | 3 5 +8 9 10 At that stage
I realized that (/) isn't only "Insert" but also used to force a "Table":
3 5 +/ 8 9 10 11 12 13 13 14 15 These lines take the "Modulo" and, in a
second step, throw a "1" for a match [division result zero], "0" otherwise):
3 5 |/ 8 9 10 2 0 1 3 4 0 3 5 (0=|/) 8 9 10 0 1 0 0 0 1 I then combined
these results by ORing (+.) the two rows: +./ 3 5 (0=|/) 8 9 10 0 1 1
Here comes Raul for help with his "first multiply, then add up" example
2 * 3 5 7 6 10 14 2 +/ .* 3 5 7 30 This technique seems to work for
anything dyadic, e.g. if I replaced the "multipy" (*) with [third] "root"
(%:) I got 3 %: 2 3 4 1.25992 1.44225 1.5874 3 +/ .%: 2 3 4 4.28957
As he (Raul) pointed out, if one replaces the "multiply" with the "equal to
zero comparison" one can rewrite thus 3 5 (0 +./ .=(|/)) 8 9 10 0 1 1
3 5 (0 +./ .=(|/8+i.)) 3 0 1 1 Going back to the original example 3 5 (0
+./ .=(|/i.)) 20 1 0 0 1 0 1 1 0 0 1 1 0 1 0 0 1 0 0 1 0 which I now
understand a bit better, reading from right to left, as - take the current
index (i.), - check the modulo result (|/), - compare with zero(0 .=), - OR
the table rows (+./) produced by the left vector (to get the result vector).
And this is a fairly general notation; playing around (this is fun): 3 5
7 (0=(|/i.)) 25 1 0 0 1 0 0 1 0 0 1 0 0 1 0 0 1 0 0 1 0 0 1 0 0 1 1 0 0 0 0
1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0
0 0 0 1 0 0 0 3 5 7 (0 +./ .=(|/i.)) 25 1 0 0 1 0 1 1 1 0 1 1 0 1 0 1 1
0 0 1 0 1 1 0 0 1 Thanks for your patience ... -M At 2016-05-05 22:03, you
wrote: > > 3 5 (0 +./ .= (|/ i.)) 20 the ".=" is hard to read. Its >
equivalent to ". =" or in this case 3 5 (0 +./@:= (|/ i.)) 20 ----- >
Original Message ----- From: Geoff Canyon <[email protected]> To: >
[email protected] Sent: Thursday, May 5, 2016 5:54 PM > Subject: Re:
[Jprogramming] Project Euler 1 So there are a few > learning opportunities
here -- euphemism for things I don't > understand ;-) I get how adding 0 =
transforms the modulo results > into a 1 for "divisible" and 0 for "not
divisible": 3 5 (0 = > (|/ i.)) 20 1 0 0 1 0 0 1 0 0 1 0 0 1 0 0 1 0 0
1 0 1 0 0 0 0 1 0 0 > 0 0 1 0 0 0 0 1 0 0 0 0 But I'm not seeing how this
combines those > results with an OR: 3 5 (0 +./ .= (|/ i.)) 20 1 0 0 1 0 1 1
0 0 1 1 > 0 1 0 0 1 0 0 1 0 Maybe I'm just not seeing how the forks/hooks >
resolve themselves? I seem to recall there was a command to get J > to box a
command to show how that flow works, but I don't remember > it. Or maybe
that's not it at all and I'm just confused. thx gc On > Wed, May 4, 2016 at
11:35 PM, Raul Miller <[email protected]> > wrote: > On Wed, May 4, 2016
at 10:35 PM, Geoff Canyon > <[email protected]> wrote: > > So I tried to
write code to solve > the general case of Project Euler > problem > > 1. The
problem > given is to find the sum of all the positive integers less > >
than > 1000 that are divisible by 3 or 5. Obviously the specific case > is >
highly optimizable. But I wanted to solve the general, with > any number
of > > divisors and any upper limit. > > ... > > Here's > the code. As
always, I suck at J, so improvements/suggestions > are > > welcome. > > > >
pe1 =: +/@(([:i.]) * > 1&-@(0&i.)@*/"1@|:@(|"0 1 i.)) > > Maybe: > pe1=:
[:+/@I. 0 +./ > .= (|/ i.) > > ? > > Assuming email anti-spam bots do not
eat my > line for including an @ > character. Maybe, instead: > > pe1=: >
[:+/ [:I. 0 +./ .= (|/ i.) > > ... > > -- > Raul > >
---------------------------------------------------------------------- > >
For information about J forums see > http://www.jsoftware.com/forums.htm > >
---------------------------------------------------------------------- >
For information about J forums see > http://www.jsoftware.com/forums.htm >
---------------------------------------------------------------------- >
For information about J forums see http://www.jsoftware.com/forums.htm
---------------------------------------------------------------------- For
information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
------------------------------
Message: 4
Date: Fri, 6 May 2016 12:03:15 -0400
From: Geoff Canyon <[email protected]>
To: [email protected]
Subject: Re: [Jprogramming] Project Euler 1
Message-ID:
<cakclktq1qkajnffzu74herpatavelwd5hfrar6-cywvjazs...@mail.gmail.com>
Content-Type: text/plain; charset=UTF-8
On Fri, May 6, 2016 at 4:43 AM, Martin Kreuzer <[email protected]> wrote:
At that stage I realized that (/) isn't only "Insert" but also used to
force a "Table":
Yep, this was new to me as well, as evidenced by my original awkward |"0 1
construction.
------------------------------
Subject: Digest Footer
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
------------------------------
End of Programming Digest, Vol 128, Issue 16
********************************************
