Part of the complexity is searching for index rather than "data". There are
several convenience functions that can simplify the code
G0 =: 0 {:: ]
G1 =: 1 {:: ]
Z2 =: 2 : 'u`(_2 Z: 1:)@.v' NB. break when v is true. otherwise u.
Funtil =: Z2 (] F..) NB. fold until v is true, otherwise apply u (of fold).
Uses old/new (C A) train.
Considering that we are using fold to replace dyadic scan, which it was not
directly intended to do, it is not THAT complicated.
There is a preprocessing step that can be separated into an adverb, and reduce
parentheses as a benefit.
1 : '(4;~4{.]) u (4}.])' NB. instead of embedding the preprocessing step into
"the fork" which impedes removing it or editing it.
((1>:@{::]),&<~[,~ _3{.0{::]) Funtil (4=0#@~.@{::]) {{(4;~4{.]) u (4}.])}} ex
or
(>:@G1,&<~ [,~ _3{.G0) Funtil (4 = #@~.@G0) {{(4;~4{.]) u (4}.])}} ex
and it is easy to turn it all into an adverb that parameterizes part 1 and 2
5 {{ (>:@G1,&<~ [,~ (>: - m){.G0) Funtil (m = #@~.@G0) {{(n;~n{.]) u (n}.])}}
m}} ex
┌─────┬─┐
│jpqmg│8│
└─────┴─┘
An alternative that maps the i. solution over preprocessed 4 ]\ ] scan (and
then probably doesn't beat i. in performance?)
It looks at only x, and increments a single integer y when it doesn't "break"
4 {{m >:@] Funtil (m = #@~.@[) m ]\ ]}} ex
7
or hard coded
4 >:@] Funtil (4 = #@~.@[) 4 ]\ ex NB. 4 is x arg to F..
7
or the first string that matches ("better than i." if this is what you want as
search result)
[ Funtil (4 = #@~.@]) 4 ]\ ex
jpqm
so there is still a relatively short version of the F.. approach for processing
scans, if you do the scan first.
On Thursday, December 8, 2022 at 03:02:35 p.m. EST, 'Michael Day' via
Programming <programm...@jsoftware.com> wrote:
Thanks for your replies - I'll try to get round to understanding them.
It's a pity the Fold approach to this problem appears to need to be verbose.
Cheers,
Mike
On 08/12/2022 19:34, 'Pascal Jasmin' via Programming wrote:
> mistake in Z definition found,
>
> Zl =: ] [ _3 Z: [
>
> makes this work,
>
> ((4;~4{.]) ((1>:@{::]),&<~[,~ _3{.0{::])`(_2 Z:1:)@.(4=0#@~.@{::]) ((100 Zl
> ]) F..) (4}.])) ex
>
> but still
>
> ((4;~4{.]) ((1>:@{::]),&<~[,~ _3{.0{::])`(_2 Z:1:)@.(4=0#@~.@{::]) ((100 Zl
> ]) F.) (4}.])) ex
>
> |domain error
>
>
>
>
> On Thursday, December 8, 2022 at 02:15:39 p.m. EST, 'Pascal Jasmin' via
> Programming <programm...@jsoftware.com> wrote:
>
>
>
>
>
> The short circuit you are trying to avoid is to skip the full partitioning
> part
>
> 4 #@~.\4
>
> one approach is to separate into the simplest possible partition, then hope
> that i. special code finds the short circuit.
>
> 4 + (1 i.~ 4 = #@~."1) 4 ]\ ex
>
> your power approach is completely reasonable.
>
> A fold approach is complicated by seeking the index rather than a "computed
> result"
>
> There might be too much manipulated computation involved, but the general
> approach would be:
>
> x parameter to fold is (a: ,< 0) NB. initial y.
> if head cell of y is shorter than 4, then append x to last 3 chars. (better
> to preprocess y such that x (to F.) has first 4 chars, and y omits first 4.)
> if head is length 4, then apply test ((1 >:@{:: ] ) ,&<~ [,~ _3{.0{::])`(_2
> Z: 1:)@.(4 = #@~. 0 {:: ])
>
> ((4;~4{.]) ((1>:@{::]),&<~[,~ _3{.0{::])`(_2 Z:1:)@.(4=0#@~.@{::]) (] F..)
> (4}.])) ex
> ┌────┬─┐
> │jpqm│7│
> └────┴─┘
>
> I don't understand why this fails: (F. instead of F..)
>
> Z =: ] [ Z:
>
>
> ((4;~4{.]) ((1>:@{::]),&<~[,~ _3{.0{::])`(_2 Z:1:)@.(4=0#@~.@{::]) ((100
>Z~ _3:) F.) (4}.])) ex
>
> |domain error
>
> or
>
> ((4;~4{.]) ((1>:@{::]),&<~[,~ _3{.0{::])`(_2 Z:1:)@.(4=0#@~.@{::]) (] F.)
>(4}.])) ex
>
> |domain error
>
>
> also it is not documented whether F. or F: are forward or reverse.
>
> On Thursday, December 8, 2022 at 11:28:12 a.m. EST, 'Michael Day' via
> Programming <programm...@jsoftware.com> wrote:
>
>
>
>
>
> Having remarked recently (re Advent of Code day 6):
>
> Very easy today, in J at least, and probably in APL & K/Q. (Though it
> suggests one should learn the new fold features, as it's inefficient to
> examine all the data for something that might occur early. No problem
> with 4kb, but ....)
>
> I've just had a look at the Jwiki entries about Fold, and wonder how it
> would work
> for day 6.
>
> The problem is so easy for J-ers that I don't think this will spoil it
> for forum users:
> ex
> mjqjpqmgbljsphdztnvjfqwrcgsmlb
> 4 + 4 i.~ 4 #@~.\ ex
> 7
>
> QED
>
> #data NB. the size of my data set
> 4096
> ts'4 + 4 i.~ 4 #@~.\ data' NB. time & space
> 0.0008555 67232
>
> I didn't bother making a function for this!
>
> One way to stop early, rather than process the whole array, is this:
> ts'4 + (# - #@:((}.`])@.(4&([ = #@:~.@:{.))^:_)) data'
> 0.0007299 4736
>
> (I know it's ugly, and non-optimal!)
>
> Similar time but with ca 14x space-saving.
>
> But there must be some sort of Fold to progressively examine 4-windows,
> or 14-windows in part 2, until the first appropriate window is found,
> when
> it stops. That should save time as well as space. Not necessary
> here, of
> course, but if there was a real application with many megabytes of data...
>
> Cheers,
>
> Mike
>
>
>
> On 06/12/2022 19:46, Brian Schott wrote:
>> I have successfully solved Day 5 using the following looping verb `tomove`
>> but cannot craft a Fold version, and would like help.
>>
>> *[FYI I have included an attachment that seems to load and execute
>> properly, but I could NOT get the email versions to load correctly,
>> presumably because of some funny characters.]*
>>
>> tomove=: dyad define
>> while. #y do.
>> x=.x move {. y
>> y =. }.y
>> end.
>> x
>> )
>>
>>
>> NB. The verb `move` for part 1 is very simple:
>>
>> move =: dyad define
>> 'n f t'=. _1 1 1*y - 0 1 1
>> take =. |.n{.>f{x
>> left =. <n}.>f{x
>> put =. <take,~>t{x
>> (left,put) (f,t)}x
>> )
>>
>> NB. the inputs are produced as follows.
>>
>> top =: 0 :0
>> [D]
>> [N] [C]
>> [Z] [M] [P]
>> 1 2 3
>> )
>>
>> state=.deb each ;/ |:|.}:1 5 9&{;._2 top
>>
>> bottom =: 0 :0
>> move 1 from 2 to 1
>> move 3 from 1 to 3
>> move 2 from 2 to 1
>> move 1 from 1 to 2
>> )
>> alpha =. a. {~97+i.26
>> moves =. ".-.&alpha ;._2 bottom
>>
>> NB. finally the result is produced by the next phrase
>>
>> {:every state tomove moves
>>
>>
>> ----------------------------------------------------------------------
>> For information about J forums seehttp://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
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
