another option for replacing primes with 1 in an array:
   arr=: 1+i.10 10
   (1 p: arr) } arr ,: 1
or tacitly:
   (1&p:)`(,:&1)} arr

On Tue, Oct 14, 2014 at 8:00 AM, Raul Miller <[email protected]> wrote:

> Looking over this primelist issue...
>
> One of the first things I would probably do, would be to review the
> dictionary entry for p:
>
> http://www.jsoftware.com/help/dictionary/dpco.htm
>
> And notice:
>    1 p: 1 2 3 4 5
> 0 1 1 0 1
>
> So primelist might be written as:
>    primelist=: 1&p: # ]
>
> Testing:
>    primelist 1 2 3 4 5
> 2 3 5
>
> Meanwhile, if you want the primes from a 10 by 10 array, first translate
> the array into a list (using comma):
>    arr=: 1+i.10 10
>    primelist,arr
> 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
>
> Or, for "change numbers in arr to 1 if the sum of the indices is prime, I
> might do something like this:
>
>    arr^0 p:+/&i./$arr
>  1  2  1  1  5  1  7  1  9  10
> 11  1  1 14  1 16  1 18 19  20
>  1  1 23  1 25  1 27 28 29   1
>  1 32  1 34  1 36 37 38  1  40
> 41  1 43  1 45 46 47  1 49   1
>  1 52  1 54 55 56  1 58  1  60
> 61  1 63 64 65  1 67  1 69  70
>  1 72 73 74  1 76  1 78 79  80
> 81 82 83  1 85  1 87 88 89   1
> 91 92  1 94  1 96 97 98  1 100
>
> Explanation:
>
> I can change the elements of arr to 1 by raising them to the zero-th power
> (changing to an arbitrary value would require slightly more work).
>
> I can get zeros corresponding to primes using 0 p: (from reading that
> dictionary entry).
>
> The expression +/&i./$arr works out like this:
>    +/&i./$arr        NB. the concise expression
>    +/&i./10 10       NB. definition of $
>    10 +/&i. 10       NB. definition of /
>    (i.10) +/ (i.10)  NB. definition of & using +/ and i.
> 0  1  2  3  4  5  6  7  8  9
> 1  2  3  4  5  6  7  8  9 10
> 2  3  4  5  6  7  8  9 10 11
> 3  4  5  6  7  8  9 10 11 12
> 4  5  6  7  8  9 10 11 12 13
> 5  6  7  8  9 10 11 12 13 14
> 6  7  8  9 10 11 12 13 14 15
> 7  8  9 10 11 12 13 14 15 16
> 8  9 10 11 12 13 14 15 16 17
> 9 10 11 12 13 14 15 16 17 18
>
> Mostly, I guess, there are a few dozen vocabulary words here to master.
> Once you've gotten comfortable with them, you should have a rough idea of
> which ones might be relevant to a topic.
>
> Also, there's the matter of getting used to working on arrays "as a whole"
> and/or thinking about treating each item independently when possible.
>
> That's all I can think of that might be relevant for this kind of thing.
>
> Thanks,
>
> --
> Raul
>
>
> On Sat, Oct 11, 2014 at 1:33 AM, Jon Hough <[email protected]> wrote:
>
> > Using (2 ! >:) is clearly better than doing my double for-loop. I'm
> > embarrassed I missed that.
> >
> > The real meat of my confusion with multidimensional arrays is in not just
> > finding the indices but doing something with the elements at the indices.
> >
> > e.g. For a single dimension array, there could be a function to fund the
> > primes less than 100.
> >
> >
> > primelist =: (I.@:(1&=)@:(1&p:)) { ]
> >
> >
> > and primelist >: i. 100
> >
> >
> > should spit out
> >
> >
> > 2 3 5 ...  ...97
> >
> >
> > But what if instead of having >: i. 100
> >
> > I had ( for some reason )
> >
> >  arr =: 10 10 $ >: i. 100
> >
> >
> > So I have a 10 by 10 matrix of all positive ints up to 100.
> >
> >
> > primelist clearly will not work on arr. But if I want to return the list
> > of primes, as a single dimensional list I'm not sure how to do that.
> >
> >
> > Or, for example, if I want to change the elements of arr to 1 if and only
> > if the sum of the (i, j) indices are prime (just a random example).
> >
> >
> > In procedural python this could be quickly done with a double for-loop
> and
> > a prime test. In J this type of problem still escapes me.
> >
> >
> >
> > > Date: Fri, 10 Oct 2014 19:35:26 -0400
> > > From: [email protected]
> > > To: [email protected]
> > > Subject: Re: [Jprogramming] Project Euler 85, Python and J
> > >
> > >    countRects=: */@(2 ! >:)             NB. How many pairs each of
> > vertical
> > > * horizontal lines
> > >    getSizes=: ,@(>:/~) # [: ,/ ,"0/~    NB. All pairs of i. y
> > >    idxClosest=: 4 : '(i. <./)@(x |@:- ])y'"(0 2)   NB. Index of mat y
> to
> > > value x
> > >    ({~ *2e6*&idxClosest@:(countRects"1)) getSizes >: i.200    NB.
> > Closest
> > > to 2e6
> > > 77 36
> > >    ({~ *1e6*&idxClosest@:(countRects"1)) getSizes >: i.200    NB.
> > Closest
> > > to 1e6
> > > 63 31
> > >    countRects"1 ] 63 31,:77 36     NB. How close is each?
> > > 999936 1999998
> > >
> > >
> > > On Fri, Oct 10, 2014 at 1:14 PM, Linda Alvord <[email protected]
> >
> > > wrote:
> > >
> > > > What is the correct answerfor this problem?
> > > >
> > > > Linda
> > > >
> > > > -----Original Message-----
> > > > From: [email protected]
> > > > [mailto:[email protected]] On Behalf Of
> Stefano
> > > > Lanzavecchia
> > > > Sent: Friday, October 10, 2014 11:47 AM
> > > > To: [email protected]
> > > > Subject: Re: [Jprogramming] Project Euler 85, Python and J
> > > >
> > > > Actuary the use of ravel and antibase is common practice to solve
> > > > certain problems in APL and isn't considered cheating. So I wouldn't
> > > > say it's "not nice" but I would definitely go for antibase instead of
> > > > a combination of floored-divide and modulus. As a bonus, a solution
> > > > based on antibase would scale to problems of any rank and not just 2d
> > > > matrices.
> > > >
> > > > Have fun!
> > > > --
> > > > Stefano
> > > >
> > > > > On 10/ott/2014, at 17:35, Sebastiano Tronto <
> > [email protected]
> > > > >
> > > > wrote:
> > > > >
> > > > > Hi,
> > > > > A dirty trick to get the job done would be to ravel the matrix ( ,
> ),
> > > > solve
> > > > > the 1d version of the problem and then get the "true" indexes with
> > > > > something like (<.@%&200 , 200&|).
> > > > > For example, if you needed to just find the max:
> > > > > (<.@%&200 , 200&|) (i. >./) , m
> > > > > where m is your matrix.
> > > > >
> > > > > I know this isn't a nice way to solve the problem, but it should
> > work.
> > > > >
> > > > > Sebastiano
> > > > >
> > > > > 2014-10-07 6:37 GMT+02:00 Jon Hough <[email protected]>:
> > > > >
> > > > >> Project Euler 85: https://projecteuler.net/problem=85
> > > > >> This problem is not really conceptually hard, but I am struggling
> > with a
> > > > J
> > > > >> solution.I have solved it in Python:
> > > > >> =============================================
> > > > >> def pe85(larg, rarg):   count = 0       llist = range(1, larg+1)
> > > > >> rlist = range(1, rarg+1)
> > > > >>        for l in llist:         for r in rlist:
> >  count +=
> > > > >> l*r
> > > > >>        return count
> > > > >>
> > > > >> if __name__ == "__main__":      # test for 2x3 grid, as in
> question.
> > > > k
> > > > >> = pe85(2,3)   print "Test value: "+str(k)             l1 =
> > range(1,200)
> > > > #
> > > > >> 200 lucky guess     l2 = range(1,200)       bestfit = 10000 # just
> > a big
> > > > >> number     area = 0        for i in l1:            for j in l2:
> > > > >>         diff = abs(2000000 - pe85(i,j))                         if
> > diff
> > > > <
> > > > >> bestfit:                             area = i*j
> > > > >>  bestfit = diff
> > > > >>        print "AREA is "+str(area)
> > > > >>
> > > > >>
> > > > >> ================================================The above script
> > will
> > > > give
> > > > >> the final area of the closest fit to 2 million. (The python code
> > may not
> > > > be
> > > > >> the best). Also I tested all possibilities up to 200x200, which
> was
> > > > chosen
> > > > >> arbitrarily(~ish).
> > > > >> Next my J. I go the inner calculation ok (i.e. see the function
> pe85
> > > > >> above). In J I have:
> > > > >> pe85 =: +/@:+/@:((>:@:i.@:[) *"(0 _) (>:@:i.@:]))
> > > > >> NB. I know, too brackety. Any tips for improvement appreciated.
> > > > >>
> > > > >>
> > > > >> But from here things get tricky. If I do the calculation over
> > 200x200
> > > > >> possibilities I end up with a big matrix, of which I have to find
> > the
> > > > >> closest value to 2 million, of which then I have to somehow get
> the
> > > > (x,y)
> > > > >> values of and then find the area by x*y.
> > > > >>
> > > > >> The main issue is getting the (x,y) from the best fit value of the
> > > > array.
> > > > >>
> > > > >> i.e. If I do pe85"(0)/~ 200, I get a big array, and I know I can
> > get the
> > > > >> closest absolute value to 2 million but then I need to get the
> > original
> > > > >> values to multiply together to give the best fit area. Actually I
> > have
> > > > >> bumped into this issue many times. It is easy enough in a 1-d
> > array,just
> > > > do:
> > > > >> (I. somefunc ) { ])
> > > > >>
> > > > >> or similar to get the index. But for two indices the problem is
> > beyond
> > > > me
> > > > >> at the moment. Any help appreciated.Regards,Jon
> > > > >>
> > > > >>
> > > > >>
> > > > >>
> > ----------------------------------------------------------------------
> > > > >> 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
> > > >
> > >
> > >
> > >
> > > --
> > > Devon McCormick, CFA
> > > ----------------------------------------------------------------------
> > > 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

Reply via email to