@ Raul Miller
Back in Win 10 jqt now. Here's what I get for inputting the first four
functions:
move_table=:
<:(,|."1)(#~0<*/"1)~.,/,/_3&{.\@/:~"1(,|:"2)>|:((;|.)@(1++)+/)\i.5
flip=: ~: (i.15)&e.
legal_moves=: [ #~ 6 = 2 #. {
search=:3 :0
((15#1) flip y) search i.0 3
NB. x: board; y: moves
:
if. 1=+/x do. y return. end.
for_move. move_table legal_moves x do.
r=.(x flip move) search move,y
if. #r do. r return. end.
end.
i.0 3
)
|syntax error
| )
Michael
On Thu, Jun 8, 2017 at 8:55 AM, Raul Miller <[email protected]> wrote:
> I cannot reproduce that spelling error you are getting.
>
> This suggests to me that either (a) your implementation of J (or some
> part of the infrastructure it relies on) is damaged, or (b) there's an
> illegal character hidden somewhere in your copy of that line.
>
> That said, note that while I did try using jqt's Run > Clipboard menu
> option when trying to reproduce your problem, I normally run this as a
> script (File > New temp; paste code into the green window; File > Save
> in the green window; Run > Load Script also in that green window, then
> go back to the yellow window to try it out).
>
> Meanwhile:
>
> solitaire 0 10 14
> No solution
> timespacex 'solitaire 0 10 14'
> 6.53433 41600
>
> Thanks,
>
> --
> Raul
>
>
> On Thu, Jun 8, 2017 at 8:37 AM, Michael Rice <[email protected]> wrote:
> > I've tried inputting your code in jqt several times, each time with a new
> > jqt terminal and keep encountering errors. Here's the last try:
> >
> > move_table=:
> > <:(,|."1)(#~0<*/"1)~.,/,/_3&{.\@/:~"1(,|:"2)>|:((;|.)@(1++)+/)\i.5
> >
> > flip=: ~: (i.15)&e.
> >
> > legal_moves=: [ #~ 6 = 2 #. {
> >
> > search=:3 :0
> > ((15#1) flip y) search i.0 3
> > NB. x: board; y: moves
> > :
> > if. 1=+/x do. y return. end.
> > for_move. move_table legal_moves x do.
> > r=.(x flip move) search move,y
> > if. #r do. r return. end.
> > end.
> > i.0 3
> >
> > solitaire=:3 :0
> > path=. search y
> > if. #path do. path else. 'No solution' end.
> > |spelling error
> > | if. #path do. path else. 'No solution' end.
> > | ^
> >
> > B/t/w, does it work for:
> >
> > solitaire 0 10 14?
> >
> > I remember you had some question about that.
> >
> > Michael
> >
> > On Thu, Jun 8, 2017 at 6:44 AM, Raul Miller <[email protected]>
> wrote:
> >
> >> > I've already posted code for changing a board and extracting legal
> moves
> >> > from it that satisfactorily produced a path to a win. If you like,
> you're
> >> > free to take a swing at finishing it any way you think will work.
> >>
> >> I thought I had posted a finished implementation?
> >>
> >> http://www.jsoftware.com/pipermail/programming/2017-June/047522.html
> >>
> >> solitaire 5
> >> 14 9 5
> >> 2 5 9
> >> 3 4 5
> >> 10 6 3
> >> 1 3 6
> >> 12 7 3
> >> 13 8 4
> >> 9 5 2
> >> 2 4 7
> >> 11 7 4
> >> 6 3 1
> >> 0 1 3
> >> 3 4 5
> >>
> >> If you feel there's something wrong with this approach, let me know
> >> and I'll see if I can wrap my head around those issues.
> >>
> >> Thanks,
> >>
> >> --
> >> Raul
> >>
> >>
> >> On Wed, Jun 7, 2017 at 11:21 PM, Michael Rice <[email protected]>
> wrote:
> >> > @ Raul Miller
> >> >
> >> > "I guess I disagree with the model you posted here, about how to
> >> > implement the peg game"
> >> >
> >> > I've already posted code for changing a board and extracting legal
> moves
> >> > from it that satisfactorily produced a path to a win. If you like,
> you're
> >> > free to take a swing at finishing it any way you think will work.
> Here's
> >> my
> >> > Clojure code (see below) for the two remaining functions, *search* and
> >> > *solitaire*.
> >> >
> >> > The *recur* function calls just act as calls to the original function
> >> that
> >> > called them, and could be replaced with the name of that function and
> get
> >> > the same result.
> >> >
> >> > Search function:
> >> > That first *if-let* tries to pull a move off the top of the incoming
> >> moves
> >> > list. If it fails, i.e., moves was empty, it drops through to the *if*
> >> > statement below it where it checks the board for just one remaining
> peg.
> >> If
> >> > true, it returns the path to the solution. If not it checks the
> history
> >> > stack. If it's empty, it prints "No solution." Otherwise it pulls a
> board
> >> > and move-list (the move list being the rest of the moves for a
> previous
> >> > move that led to a dead-end) off the history stack, and recurs with
> that
> >> > board, its move list, the path list minus the last move added, and the
> >> rest
> >> > of the history stack. As you can see, the elements of the history
> stack
> >> are
> >> > lists with two sublists, one for the board, the other for its
> remaining
> >> > moves.
> >> >
> >> > If the search function gets a move, you can see for yourself what it
> >> does:
> >> > 1) create the next board
> >> > 2) recur(next-board, moves for next-board, move added to path, the
> >> current
> >> > board and the rest of its moves pushed onto the history stack)
> >> >
> >> > Solitaire function:
> >> > The board is modeled like the J code I posted.
> >> > The recursion is kicked off with that board, its moves, an empty
> vector
> >> to
> >> > accumulate the path (see note below), and an empty history stack (a
> >> list).
> >> >
> >> > Note: A nice feature of Clojure is using a vector instead of a list to
> >> > accumulate a path. An item is added to a list at its top. An item is
> >> added
> >> > to a vector at its end. Popping a list removes the first element.
> >> Popping a
> >> > vector removes the last element. Using a list to accumulate a path
> >> requires
> >> > reversing the list before printing it. Using a vector eliminates that
> >> > requirement. Lists are enclosed in parentheses, vectors in brackets.
> >> >
> >> > If you, or anyone else, pursues this, feel free to ask any questions
> you
> >> > might have.
> >> >
> >> > Michael
> >> >
> >> > Code (Change font to fixed-width if it doesn't come across as that.
> It's
> >> > easier to read with proper indentatation):
> >> >
> >> > (defn search
> >> > [board moves path history]
> >> > (if-let [move (when-let [s (seq moves)] (first s))]
> >> > (let [next-board (make-move board move)]
> >> > (recur next-board (find-moves next-board) (conj path move) (conj
> >> > history (list board (rest moves)))))
> >> > (if (= (reduce + 0 board) 1)
> >> > path
> >> > (if-let [backtrack (when-let [s (seq history)] (first s))]
> >> > (let [[board moves] backtrack]
> >> > (recur board moves (pop path) (rest history)))
> >> > "No solution."))))
> >> >
> >> > (defn solitaire
> >> > ; lst: empty board location(s)
> >> > [lst]
> >> > (let [board (reduce #(assoc %1 %2 0) [1 1 1 1 1 1 1 1 1 1 1 1 1 1 1]
> >> > lst)]
> >> > (search board (find-moves board) [] ())))
> >> >
> >> > ;user=> (solitaire '(5))
> >> > ;[[0 2 5] [3 1 0] [5 4 3] [6 3 1] [0 1 3] [11 7 4] [3 4 5] [9 5 2]
> [13 12
> >> > 11] [10 11 12] [12 8 5] [2 5 9] [14 9 5]]
> >> >
> >> >
> >> >
> >> > On Wed, Jun 7, 2017 at 3:23 PM, Raul Miller <[email protected]>
> >> wrote:
> >> >
> >> >> Oh... well...
> >> >>
> >> >> I guess I disagree with the model you posted here, about how to
> >> >> implement the peg game: I think that a spec requiring five arrays is
> >> >> unnecessarily redundant.
> >> >>
> >> >> That said, I did make an error in one of my posts, which I am only
> >> >> just now realizing: the move_table depends on the size of the board,
> >> >> and I didn't deal with that in my supposed general case
> >> >> implementation. Fortunately, the fix is straightforward, and I could
> >> >> post that if you wanted.
> >> >>
> >> >> Anyways... to address the complexity argument you're raising, you can
> >> >> have up to four hetrogenous unboxed array parameters in a recursive
> >> >> context in J without resorting to objects to represent them.
> >> >> Specifically: verbs can take one or two arguments, adverbs give you
> an
> >> >> additional argument and conjunctions another on top of that. With
> >> >> objects, or with boxing, you can go much higher - but that can indeed
> >> >> feel kludgy if you need an object or box for every recursive
> >> >> invocation. But you can also often rearrange things to not need so
> >> >> many recursive parameters.
> >> >>
> >> >> And for the peg problem, I only see three significant arrays: the
> >> >> board, the moves to reach that board and the list of legal moves.
> >> >> Recursive contexts give you a stack, allowing you to backtrack with
> >> >> these arrays. I'm not seeing why you need more than that?
> >> >>
> >> >> Thanks,
> >> >>
> >> >> --
> >> >> Raul
> >> >>
> >> >> On Wed, Jun 7, 2017 at 2:26 PM, Michael Rice <[email protected]>
> >> wrote:
> >> >> > Thanks for the paste tip. I was unaware of that feature.
> >> >> >
> >> >> > I'm "giving up on" the peg game. I didn't think that needed
> >> identifying
> >> >> as
> >> >> > it's been my only focus. I think of "academic exercises" as
> homework,
> >> >> > seeking answers to which is, rightly, taboo on computer language
> >> >> web-sites.
> >> >> >
> >> >> > The peg game search function has five arrays it recursively
> >> manipulates
> >> >> to
> >> >> > a solution, three of which begin as empty, all having varying
> shapes,
> >> >> even
> >> >> > empty, as they pass through recursions. From what I've read in
> >> >> *Learning J*,
> >> >> > for their heterogeneous shapes they would have to be boxed to be
> >> passed
> >> >> as
> >> >> > a functional parameter, un-boxed inside a recursive pass to be
> >> altered,
> >> >> and
> >> >> > then boxed again to be passed on to the next recursion. I didn't
> say
> >> it
> >> >> was
> >> >> > impossible, just that it seemed kludgy, or, as you put it "forced."
> >> >> >
> >> >> > I spent quite a bit of time with Haskell. As a functional language
> >> it's
> >> >> > hard to beat, but some problems on which I used it I felt like I
> was
> >> >> having
> >> >> > to go around the block just to get next door. Why bother?
> >> >> >
> >> >> > Thanks for your input.
> >> >> >
> >> >> >
> >> >> > On Wed, Jun 7, 2017 at 1:11 PM, Raul Miller <[email protected]
> >
> >> >> wrote:
> >> >> >
> >> >> >> When pasting into gmail, please use "Paste and match style" to
> avoid
> >> >> >> the extra blank lines that someone at google somehow managed to
> work
> >> >> >> into the default Paste action.
> >> >> >>
> >> >> >> That said:
> >> >> >>
> >> >> >> my_empty =: }. 1
> >> >> >> < my_empty
> >> >> >> ┌┐
> >> >> >> ││
> >> >> >> └┘
> >> >> >>
> >> >> >> What you are seeing here is not an empty list of boxes but a box
> >> >> >> containing an empty. Or, ok, yes: "an empty box".
> >> >> >>
> >> >> >> Note also that a: is the same:
> >> >> >>
> >> >> >> a:
> >> >> >> ┌┐
> >> >> >> ││
> >> >> >> └┘
> >> >> >> a: -: <}.1
> >> >> >> 1
> >> >> >>
> >> >> >> (Finally, I should perhaps note that I have no idea what problem
> you
> >> >> >> are giving up on. Usually, though, "academic exercises" - which
> >> >> >> typically focus more on how the goal is reached than on reaching
> the
> >> >> >> goal - tend to feel forced in J.)
> >> >> >>
> >> >> >> Thanks,
> >> >> >>
> >> >> >> --
> >> >> >> Raul
> >> >> >>
> >> >> >>
> >> >> >> On Wed, Jun 7, 2017 at 1:03 PM, Michael Rice <[email protected]
> >
> >> >> wrote:
> >> >> >> > @robert therriault
> >> >> >> >
> >> >> >> > my_empty =: }. 1
> >> >> >> >
> >> >> >> > my_empty
> >> >> >> >
> >> >> >> >
> >> >> >> > f my_empty
> >> >> >> >
> >> >> >> > 1
> >> >> >> >
> >> >> >> > < my_empty
> >> >> >> >
> >> >> >> > ┌┐
> >> >> >> >
> >> >> >> > ││
> >> >> >> >
> >> >> >> > └┘
> >> >> >> >
> >> >> >> >
> >> >> >> > An empty box?
> >> >> >> >
> >> >> >> >
> >> >> >> > I'm beginning to see the problem I was thinking of doing in J is
> >> >> >> ill-suited
> >> >> >> > to the language. It could be done, as it could in any computer
> >> >> language,
> >> >> >> > but the solution would be pretty kludgy.
> >> >> >> >
> >> >> >> >
> >> >> >> > I'll soon think of something else on which to apply J. It's
> already
> >> >> >> > invading my sleep. Going through exercises is no way to get
> into a
> >> >> >> > language. One needs a problem on which to focus it. I've been
> >> wanting
> >> >> to
> >> >> >> > explore cryptography more deeply, and J seems ideal for it.
> >> >> >> >
> >> >> >> >
> >> >> >> > Thanks to all,
> >> >> >> >
> >> >> >> >
> >> >> >> > Michael
> >> >> >> >
> >> >> >> >
> >> >> >> >
> >> >> >> >
> >> >> >> >
> >> >> >> >
> >> >> >> >
> >> >> >> >
> >> >> >> >
> >> >> >> >
> >> >> >> >
> >> >> >> >
> >> >> >> >
> >> >> >> >
> >> >> >> >
> >> >> >> >
> >> >> >> > On Wed, Jun 7, 2017 at 12:01 PM, robert therriault <
> >> >> >> [email protected]>
> >> >> >> > wrote:
> >> >> >> >
> >> >> >> >> I'm going to look at these results through the lens of Shape
> ($)
> >> >> >> >>
> >> >> >> >> f =: (1&,)
> >> >> >> >> f 2
> >> >> >> >> 1 2
> >> >> >> >> $ f 2 NB. shape is 2
> >> >> >> >> 2
> >> >> >> >> f ''
> >> >> >> >> 1
> >> >> >> >> $ f '' NB. shape is 1
> >> >> >> >> 1
> >> >> >> >> empty NB. it is a verb in my environment
> >> >> >> >> (i.0 0)"_
> >> >> >> >> f empty
> >> >> >> >> f empty NB. result of two verbs and no arguments is just the
> two
> >> >> verbs
> >> >> >> >> f empty 2 NB. this is where you expect to have a 1 returned
> >> >> >> >>
> >> >> >> >> $ f empty 2 NB. shape is 1 0
> >> >> >> >> 1 0 NB. one line of no items means no display
> >> >> >> >>
> >> >> >> >> I think it is the second dimension of EMPTY as opposed to NULL
> >> that
> >> >> is
> >> >> >> >> tripping you up.
> >> >> >> >>
> >> >> >> >> NULL=.''
> >> >> >> >> $ NULL
> >> >> >> >> 0
> >> >> >> >> EMPTY
> >> >> >> >> $EMPTY
> >> >> >> >> 0 0
> >> >> >> >> EMPTY-:empty 1
> >> >> >> >> 1
> >> >> >> >>
> >> >> >> >> In answer to your most recent question Michael, I would say
> just
> >> make
> >> >> >> sure
> >> >> >> >> that the empty list that you pass is the right shape.
> >> >> >> >>
> >> >> >> >> Cheers, bob
> >> >> >> >>
> >> >> >> >> > On Jun 7, 2017, at 8:48 AM, Raul Miller <
> [email protected]>
> >> >> >> wrote:
> >> >> >> >> >
> >> >> >> >> > empty is a verb
> >> >> >> >> > f is a verb
> >> >> >> >> >
> >> >> >> >> > so f empty is a verb (a hook)
> >> >> >> >> >
> >> >> >> >> > f=: 1&,
> >> >> >> >> > (f empty) 3
> >> >> >> >> >
> >> >> >> >> >
> >> >> >> >> >
> >> >> >> >> > $(f empty) 3
> >> >> >> >> > 3 0
> >> >> >> >> > $(f empty) 5
> >> >> >> >> > 5 0
> >> >> >> >> >
> >> >> >> >> > The reasons for this are documented at
> >> >> >> >> > http://www.jsoftware.com/help/dictionary/dictf.htm (hooks)
> and
> >> >> >> >> > http://www.jsoftware.com/help/dictionary/d630n.htm (x m&v
> y).
> >> >> >> >> >
> >> >> >> >> > That said, verbs take arguments and empty is a verb - it
> always
> >> >> >> >> > produces an empty result, but only when it gets an argument.
> >> >> >> >> >
> >> >> >> >> > I hope this helps,
> >> >> >> >> >
> >> >> >> >> > --
> >> >> >> >> > Raul
> >> >> >> >> >
> >> >> >> >> >
> >> >> >> >> > On Wed, Jun 7, 2017 at 11:39 AM, Michael Rice <
> >> [email protected]
> >> >> >
> >> >> >> >> wrote:
> >> >> >> >> >> Oops! Guess I creamed empty. Will close and regen Jqt before
> >> >> >> proceeding.
> >> >> >> >> >>
> >> >> >> >> >> Done!
> >> >> >> >> >>
> >> >> >> >> >> f =: (1&,)
> >> >> >> >> >> f 2
> >> >> >> >> >> 1 2
> >> >> >> >> >> f empty
> >> >> >> >> >> f empty
> >> >> >> >> >>
> >> >> >> >> >> Shouldn't it have returned
> >> >> >> >> >>
> >> >> >> >> >> 1
> >> >> >> >> >>
> >> >> >> >> >> ?
> >> >> >> >> >>
> >> >> >> >> >> On Wed, Jun 7, 2017 at 11:22 AM, robert therriault <
> >> >> >> >> [email protected]>
> >> >> >> >> >> wrote:
> >> >> >> >> >>
> >> >> >> >> >>> One thing to remember is that empty is already defined as a
> >> verb
> >> >> >> >> >>>
> >> >> >> >> >>> empty
> >> >> >> >> >>> (i.0 0)"_
> >> >> >> >> >>>
> >> >> >> >> >>> So if you overwrite this you may break some code if you
> have
> >> >> >> previously
> >> >> >> >> >>> relied on the existing verb definition.
> >> >> >> >> >>>
> >> >> >> >> >>> I think along the lines that Pascal mentioned that null
> could
> >> be
> >> >> >> >> similarly
> >> >> >> >> >>> defined as
> >> >> >> >> >>>
> >> >> >> >> >>> null NB. check that it is not already used
> >> >> >> >> >>> |value error: null
> >> >> >> >> >>> null=:(i.0)"_
> >> >> >> >> >>> NULL NB. check that it is not already used - uppercase
> for
> >> >> global
> >> >> >> >> >>> nouns is a convention I like and is often seen in J code
> >> >> >> >> >>> |value error: NULL
> >> >> >> >> >>> NULL=:'' NB. I use this as the null string (same as what
> >> John
> >> >> >> >> suggested)
> >> >> >> >> >>> NULL-:null 2 NB. any argument produces NULL from null
> >> >> >> >> >>> 1
> >> >> >> >> >>>
> >> >> >> >> >>> Hope this helps,
> >> >> >> >> >>>
> >> >> >> >> >>> Cheers, bob
> >> >> >> >> >>>
> >> >> >> >> >>>> On Jun 7, 2017, at 8:09 AM, 'Jon Hough' via Programming <
> >> >> >> >> >>> [email protected]> wrote:
> >> >> >> >> >>>>
> >> >> >> >> >>>>
> >> >> >> >> >>>> I may be wrong in doing this, but I usually write
> >> >> >> >> >>>> empty=: ''
> >> >> >> >> >>>> to signify an empty list, array, matrix etc.
> >> >> >> >> >>>>
> >> >> >> >> >>>>
> >> >> >> >> >>>> On Jun 7, 2017, 23:59, at 23:59, Michael Rice <
> >> >> [email protected]
> >> >> >> >
> >> >> >> >> >>> wrote:
> >> >> >> >> >>>>> Is there a special "noun" for an empty list?
> >> >> >> >> >>>>>
> >> >> >> >> >>>>> Creating one seems enigmatic.
> >> >> >> >> >>>>>
> >> >> >> >> >>>>> empty =: 1 2
> >> >> >> >> >>>>> empty
> >> >> >> >> >>>>> 1 2
> >> >> >> >> >>>>> empty =: }. empty
> >> >> >> >> >>>>> empty
> >> >> >> >> >>>>> 2
> >> >> >> >> >>>>> empty =: }. empty
> >> >> >> >> >>>>> empty
> >> >> >> >> >>>>>
> >> >> >> >> >>>>> empty1 =:
> >> >> >> >> >>>>> |syntax error
> >> >> >> >> >>>>> | empty1=:
> >> >> >> >> >>>>> ------------------------------
> >> ------------------------------
> >> >> >> >> ----------
> >> >> >> >> >>>>> 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
> >> >> >> >>
> >> >> >> >> ------------------------------------------------------------
> >> >> ----------
> >> >> >> >> 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/forum
> s.htm
> >> >>
> >> > ------------------------------------------------------------
> ----------
> >> > For information about J forums see http://www.jsoftware.com/forum
> s.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
