2006/11/16, June Kim <[EMAIL PROTECTED]>:
2006/11/16, Mike Day <[EMAIL PROTECTED]>:
> So does this satisfy your requirements?
>
> 1 ((>./\@([ {. <[EMAIL PROTECTED] # [EMAIL PROTECTED])~ #) </. ]) i.10
> +-------------------+
> |0 1 2 3 4 5 6 7 8 9|
> +-------------------+
> 2 ((>./\@([ {. <[EMAIL PROTECTED] # [EMAIL PROTECTED])~ #) </. ]) i.10
> +---------+---------+
> |0 1 2 3 4|5 6 7 8 9|
> +---------+---------+
> 3 ((>./\@([ {. <[EMAIL PROTECTED] # [EMAIL PROTECTED])~ #) </. ]) i.10
> +-----+-----+-------+
> |0 1 2|3 4 5|6 7 8 9|
> +-----+-----+-------+
> 7 ((>./\@([ {. <[EMAIL PROTECTED] # [EMAIL PROTECTED])~ #) </. ]) i.10
> +-+-+-+-+-+-+-------+
> |0|1|2|3|4|5|6 7 8 9|
> +-+-+-+-+-+-+-------+
>
> It doesn't check the ordering of the input list. What should be
> the result for 10?10 ?
> Compare
> 3 ((((-@ <[EMAIL PROTECTED] )~)#)<\]) q=: 0 1 8 2 6 7 9 4 5 3
> +-----+-----+-------+
> |0 1 8|2 6 7|9 4 5 3|
> +-----+-----+-------+
> 3 f q NB. June Kim's "f"
> +-------+---------+-+
> |0 1 8 2|6 7 9 4 5|3|
> +-------+---------+-+
Yes, you are right and my second f was wrong. I mistakingly considered
the input as i. N. However, my first version of f in the original post
works correct.
Thanks.
So my second f, which was previously (b1*.b2) < ;. 1 ], should be modified as:
((b1 *. b2) [EMAIL PROTECTED]@]) <;.1 ]
>
> Mike
>
> June Kim wrote:
> > Well, it doesn't work in the case of K=4 and N=10.
> >
> > (-<.10%4) ((*@|@|#) (]`(_2:(}.,[:,&.>/{.)])@.[) <\) i.10
> > +---+---+---+---+---+
> > |0 1|2 3|4 5|6 7|8 9|
> > +---+---+---+---+---+
> >
> > They are five segments, instead of four(K). What actually it should
> > return is:
> > 4 f i.10
> > +---+---+---+-------+
> > |0 1|2 3|4 5|6 7 8 9|
> > +---+---+---+-------+
> >
> >
> > 2006/11/16, June Kim <[EMAIL PROTECTED]>:
> >> 2006/11/15, R.E. Boss <[EMAIL PROTECTED]>:
> >> > A first shot: use (-K) <\ i.N and append the content of the last
> >> two boxes
> >>
> >> It shouldn't be (-K) <\ i.N
> >>
> >> K in the problem is the number of segments of the whole ordered list.
> >> Therefore, it should've been <.N%K instead.
> >>
> >> > if the last one is a shard.
> >> >
> >> > _3 ((*@|@|#) (]`(_2&}.,[:,&.>/_2&{.)@.[) <\) i.10
> >> > +-----+-----+-------+
> >> > |0 1 2|3 4 5|6 7 8 9|
> >> > +-----+-----+-------+
> >> >
> >> > R.E. Boss
> >> >
> >>
> >> Thank you for your solution.
> >>
> >>
> >> >
> >> > -----Oorspronkelijk bericht-----
> >> > Van: [EMAIL PROTECTED]
> >> > [mailto:[EMAIL PROTECTED] Namens June Kim
> >> > Verzonden: woensdag 15 november 2006 6:17
> >> > Aan: Programming forum
> >> > Onderwerp: [Jprogramming] Re: Coding Problem
> >> >
> >> > One more solution:
> >> >
> >> > cs=: [: <. [ %~ [: # ]
> >> > b1=: 0 = cs | ]
> >> > b2=: ] < [ * cs
> >> > f=: (b1*.b2) < ;. 1 ]
> >> >
> >> >
> >> > 2006/11/15, June Kim <[EMAIL PROTECTED]>:
> >> > > 2006/11/15, June Kim <[EMAIL PROTECTED]>:
> >> > > > from http://c2.com/cgi/wiki?CodingProblem
> >> > > >
> >> > > > Given K, answer an ordered collection of K ordered collections
> >> of size
> >> > > > approximately N / K, such that the first contains the first N / K
> >> > > > objects, the second the second N / K, etc.
> >> > > >
> >> > > > There is a J solution on that page but it doesn't work in all
> >> cases.
> >> > > >
> >> > > > Following is my solution (with one issue though):
> >> > > > c=: [: <. [ %~ [: # ]
> >> > > > hd=: ([: <: [) * c
> >> > > >
> >> > > > b1=: hd {.]
> >> > > > b2=: hd }.]
> >> > > > f=: <@b2 ,~ [EMAIL PROTECTED] <\ b1
> >> > > >
> >> > > > assert (0 1 2;3 4 5;6 7 8)-:3 f i.9
> >> > > > assert ((,:0);1 2)-:2 f i.3
> >> > > > assert (0 1 2;3 4 5;6 7 8 9)-:3 f i.10
> >> > > >
> >> > > > assert ((0$<''),<0 1)-: 1 f i.2 NB. $ > 1 f i.2 is 1 2,
> >> not 2
> >> > > > as I expected
> >> > > >
> >> > > > I don't like the last line -- that problem occurs once in a
> >> while. How
> >> > > > could I make it to pass "assert (<0 1)-:1 f i.2" with a simple
> >> > > > modification?
> >> > >
> >> > > In other words, assert (,:<0 1)-: 1 f i.2
> >> > >
> >> > > Hm... Maybe I was wrong.
> >> > >
> >> > > My solution's result is more consistent than how I wanted the
> >> result to
> >> > be.
> >> > >
> >> > > The return value of f is, an array of rank 1. Each item of the array
> >> > > is of rank 1. Then my previous solution is more consistent.
> >> > >
> >> > > I am sometimes confused(and make mistakes) with the fact that in
> >> J we
> >> > > have scalars of which rank is empty, which is different from a
> >> rank-1
> >> > > array of a single item. Even a boxed value can a scalar or a rank-1
> >> > > array(say <1 and ,:<1).
> >> > >
> >> > > >
> >> > > > I am interested in seeing other J solutions.
> >> > > >
> >> > >
> >> > > Still.
> >> > >
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
