From ba85d6137defa4d2f79b260f5bf8dd721b452e78 Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Tue, 7 Aug 2018 14:03:28 +0200
Subject: [PATCH 01/12] Adding Trashtalk to contributors file

---
 CONTRIBUTORS.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index f188deacc..fddd93812 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -57,3 +57,4 @@ NIFR91
 Michal Hanajik
 <br>
 Bendik Samseth
+Trashtalk 

From 492826d6d6ea3cd6231fe4525934106500eeac50 Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Thu, 9 Aug 2018 12:09:22 +0200
Subject: [PATCH 02/12] Bubble sort implementation for Lisp

---
 CONTRIBUTORS.md                                |  1 +
 .../bubble_sort/code/lisp/bubble_sort.lisp     | 18 ++++++++++++++++++
 2 files changed, 19 insertions(+)
 create mode 100644 contents/bubble_sort/code/lisp/bubble_sort.lisp

diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index fddd93812..77269e07c 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -58,3 +58,4 @@ Michal Hanajik
 <br>
 Bendik Samseth
 Trashtalk 
+Trashtalk 
diff --git a/contents/bubble_sort/code/lisp/bubble_sort.lisp b/contents/bubble_sort/code/lisp/bubble_sort.lisp
new file mode 100644
index 000000000..0c4eb860f
--- /dev/null
+++ b/contents/bubble_sort/code/lisp/bubble_sort.lisp
@@ -0,0 +1,18 @@
+;;;;Bubble sort implementation
+
+;;;Swaps to elements in a list (complexity: O(n))
+(defun swap (lst low high)
+    (let ((list-tail (nthcdr low lst)))
+    (rotatef (car list-tail) (elt list-tail (- high low)))
+    lst))
+
+(defun bubble_sort (lst)
+    (dotimes (m (- (length lst) 1) lst)                     ;loop
+        (dotimes (n (- (length lst) (+ 1 m)) lst)           ;loop   
+            (if (> (nth n lst) (nth (+ n 1) lst))           ;if
+            (swap lst n (+ n 1))                            ;then
+            lst))))                                         ;else
+
+;;Use of an array insead of a list would be faster
+;;The built-in sort is also quicker (sort (list 5 4 3 2 1))
+(print (bubble_sort (list 5 4 3 2 1)))
\ No newline at end of file

From e70f287b794eff9f95579390c67c178aa88d7098 Mon Sep 17 00:00:00 2001
From: Eric Berquist <eric.berquist@gmail.com>
Date: Thu, 9 Aug 2018 14:18:49 -0400
Subject: [PATCH 03/12] Add bubble sort implementation in Lisp to book.

---
 contents/bubble_sort/bubble_sort.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/contents/bubble_sort/bubble_sort.md b/contents/bubble_sort/bubble_sort.md
index 20716a107..423a4404b 100644
--- a/contents/bubble_sort/bubble_sort.md
+++ b/contents/bubble_sort/bubble_sort.md
@@ -44,6 +44,8 @@ This means that we need to go through the vector $$\mathcal{O}(n^2)$$ times with
 [import:1-11, lang:"crystal"](code/crystal/bubble.cr)
 {% sample lang="php" %}
 [import:3-15, lang:"php"](code/php/bubble_sort.php)
+{% sample lang="lisp" %}
+[import:3-14, lang:"lisp"](code/lisp/bubble_sort.lisp)
 {% endmethod %}
 
 ... And that's it for the simplest bubble sort method.
@@ -93,6 +95,8 @@ Program.cs
 [import, lang:"crystal"](code/crystal/bubble.cr)
 {% sample lang="php" %}
 [import, lang:"php"](code/php/bubble_sort.php)
+{% sample lang="lisp" %}
+[import, lang:"lisp"](code/lisp/bubble_sort.lisp)
 {% endmethod %}
 
 <script>

From db9f92961b2729d21bdec9a3f2e99c6dbd05a4d6 Mon Sep 17 00:00:00 2001
From: Eric Berquist <eric.berquist@gmail.com>
Date: Thu, 9 Aug 2018 14:19:37 -0400
Subject: [PATCH 04/12] Add EditorConfig rule for Lisp.

---
 .editorconfig | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/.editorconfig b/.editorconfig
index a71ed6e9f..87fd65028 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -75,6 +75,11 @@ indent_size = 2
 indent_style = space
 indent_size = 2
 
