For what it's worth, here's what I did for day 13. s0 is the sample data set.
s0=:|:".;._2]0 :0-.':'
0: 3
1: 2
4: 4
6: 4
)
ride=:*/ +/ .* 0 = (|~ _2 2&p.)/
safe=:3 :0
'when len'=: y
dur=. _2 2&p.len
lim=. *./dur NB. delays=: i.*./dur
bs=. >./ (* 1e5&>) */\q:lim
for_block. bs*i.lim%bs do.
delays=. block+i.bs
sol=. block+I. 0=(1>.*/y) +/ .* 0 = dur|when+/delays
if.#sol do.sol return.end.
end.
)
The verb ride was for part 1, and safe was for part 2.
I apologize for not replying earlier, I've had a bit of work to do
this week and have been mostly ignoring aoc stuff.
Good luck,
--
Raul
On Fri, Dec 22, 2017 at 1:24 PM, '[email protected]' via
Programming <[email protected]> wrote:
> That problem took a lot of reading!
>
> Like you, Brian, I started with the boustrophedon cycles:
> example NB. my data has 2 rows: depth,: range:
> 0 1 4 6
> 3 2 4 4
>
> (Brian forms the data into a simple vector of ranges
> 3 2 0 0 4 0 4 )
>
> My verb, cycle, is used to assemble a look-up table of scan positions.
>
> (7$(delay |. cycle)) every <: 3 2 4 4 [ delay =. 0 NB. delay needed
> for part 2
> 0 1 2 1 0 1 2
> 0 1 0 1 0 1 0
> 0 1 2 3 2 1 0
> 0 1 2 3 2 1 0
> Note that the period for a range of r is 2 * (r - 1), and that the
> third and fourth
> row (origin 1!) are identical.
>
> My problem data had 40 odd pairs, with depth between 0 and 92, but
> only 12 distinct values for range, so I set up 12 cycles of length
> 93, and
> looked up the one I needed for each depth used in a make-once use-often
> table.
>
> The function below does part 1 - and tries to do part 2 - with a
> negative
> left argument repesenting the trial delay - its right argument is the 2
> row
> representation of the given input. (It grew rather more complicated
> than
> necessary for part 1 in order to try to solve part 2.)
>
> dostates=: 3 : 0
> 0 dostates y
> :
> if. x > 0 do. e =. echo else. e =. ] end. NB. debugging stuff
> 'd r' =. y
> s =. 0#~#r
> l =. *./ +: <: r NB. lcm of
> cycle lengths
> if. x < 0 do.
> delay =. - 0 <. x
> else.
> delay =. 0
> end.
> c =. ((l <. 2 + >./d) $ (delay |. cycle)) every <: ur =. ~.r NB.
> look-up table of range-positions
> e (;~$) c
> t =. 0
> max =. >:>./d
> if. x > 0 do. max =. | x <. max end.
> for_layer. i.max do.
> if. layer e. d do.
> id =. d i. layer NB.
> rlayer =. id{r NB. which range
> rlu =. ur i. rlayer NB. where in nub of ranges
> scanid =. (<rlu, layer) { c NB. scan position
> if. scanid = 0 do.
> e 'caught'; layer, rlayer
> t =. t + (delay~:0) + layer * rlayer * delay = 0
> end.
> end.
> if. x * x < >:>./d do. e layer; d,: (ur i.r) { (l|layer) {"1 c end.
> end.
> t
> )
>
> It works ok, as does Brian's corrected function:
> ts'day13 datas'
> 0.0338706 8448
> ts'dostates input13'
> 0.000846644 25728
>
> But then I realised this does the job even better! :-
> 13 : '+/*/y{"1~ I. 0 =|~/({.,: (2*(<:@{:)))y' input13
> 1580
>
> That is, the probe is detected by "scanners" for those pairs
> where a range's cycle period divides the corresponding depth.
> It is faster than both the above loopy functions, uses
> more space than Brian's, less than mine.
> ts '13 : ''+/*/y{"1~ I. 0 =|~/({.,: (2*(<:@{:)))y'' input13'
> 5.18354e_5 12288
>
> The following variant shows how I managed to do part 2, albeit
> very slowly!
> 10 (13 : '+/*/y{"1~ I. 0 =|~/(0,~x) + ({.,: (2*(<:@{:)))y') example
> 0
> ie, you add the delay to the cycle period, so that now
> (a range's cycle-period plus the delay) divides the corresponding
> depth.
> We seek the lowest delay such that for none of these modified pairs
> is the period-plus-delay a divisor of the depth.
>
> I suspect there's a better way for part 2, but haven't looked!
>
> Cheers,
>
> Mike
>
>
>
> On 21/12/2017 12:08, Brian Schott wrote:
>> I found my error.
>> ud =: i. , }:@}.@i.@- NB. added }:@
>>
>> Also, the approach is very inefficient, but works, now.
>>
>> On Wed, Dec 20, 2017 at 6:29 PM, Brian Schott <schott.brian@gmail.
> com>
>> wrote:
>>
>>> I am getting the wrong answer for part 1 of day 13.
>>> Can someone give me a hint what I am misunderstanding?
>>>
>>> My main verb is day13, but it depends on the following simple verbs.
>>>
>>> ud =: i.,}.@i.@-
>>> spos =: [{.@:|."0 1 ud@]
>>> (i. 6) spos"0/ ]3 2 0 0 4 0 4
>>> 0 0 0 0 0 0 0
>>> 1 1 0 0 1 0 1
>>> 2 0 0 0 2 0 2
>>> 1 0 0 0 3 0 3
>>> 0 1 0 0 2 0 2
>>> 0 0 0 0 1 0 1
>>>
>>>
>>> day13 =: verb define
>>> ranges =. y
>>> severity =. 0
>>> for_secs. i. # ranges do.
>>> state =. secs spos"0 ranges
>>> if. 0 = secs { state do.
>>> if. secs{ ranges do.
>>> severity =. severity+secs*secs{ranges
>>> end.
>>> end.
>>> end.
>>> severity
>>> )
>>> day13 3 2 0 0 4 0 4
>>> 24
>>> day13 $.^:_1 datas
>>> 2052
>>>
>>>
>>>
>>> For more completeness, my data collection used the following ideas.
>>>
>>> datam =: data rplc ':';' '
>>> datas =: ({:|: ". ;._2 datam)({.|: ". ;._2 datam)} 1 $. 99
>>>
>>> TIA,
>>>
>>> --
>>> (B=)
>>>
>>
>
> ----------------------------------------------------------------------
> For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
