Topic: Coordinates compertion

[Shay Gaghe]

Here's a simple way to approach it:

Code - Auto/Visual Lisp: [Select]

1. (defun foo ( lst / key rtn )
2.     (setq key (caar lst)
3.           rtn (caadar lst)
4.     )
5.     (foreach grp lst
6.         (foreach pnt (cadr grp)
7.             (if (< (cadr rtn) (cadr pnt))
8.                 (setq rtn pnt
9.                       key (car grp)
10.                 )
11.             )
12.         )
13.     )
14.     (list key rtn)
15. )

Code - Auto/Visual Lisp: [Select]

1. (setq lst
2.    '(
3.         ("a" ((0 2 4) (0 7 0) (0 2 0)))
4.         ("b" ((0 2 0) (0 5 0) (0 2 0)))
5.         ("c" ((3 2 0) (0 2 0) (9 3 0)))
6.     )
7. )

Code - Auto/Visual Lisp: [Select]

1. _$ (foo lst)
2. ("a" (0 7 0))

Code: [Select]

(defun foo ( lst / key rtn )
    (setq key (caar lst)
          rtn (caadar lst)
    )
    (foreach grp lst
        (foreach pnt (cadr grp)
            (if (< (cadr rtn) (cadr pnt))
                (setq rtn pnt
                      key (car grp)
                )
            )
        )
    )
    (list key rtn)
)

;_rtn is the first point to be compared to
;_compare each delivered point's Y to rtn's Y
;_if the delivered point is bigger
;_replace  rtn with that point
;_replace the key with the delivered key
        ;_
;_
i understand it, but i dont know how i would explain it to someone else....what logical steps i need to plan in order  to the solution?

[Lee Mac]

i need to learn what you did.

thanks for the meantime....

You're welcome.

The task could be accomplished in many ways - here is another:

Code - Auto/Visual Lisp: [Select]