+# Lisp
+[*.lisp]
+indent_style = space
+indent_size = 2
+
 # Matlab
 [*.m]
 indent_style = space

From 05c3caa11718efcf80fc7460862be9042e8d32a6 Mon Sep 17 00:00:00 2001
From: Eric Berquist <eric.berquist@gmail.com>
Date: Thu, 9 Aug 2018 14:19:53 -0400
Subject: [PATCH 05/12] Add Lisp to language picker.

---
 book.json | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/book.json b/book.json
index 98a948994..230843bef 100644
--- a/book.json
+++ b/book.json
@@ -127,6 +127,10 @@
         {
           "lang": "php",
           "name": "PHP"
+        },
+        {
+          "lang": "lisp",
+          "name": "Lisp"
         }
       ]
     }

From 7681e949e39f63abcc23395c943251dfa9724c96 Mon Sep 17 00:00:00 2001
From: Eric Berquist <eric.berquist@gmail.com>
Date: Thu, 9 Aug 2018 14:20:58 -0400
Subject: [PATCH 06/12] Fix CONTRIBUTORS.

---
 CONTRIBUTORS.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index 77269e07c..5f6ae38dc 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -57,5 +57,5 @@ NIFR91
 Michal Hanajik
 <br>
 Bendik Samseth
-Trashtalk 
-Trashtalk 
+<br>
+Trashtalk

From 2226a8c87c544540d43b3d251b52187286e53157 Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Fri, 10 Aug 2018 19:59:12 +0200
Subject: [PATCH 07/12] Refactored: 4 to 2 spaces and renamed things.

---
 contents/bubble_sort/bubble_sort.md           |  2 +-
 .../bubble_sort/code/lisp/bubble_sort.lisp    | 40 ++++++++++++-------
 2 files changed, 27 insertions(+), 15 deletions(-)

diff --git a/contents/bubble_sort/bubble_sort.md b/contents/bubble_sort/bubble_sort.md
index 423a4404b..b86b6eb3a 100644
--- a/contents/bubble_sort/bubble_sort.md
+++ b/contents/bubble_sort/bubble_sort.md
@@ -45,7 +45,7 @@ This means that we need to go through the vector $$\mathcal{O}(n^2)$$ times with
 {% sample lang="php" %}
 [import:3-15, lang:"php"](code/php/bubble_sort.php)
 {% sample lang="lisp" %}
-[import:3-14, lang:"lisp"](code/lisp/bubble_sort.lisp)
+[import:3-15, lang:"lisp"](code/lisp/bubble_sort.lisp)
 {% endmethod %}
 
 ... And that's it for the simplest bubble sort method.
diff --git a/contents/bubble_sort/code/lisp/bubble_sort.lisp b/contents/bubble_sort/code/lisp/bubble_sort.lisp
index 0c4eb860f..d55efce76 100644
--- a/contents/bubble_sort/code/lisp/bubble_sort.lisp
+++ b/contents/bubble_sort/code/lisp/bubble_sort.lisp
@@ -1,18 +1,30 @@
-;;;;Bubble sort implementation
+;;;; Bubble sort implementation
 
-;;;Swaps to elements in a list (complexity: O(n))
+;;; Swaps two elements in a list (complexity: O(n))
 (defun swap (lst low high)
-    (let ((list-tail (nthcdr low lst)))
-    (rotatef (car list-tail) (elt list-tail (- high low)))
-    lst))
+  (let ((list-tail (nthcdr low lst)))
+  (rotatef (car list-tail) (elt list-tail (- high low)))
+  lst))
 
-(defun bubble_sort (lst)
-    (dotimes (m (- (length lst) 1) lst)                     ;loop
-        (dotimes (n (- (length lst) (+ 1 m)) lst)           ;loop   
-            (if (> (nth n lst) (nth (+ n 1) lst))           ;if
-            (swap lst n (+ n 1))                            ;then
-            lst))))                                         ;else
+(defun bubble-sort (lst)
+  (dotimes (m (- (length lst) 1) lst)           ;loop
+    (dotimes (n (- (length lst) (+ 1 m)) lst)   ;loop   
+      (if (> (nth n lst) (nth (+ n 1) lst))     ;if
+      (swap lst n (+ n 1))                      ;then
+      lst))))                                   ;else
 
