So you think you're hot stuff? Reverse THIS

import binarytreeutils as butt
butt.reverse()

File: 1488452933045.png (211KB, 2000x1667px) Image search: [Google]

211KB, 2000x1667px

>>59196608
> coders

>>59196608
Do a pre-order traversal, then insert each element into the data structure with a reversed predicate.
Otherwise, just reverse the in-order sequence.
I'm not being careful, so probably what I'm saying is not entirely correct.

>>59196608

def reverse_tree(root):
    if root.left is None and root.right is None:
        return
    else: 
        if root.left is not None:
            root.right = reverse_tree(root.left)
        if root_right is not None:
            root_left = reverse_tree(root.right)
    return

I'm too lazy to test this right now, but I think this is how you do it in Python.

>>59196676

def reverse_tree(root):
    if root.left is not None:
        root.right = reverse_tree(root.left)
    if root_right is not None:
        root_left = reverse_tree(root.right)
    return

Cleaned it up

File: zx.png (407KB, 1000x700px) Image search: [Google]

407KB, 1000x700px

>>59196652

>>59196691

def reverse_tree(root):
    if root.left is not None:
        root.right = reverse_tree(root.left)
    if root.right is not None:
        root.left = reverse_tree(root.right)
    return

Whoops found typo.

>>59196716

def reverse_tree(root):
    if root.left is not None:
        root.right = reverse_tree(root.left)
    if root.right is not None:
        root.left = reverse_tree(root.right)
    return root

And another typo fixed. I'm amazed I'm still this awake after 3.

File: fixed.png (153KB, 2000x1667px) Image search: [Google]

153KB, 2000x1667px

>>59196608
Fixed.

>>59196780
Does it work?

>>59196780
You're overwriting right with left, and then overwriting left with right. You need a temporary variable for a subtree or alternatively use a swap-function.

File: laughing.png (98KB, 390x310px) Image search: [Google]

98KB, 390x310px

>>59196608
>>59196691
>>59196676
>ITT: People that can't swap values.

>>59197537
>>59196652
These.

>>59196608

CL-USER> (defun reverse-tree (tree)
  (symbol-macrolet ((l (second tree))
                    (r (third tree)))
    (rotatef l r)
    (when r (reverse-tree r))
    (when l (reverse-tree l)))
  tree)
CL-USER> (reverse-tree '(8 (3 (1 nil nil) (6 (4 nil nil) (7 nil nil))) (10 nil (14 (13 nil nil) nil))))
(8 (10 (14 NIL (13 NIL NIL)) NIL) (3 (6 (7 NIL NIL) (4 NIL NIL)) (1 NIL NIL)))

>inb4 nil nil))nil)))nil)))

>>59198383
Lisp people are funny)))

>>59198398
I'm thorry, ith that tharcathm?

>>59198383
Now with atom leaves for brevity:

CL-USER> (defun reverse-tree (tree)
  (symbol-macrolet ((l (second tree))
                    (r (third tree)))
    (rotatef l r)
    (macrolet ((nodep (n) (and n (listp n))))
      (when (nodep r) (reverse-tree r))
      (when (nodep l) (reverse-tree l))))
  tree)