1. (defun foo2 ( lst )
2.     (car (vl-sort (apply 'append (mapcar '(lambda ( x ) (mapcar '(lambda ( y ) (list (car x) y)) (cadr x))) lst)) '(lambda ( a b ) (> (cadadr a) (cadadr b)))))
3. )

Code - Auto/Visual Lisp: [Select]

1. _$ (foo2 lst)
2. ("a" (0 7 0))

[Shay Gaghe]

i understand it, but i dont know how i would explain it to someone else....what logical steps i need to plan in order  to the solution?

[Lee Mac]

;_rtn is the first point to be compared to
;_compare each delivered point's Y to rtn's Y
   ;_if the delivered point is bigger
      ;_replace  rtn with that point
      ;_replace the key with the delivered key
        ;_
;_

Your understanding looks to be correct.

[Shay Gaghe]

;_rtn is the first point to be compared to
;_compare each delivered point's Y to rtn's Y
   ;_if the delivered point is bigger
      ;_replace  rtn with that point
      ;_replace the key with the delivered key
        ;_
;_

Your understanding looks to be correct.

how do you map this logic to human language? 

[Lee Mac]

how do you map this logic to human language? 

I don't see the point of your question - you have already described each step of the algorithm in 'human language', which shows that you already understand the algorithm; why then would you need this to be written in such a way to explain to someone else? Is this for a homework assignment?

[Shay Gaghe]

how do you map this logic to human language? 

I don't see the point of your question - you have already described each step of the algorithm in 'human language', which shows that you already understand the algorithm; why then would you need this to be written in such a way to explain to someone else? Is this for a homework assignment?

i spent half day thinking about this while you just solve it like you are sms "good morning" to your girlfriend 

i just preparing myself to help my daughter with her homework

I was always thinking there was  a way to tell the machine what to do as it was your employee, but I cant really see it possible, (otherwise there wasnt a need for programing language i guess).
I do understand the algorithm, and you understand that I understand it because you are a programmer, but if youwarnt  a programmer you wouldn’t understand.

[irneb]

how do you map this logic to human language? 

You mean something like this:

• Keep track of the first point and its key in some local variables.
• Look at each key+point pair in turn, comparing its Y value to the one in that local variable.
• If the current point's Y is larger than the Y in the local variable, replace the contents of the local variables with the current point and its key.
• Once all points have finished being compared, the local variables should now contain the values of the largest point, so return them as the last statement in the function.

I was always thinking there was  a way to tell the machine what to do as it was your employee, but I cant really see it possible, (otherwise there wasnt a need for programing language i guess).

That's still just a pipe dream ... one that was thought up in the 50s - 60s: What's referred to as a 4th generation programming language, i.e. a natural human language. 3rd being the normal programming languages we use mostly (e.g. Lisp / C / Python / etc.), 2nd being assembly code (i.e. CPU instructions as abreviated words), 1st being the 1s and 0s representing the on/off signals the CPU actually receives and sends.


Unfortunately human languages are very complex with lots of ambiguity, not the best thing for a computer to "understand". For these to actually work, you'd need a computer with "true" artificial intelligence, i.e. it would need to "understand" your meaning instead of just following a set of steps.

[Shay Gaghe]

how do you map this logic to human language? 

You mean something like this:

• Keep track of the first point and its key in some local variables.
• Look at each key+point pair in turn, comparing its Y value to the one in that local variable.
• If the current point's Y is larger than the Y in the local variable, replace the contents of the local variables with the current point and its key.
• Once all points have finished being compared, the local variables should now contain the values of the largest point, so return them as the last statement in the function.

I was always thinking there was  a way to tell the machine what to do as it was your employee, but I cant really see it possible, (otherwise there wasnt a need for programing language i guess).

That's still just a pipe dream ... one that was thought up in the 50s - 60s: What's referred to as a 4th generation programming language, i.e. a natural human language. 3rd being the normal programming languages we use mostly (e.g. Lisp / C / Python / etc.), 2nd being assembly code (i.e. CPU instructions as abreviated words), 1st being the 1s and 0s representing the on/off signals the CPU actually receives and sends.


Unfortunately human languages are very complex with lots of ambiguity, not the best thing for a computer to "understand". For these to actually work, you'd need a computer with "true" artificial intelligence, i.e. it would need to "understand" your meaning instead of just following a set of steps.

yaa.. that why a robot can never replace a humen... lets cheers for that 

[roy_043]

Another sort solution:

Code - Auto/Visual Lisp: [Select]

1. ; (testSort2 lst)
2. (defun testSort2 (lst / tmp)
3.   (setq tmp
4.     (vl-sort
5.       (mapcar
6.         '(lambda (sub)
7.           (list
8.             (car sub)
9.             (vl-sort
10.               (cadr sub)
11.               '(lambda (a b) (> (cadr a) (cadr b)))
12.             )
13.           )
14.         )
15.         lst
16.       )
17.       '(lambda (a b) (> (cadr (caadr a)) (cadr (caadr b))))
18.     )
19.   )
20.   (list (caar tmp) (caadar tmp))
21. )

Recursive solution:

Code - Auto/Visual Lisp: [Select]

1. ; (TestRecursive lst nil nil)
2. (defun TestRecursive (lst key pt)
3.   (cond
4.     ((not lst)
5.       (list key pt)
6.     )
7.     ;; No more points in sub:
8.     ((not (cadar lst))
9.       (TestRecursive (cdr lst) key pt)
10.     )
11.     ;; Check if current point has higher Y:
12.     (
13.       (>
14.         (cadr (caadar lst))
15.         (cadr pt)
16.       )
17.       (TestRecursive
18.         (cons
19.           (list (caar lst) (cdadar lst)) ; Remove point from current sub.
20.           (cdr lst)
21.         )
22.         (caar lst)
23.         (caadar lst)
24.       )
25.     )
26.     (T
27.       (TestRecursive
28.         (cons
29.           (list (caar lst) (cdadar lst))
30.           (cdr lst)
31.         )
32.         key
33.         pt
34.       )
35.     )
36.   )
37. )

[irneb]

Actually I would tend to go about it in a functional way - i.e. I'd want a reduce function (but AutoLisp doesn't have such built in). Thus I'd make one for myself. Here's a simplistic (imperative) variant which works in pretty much the same way as Lee's original code:

Code - Auto/Visual Lisp: [Select]

1. (defun reduce (operation lst / accumulator)
2.   (setq accumulator (car lst) operation (eval operation))
3.   (foreach item (cdr lst)
4.     (setq accumulator (operation accumulator item)))
5.   accumulator)

Then I could use that by applying a custom operation onto it - the operation only ever needs to compare two inputs and return whichever it deems the "correct" or some modified value (e.g. when summing a list). In this example case you're looking for the highest Y value inside a list of points. So:

Code - Auto/Visual Lisp: [Select]

1. (defun PointMaxY (pt1 pt2)
2.   (if (> (cadr pt2) (cadr pt1)) pt2 pt1))
3.  
4. ; Test code
5. _$ (reduce 'PointMaxY '((1 2 3) (4 3 2) (2 0 6)))
6. (4 3 2)

Of course, that's just half the issue in your OP. And that's where the map+reduce gives the power behind all this. E.g. extracting the "highest" point from each item in the keyed list:

Code - Auto/Visual Lisp: [Select]

1. _$ (setq lst '(
2.         ("a" ((0 2 4) (0 7 0) (0 2 0)))
3.         ("b" ((0 2 0) (0 5 0) (0 2 0)))
4.         ("c" ((3 2 0) (0 2 0) (9 3 0)))))
5. (("a" ((0 2 4) (0 7 0) (0 2 0))) ("b" ((0 2 0) (0 5 0) (0 2 0))) ("c" ((3 2 0) (0 2 0) (9 3 0))))
6. _$ (mapcar '(lambda (item) (list (car item) (reduce 'PointMaxY (cadr item)))) lst)
7. (("a" (0 7 0)) ("b" (0 5 0)) ("c" (9 3 0)))

