Dany gituser768

Quines.

A quine is a program which produces its own sourcecode as its output. Typically, the trick is to use a format string with a call to a print or printf function. Since lisps can easily treat sourcecode as any other data, writting a quine in lisp is not as mind-bending an excersise as in other languages (see the examples here). Additionally, access to anonymous functions in Clojure makes it easy to get the recursion required for a quine.

Approach

Writing a quine initially seems a daunting task, but once it's broken down a bit, it becomes surprisingly easy. Armed with lambdas and syntax quoting, all we need to do is write a function which returns the argument passed to it wrapped in lambda syntax, and applied to the argument wrapped in syntax quoting.

#Gorilla REPL Check it out!

You can view the worksheet here

Permutations of a String

The task of listing every permutation of a string is trivial when the string contains only two characters. Using this knowledge, the same problem can be solved for a string of three characters relatively easily. Accordingly, the permutations of a string of length n are easy to list if we know the permutations of a substring of length n-1.

This property is easy to see, if not obvious within a few minutes of thinking about this problem. Since the problem can be simply defined recursively, it can also be solved recursively with relative ease. In this solution, I use Clojure to demonstrate that recursion lends itself nicely to functional programming.

Brainstorming With Example Input

Binary Search Trees

A Binary Search Tree (BST) is a data structure consisting of nodes, each of which has a value and references to two other nodes; one with a value larger than the current node's value, and one with a value smaller. If there are no values larger (or smaller) than the value at the current node, then the reference contains the null pointer.

Consequentially, operations on binary trees are most naturally defined recursively. As such, Clojure is perfect for this week's task!

	#include <GL/freeglut.h>
	#include <vector>
	#include <cmath>

	const double pi = 3.141593;

	typedef struct PhysVector {
	float x;
	float y;
	};

	#include <GL/freeglut.h>
	#include <vector>
	#include <cmath>

	const double pi = 3.141593;

	typedef struct PhysVector {
	float x;
	float y;
	};

	(def my-list
	[1 2 7 9 2 4 27 3 8 109 384 921 84 81722 94 92 7 4929 48 78 733 98 9 7 7 7 7 6 5 4332 9 2 1])

	(defn qsort
	"Quicksort implementation"
	[v]
	(let [pivot (last v)]
	(cond
	(> (count v) 1)
	(->> (vector ;; TODO Is there a better way to join three vectors?

	mylist = [1, 4, 6, 2, 5, 1, 4, 5, 5, 59, 3, 4, 5]

	def move_to(v, oldi, newi):
	tmp = v[oldi]
	del v[oldi]
	v.insert(newi, tmp)


	def qsort(v):
	pivot_index = len(v)