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]>
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
