Hi Skip,
When using n (or v) as names in a direct definition, it assumes you're
defining a conjunction:
F=.{{{.n#~y=+/\c1 n=.>:i.100}}
F 19
F(19)
type <'F'
┌───────────┐
│conjunction│
└───────────┘
FF=:{{{.nn#~y+/\c1 nn=.>:i.100}}
type<'FF'
┌────┐
│verb│
└────┘
or you can explicitly tell it to make a monad using )m (note, doesn't
seem to work on a single line):
FFF=:{{)m
{.n#~y+/\c1 n=.>:i.100
}}
type<'FFF'
┌────┐
│verb│
└────┘
I hope this helps,
Jan-Pieter
On Sun, Jan 23, 2022, 07:03 Skip Cave <s...@caveconsulting.com> wrote:
> Also,
>
> Also, why doesn't this work:
>
> F=.{{{.n#~y=+/\c1 n=.>:i.100}}
>
> F 19
>
> F(19)
>
>
>
>
> Skip Cave
> Cave Consulting LLC
>
>
> On Sat, Jan 22, 2022 at 11:50 PM Skip Cave <s...@caveconsulting.com>
> wrote:
>
> > Thanks for all the examples. I thought that the solution would be pretty
> > straightforward.
> >
> > c1 gives the number of ones in an integer:
> > * c1=.{{+/1=10#.^:_1]y}}"0*
> >
> >
> > Test it:
> >
> > * c1 211*
> >
> > *2*
> >
> >
> > So the number of ones from 1 to 81 is:
> >
> > * +/c1 i.>:81*
> >
> > *19*
> >
> > To develop the inverse verb F, we can get a running sum of ones:
> > * +/\c1 >:i.100*
> >
> > * 1 1 1 1 1 1 1 1 1 2 4 5 6 7 8 9 10 11 12 12 13 13 13 13 13 13 13 13 13
> > 13 14 14 14 14 14 14 14 14 14 14 15 15 15 15 15 15 15 15 15 15 16 16 16
> 16
> > 16 16 16 16 16 16 17 17 17 17 17 17 17 17 17 17 18 18 18 18 18 18 18 18
> 18
> > 18 19 19 19 19 19 19 19 19 19 19 20 20 20 20 20 20 20 20 20 21*
> >
> >
> > So to find the integer where the sum of ones equals 19:
> >
> > *F=.3 :'{.n#~y=+/\c1 n=.>:i.100'*
> >
> > * F 19*
> >
> > *81*
> >
> > This works great, except that I need to make sure that the running sum
> > index n, is larger than the expected answer. In this case, the integers
> > from one to 100 were sufficient, but that was discovered by trial and
> error.
> >
> >
> > Ideally, the running sum could be defined as an iterative process that
> > terminates in an integer, when the running sum iteration reaches or
> exceeds
> > the required count. Then the output of F is that integer.
> >
> >
> > So I was mainly wanting to see how to define a verb F that iterates on a
> > running sum of one counts until the sum reaches the right argument of F,
> > then returns the integer that terminates the ones count.
> >
> > So I just want to know how to modify:
> >
> > *F=.3 :'{.n#~y=+/\c1 n=.>:i.100'*
> >
> > to a running-sum iteration which terminates & returns the final integer
> > that matches the ones count input, and does not have to predefine the
> index
> > count.
> >
> > Skip Cave
> > Cave Consulting LLC
> >
> >
> > On Tue, Jan 18, 2022 at 3:58 AM Raul Miller <rauldmil...@gmail.com>
> wrote:
> >
> >> I should have removed from 'seno' the line that says:
> >> assert. hi<1000
> >>
> >> The purpose of that line was to save me from having to use jbrk if I
> >> hit an infinite loop from getting my conditions backwards. It's not a
> >> useful mechanism, and should have been removed before I posted the
> >> implementation.
> >>
> >> FYI,
> >>
> >> --
> >> Raul
> >>
> >> On Tue, Jan 18, 2022 at 2:27 AM Hauke Rehr <hauke.r...@uni-jena.de>
> >> wrote:
> >> >
> >> > I didn’t do it much differently, conceptually.
> >> > But instead of binary search (bisection)
> >> > I split it up in ten buckets (dekasect).
> >> > Apologies for the bad naming:
> >> > another greek-latin hybrid, oh my …
> >> >
> >> > I split that way because I wanted to evaluate
> >> > ones more often on small inputs than large.
> >> > Didn’t measure if it atcually helps, though.
> >> > And maybe I should have added an M. in order
> >> > to memoize?
> >> >
> >> > But seno definitively reads better.
> >> >
> >> > Am 18.01.22 um 02:54 schrieb Raul Miller:
> >> > > Your 'ones' is a bit more efficient than the routine I had come up
> >> > > with, so I'll stick with your implementation here.
> >> > >
> >> > > Meanwhile, it's perhaps worth noting
> >> > >
> >> > > I.213=ones i.1000
> >> > > 521 522 523 524 525 526 527 528 529 530
> >> > >
> >> > > So, building the inverse... it's typical for there to be ten numbers
> >> > > who had n "one digits in the sequence". But, for example, there's no
> >> > > number which has exactly 3 "one digits in the sequence". Ten has 2,
> >> > > eleven has four. But we can find the minimum value which had at
> least
> >> > > n preceding one digits.
> >> > >
> >> > > Personally, I'd use a binary search here:
> >> > >
> >> > > seno=:{{
> >> > > if.y=ones y do.y return.end.hi=.2*lo=.y
> >> > > while.y>ones hi do. hi=.2*lo=.hi end.
> >> > > while.hi>lo do.
> >> > > assert. hi<1000
> >> > > select.*y-ones mid=.<.-:lo+hi+1
> >> > > case._1 do.if.hi=mid do.lo=.hi break.end.hi=.mid
> >> > > case.0 do.lo=.hi=.mid break.
> >> > > case.1 do.lo=.mid
> >> > > end.
> >> > > end.
> >> > > while.y <: ones lo do.lo=.<:hi=.lo end. NB. maybe too crude...
> >> > > hi
> >> > > }}
> >> > >
> >> > > seno 213
> >> > > 521
> >> > > ones 521
> >> > > 213
> >> > >
> >> > > FYI,
> >> > >
> >> >
> >> > --
> >> > ----------------------
> >> > mail written using NEO
> >> > neo-layout.org
> >> >
> >> > ----------------------------------------------------------------------
> >> > 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