And then to extract the highest of each, another reduce on top of that:

Code - Auto/Visual Lisp: [Select]

1. (reduce '(lambda (item1 item2)
2.            (if (> (cadadr item2) (cadadr item1)) item2 item1))
3.         (mapcar '(lambda (item)
4.                    (list (car item) (reduce 'PointMaxY (cadr item))))
5.                 lst))
6. ("a" (0 7 0))

[Lee Mac]

Good generalisation Irné 

For fun, here's another recursive solution, hampered slightly by the data format:

Code - Auto/Visual Lisp: [Select]

1. (defun foo ( lst )
2.     (   (lambda ( bar ) (bar (apply 'append (mapcar '(lambda ( x ) (mapcar '(lambda ( y ) (list (car x) y)) (cadr x))) lst))))
3.         (lambda ( lst )
4.             (if (cdr lst)
5.                 (if (< (car (cdadar lst)) (cadr (cadadr lst)))
6.                     (bar (cdr lst))
7.                     (bar (cons (car lst) (cddr lst)))
8.                 )
9.                 (car lst)
10.             )
11.         )
12.     )
13. )

(EDIT: Updated as per Roy's suggestion below)

[roy_043]

@ Lee: take another look at line 6 of the code in your last post:

Code: [Select]

(cons (cadr lst) (cddr lst))

[Lee Mac]

@ Lee: take another look at line 6 of the code in your last post:

Code: [Select]

(cons (cadr lst) (cddr lst))

Sorry roy, I don't follow? 

[roy_043]

@ Lee: take another look at line 6 of the code in your last post:

Code: [Select]

(cons (cadr lst) (cddr lst))

Sorry roy, I don't follow? 

Code: [Select]

(setq lst '(0 1 2 3 4))
(cons (cadr lst) (cddr lst)) => (1 2 3 4)
(cdr lst) => (1 2 3 4)