-;;Use of an array insead of a list would be faster
-;;The built-in sort is also quicker (sort (list 5 4 3 2 1))
-(print (bubble_sort (list 5 4 3 2 1)))
\ No newline at end of file
+;; Use of an array instead of a list would be faster
+(print 
+  (bubble-sort (list 5 4 3 2 1)))
+(print
+  (bubble-sort (list 1 2 3 3 2 1)))
+
+;; The built-in sort is quicker, see the usage below
+;; quick test
+(assert 
+  (equal  (bubble-sort (list 5 4 3 2 1))
+          (sort '(1 2 3 4 5) #'<)))
+
+(assert 
+  (equal  (bubble-sort (list 1 2 3 3 2 1))
+          (sort '(1 2 3 3 2 1) #'<)))

From c08f07d6498cf36d4b7fcd7f1a466650e2bd4c78 Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Sun, 12 Aug 2018 19:14:07 +0200
Subject: [PATCH 08/12] Removed comparison

---
 contents/bubble_sort/code/lisp/bubble_sort.lisp | 12 +-----------
 1 file changed, 1 insertion(+), 11 deletions(-)

diff --git a/contents/bubble_sort/code/lisp/bubble_sort.lisp b/contents/bubble_sort/code/lisp/bubble_sort.lisp
index d55efce76..48d5870f2 100644
--- a/contents/bubble_sort/code/lisp/bubble_sort.lisp
+++ b/contents/bubble_sort/code/lisp/bubble_sort.lisp
@@ -13,18 +13,8 @@
       (swap lst n (+ n 1))                      ;then
       lst))))                                   ;else
 