CL-USER> (reverse-tree '(8 (3 1 (6 4 7)) (10 nil (14 13 nil))))
(8 (10 NIL (14 13 NIL)) (3 1 (6 4 7)))

>>59196608
>2017
>Not using neural networks for this type of tasks

>>59198571
And golfing a bit:

(defun reverse-tree (tree)
  (when (consp tree)
   (symbol-macrolet ((l (second tree))
                    (r (third tree)))
    (rotatef l r)
    (reverse-tree r)
    (reverse-tree l)))
  tree)

>>59198651
The indentation is a column off here and there, but fuck it.

File: gondola.png (10KB, 531x339px) Image search: [Google]

10KB, 531x339px

>>59196608
[obligatory we don't do your homework post]

>>59196608
define reverse, nigger

And for the OOP in OOL faggots

(defclass tree ()
  ((content :accessor content :initarg :content)))

(defclass leaf (tree) ())

(defclass node (leaf)
  ((left :accessor left :initarg :left)
   (right :accessor right :initarg :right)))

(defun make-tree (args)
  (if (consp args)
    (make-instance 'node
                   :content (first args)
                   :left (make-tree (second args))
                   :right (make-tree (third args)))
    (make-instance 'leaf :content args)))


(defmethod print-object ((leaf leaf) s)
  (format s "~s" (content leaf)))

(defmethod print-object ((node node) s)
  (format s "(~a ~a ~a)" (content node) (left node) (right node)))

(defmethod reverse-tree ((leaf leaf)) leaf)

(defmethod reverse-tree ((node node))
  (with-slots (left right) node
    (rotatef left right)
    (reverse-tree left)
    (reverse-tree right))
  node)

>>59199185

CL-USER> (make-tree '(8 (3 1 (6 4 7)) (10 nil (14 13 nil))))
(8 (3 1 (6 4 7)) (10 NIL (14 13 NIL)))
CL-USER> (reverse-tree (make-tree '(8 (3 1 (6 4 7)) (10 nil (14 13 nil)))))
(8 (10 (14 NIL 13) NIL) (3 (6 7 4) 1))

>>59198383
>>59198571
>>59198651
>>59199185
>>59199201
What esoteric programming language is this?

>>59199290
lisp I think

>>59199290
Common Lisp, not esoteric at all, just a tad obscure nowadays

>>59199290
>>59199363
http://learnlispthehardway.org/try-lisp/
http://www.gigamonkeys.com/book/
Have fun

File: unimpressed.jpg (249KB, 1023x843px) Image search: [Google]

249KB, 1023x843px

>>59199403
Why would I wanna waste my time learning that shit?

>>59199441
http://www.gigamonkeys.com/book/introduction-why-lisp.html
The very first chapter explains why in just a couple of minutes.

public void invertTree(Node node) {
  if (node == null) {
    return;
  }

  Node temp = node.left;
  node.left = node.right;
  node.right = temp;

  invertTree(node.left);
  invertTree(node.right);
}

h-how did i do gee??

>>59199441
If you have ADHD, PTSD, or some other kind of short-sighted autism, you could try reading this instead:
https://stackoverflow.com/questions/2036244/whats-so-great-about-lisp

>>59199488
>m-my language gets shit done quicker!
That's pretty much what every language out there claims.

>>59199516
Name 1 (one) relevant piece of software written in LISP. I'll wait.

>>59199557
https://en.wikipedia.org/wiki/Common_Lisp#Applications
https://en.wikipedia.org/wiki/Category:Common_Lisp_software
These lists are, of course, vastly incomplete

>>59199557
https://en.wikipedia.org/wiki/Dynamic_Analysis_and_Replanning_Tool
Your Freedoms

SwapChildren(Node* n) 
{
    if(!n) return;
    swap(n->left, n->right);
    SwapChildren(n->left);
    SwapChildren(n->right);
}

reverse :: Tree a -> Tree a
reverse Nil = Nil
reverse (Node x l r) = Node x (reverse r) (reverse l)

>>59199629
>outdated military shit
Not relevant.

>>59199611
Don't see anything relevant on those lists. Is that all you got?

>>59199693
Man, Haskell is the pinnacle of elegancy.
Wish I could find a use case for it outside of university assignments.

>>59199713
>>>/v/

>>59199611
>>59199629
>half a dozen things you've never even heard of happened to be written in LISP
>an entire world of mainstream software out there is written in other programming languages
>"LEL LISP IS DA BEST"
Maximum autism.

>>59199724
you're inevitably going to run into a situation where you'll really wish you were working in a procedural language instead
just forget about it

File: prince_of_all_blabla.jpg (15KB, 424x240px) Image search: [Google]

15KB, 424x240px

>>59199441
>BLABLA POWERFULL BLABLA HOMOICONIC BLABLA MACROS BLABLA MEME DSLS TO MAKE THE CODE EVEN MORE UNREADABLE BLABLA PRINCE OF ALL SAY- PROGRAMMING LANGUAGES

>>59199763
>muh (((java))) runz ebarywer so its de best obdion :D

>Hush little niglet, don't say a word
>And never mind that noise jew heard
>It's just ((((the beast)))) under jewr bed
>In jewr closet, in jewr head

>>59199785
There's always a reader-macro for you if you want m-expressions and brackets

File: tribbered.png (136KB, 320x371px) Image search: [Google]

136KB, 320x371px

>>59199872
And then the next idiot to maintain the code needs to decipher it.

>>59199956
Any Lisp dialect this side of the 70's is a breeze to read

>>59199812
Quality post.

>>59200029
Thankth

>>59200002
>Any Lisp dialect this side of the 70's is a breeze to read

>>59200101
Unless you are deliberately illiterate, of course

>>59200314
You have to be deliberately retarded to believe that, of course.

>>59200362
Pray do tell, what is your language of choice?

>>59200457
Depends. Most of them aren't production ready, yet.