-;; Use of an array instead of a list would be faster
+;; The built-in sort: (sort (list 5 4 3 2 1) #'<)
 (print 
   (bubble-sort (list 5 4 3 2 1)))
 (print
   (bubble-sort (list 1 2 3 3 2 1)))
-
-;; The built-in sort is quicker, see the usage below
-;; quick test
-(assert 
-  (equal  (bubble-sort (list 5 4 3 2 1))
-          (sort '(1 2 3 4 5) #'<)))
-
-(assert 
-  (equal  (bubble-sort (list 1 2 3 3 2 1))
-          (sort '(1 2 3 3 2 1) #'<)))

From 555691271b801dc93993b74c4523f4aea616dd0a Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Tue, 14 Aug 2018 12:56:47 +0200
Subject: [PATCH 09/12] Redid the bubble-sort to stop using inefficient swap.

---
 .../bubble_sort/code/lisp/bubble_sort.lisp    | 35 +++++++++++++------
 1 file changed, 24 insertions(+), 11 deletions(-)

diff --git a/contents/bubble_sort/code/lisp/bubble_sort.lisp b/contents/bubble_sort/code/lisp/bubble_sort.lisp
index 48d5870f2..7266fa0fe 100644
--- a/contents/bubble_sort/code/lisp/bubble_sort.lisp
+++ b/contents/bubble_sort/code/lisp/bubble_sort.lisp
@@ -1,17 +1,30 @@
 ;;;; Bubble sort implementation
 
-;;; Swaps two elements in a list (complexity: O(n))
-(defun swap (lst low high)
-  (let ((list-tail (nthcdr low lst)))
-  (rotatef (car list-tail) (elt list-tail (- high low)))
-  lst))
+(defun bubble-up (list)
+  (if
+    (< (length list) 2) 
+    list  
+    (if 
+      (> (first list) (second list))
+      (cons 
+        (second list) 
+        (bubble-up 
+          (cons 
+            (first list) 
+            (rest (rest list)))))
+            
+      (cons 
+        (first list)
+        (bubble-up
+          (cons
+            (second list)
+            (rest (rest list))))))))
 
-(defun bubble-sort (lst)
-  (dotimes (m (- (length lst) 1) lst)           ;loop
-    (dotimes (n (- (length lst) (+ 1 m)) lst)   ;loop   
-      (if (> (nth n lst) (nth (+ n 1) lst))     ;if
-      (swap lst n (+ n 1))                      ;then
-      lst))))                                   ;else
+(defun bubble-sort (list)
+  (if 
+    (equal list (bubble-up list))
+    list
+    (bubble-sort (bubble-up list))))
 
 ;; The built-in sort: (sort (list 5 4 3 2 1) #'<)
 (print 

From ffbc7abb594467691035ee5f21bda70714208d53 Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Tue, 14 Aug 2018 14:09:04 +0200
Subject: [PATCH 10/12] Updated bubble_sort.md to make the code fit in the
 textbox.

---
 contents/bubble_sort/bubble_sort.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contents/bubble_sort/bubble_sort.md b/contents/bubble_sort/bubble_sort.md
index b86b6eb3a..88f9418ed 100644
--- a/contents/bubble_sort/bubble_sort.md
+++ b/contents/bubble_sort/bubble_sort.md
@@ -45,7 +45,7 @@ This means that we need to go through the vector $$\mathcal{O}(n^2)$$ times with
 {% sample lang="php" %}
 [import:3-15, lang:"php"](code/php/bubble_sort.php)
 {% sample lang="lisp" %}
-[import:3-15, lang:"lisp"](code/lisp/bubble_sort.lisp)
+[import:3-28, lang:"lisp"](code/lisp/bubble_sort.lisp)
 {% endmethod %}
 
 ... And that's it for the simplest bubble sort method.

From 3ee257f2477484b88d955a480bbe565d473ef24a Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Tue, 14 Aug 2018 15:00:47 +0200
Subject: [PATCH 11/12] Made bubble-sort skip already sorted items. Updated
 bubble-sort.md

---
 contents/bubble_sort/bubble_sort.md             |  2 +-
 contents/bubble_sort/code/lisp/bubble_sort.lisp | 14 +++++++-------
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/contents/bubble_sort/bubble_sort.md b/contents/bubble_sort/bubble_sort.md
index 88f9418ed..4d9a70fdf 100644
--- a/contents/bubble_sort/bubble_sort.md
+++ b/contents/bubble_sort/bubble_sort.md
@@ -45,7 +45,7 @@ This means that we need to go through the vector $$\mathcal{O}(n^2)$$ times with
 {% sample lang="php" %}
 [import:3-15, lang:"php"](code/php/bubble_sort.php)
 {% sample lang="lisp" %}
-[import:3-28, lang:"lisp"](code/lisp/bubble_sort.lisp)
+[import:3-30, lang:"lisp"](code/lisp/bubble_sort.lisp)
 {% endmethod %}
 
 ... And that's it for the simplest bubble sort method.
diff --git a/contents/bubble_sort/code/lisp/bubble_sort.lisp b/contents/bubble_sort/code/lisp/bubble_sort.lisp
index 7266fa0fe..0379355f8 100644
--- a/contents/bubble_sort/code/lisp/bubble_sort.lisp
+++ b/contents/bubble_sort/code/lisp/bubble_sort.lisp
@@ -11,20 +11,20 @@
         (bubble-up 
           (cons 
             (first list) 
-            (rest (rest list)))))
-            
+            (rest (rest list)))))           
       (cons 
         (first list)
         (bubble-up
-          (cons
-            (second list)
-            (rest (rest list))))))))
+          (rest list))))))
 
 (defun bubble-sort (list)
   (if 
-    (equal list (bubble-up list))
+    (< (length list) 2)
     list
-    (bubble-sort (bubble-up list))))
+    (let* ((new-list (bubble-up list)))
+      (append 
+        (bubble-sort (butlast new-list)) 
+        (last new-list)))))
 
 ;; The built-in sort: (sort (list 5 4 3 2 1) #'<)
 (print 

From cc914ad52efce3d4b313fee7e701d90b25a96a33 Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Tue, 14 Aug 2018 15:01:54 +0200
Subject: [PATCH 12/12] Updated bubble_sort.md, again.

---
 contents/bubble_sort/bubble_sort.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contents/bubble_sort/bubble_sort.md b/contents/bubble_sort/bubble_sort.md
index 4d9a70fdf..88f9418ed 100644
--- a/contents/bubble_sort/bubble_sort.md
+++ b/contents/bubble_sort/bubble_sort.md
@@ -45,7 +45,7 @@ This means that we need to go through the vector $$\mathcal{O}(n^2)$$ times with
 {% sample lang="php" %}
 [import:3-15, lang:"php"](code/php/bubble_sort.php)
 {% sample lang="lisp" %}
-[import:3-30, lang:"lisp"](code/lisp/bubble_sort.lisp)
+[import:3-28, lang:"lisp"](code/lisp/bubble_sort.lisp)
 {% endmethod %}
 
 ... And that's it for the simplest bubble sort method.