Mostly playing with racket and prepared for upload to github

Signed-off-by: Collin J. Doering <rekahsoft@gmail.com>

.gitignore

@@ -1 +1,2 @@
+.*
 *~

C/test.c

@@ -21,6 +21,10 @@
  * Date: Jun 27, 2012
  */
 
+int gcd (int a, int b) {
+  return 0;
+}
+  
 int main () {
   return 0;
 }

Haskell/LargestPalindromeFromIntPairs.hs

@@ -0,0 +1,13 @@
+
+
+isPalindrome :: (Eq a) => [a] -> Bool
+isPalindrome x
+  | mod len 2 == 0 && take (div len 2) x == reverse (drop (div len 2) x) = True
+  | otherwise                                                            = False
+  where len = length x
+
+largestPalidromeOfSize :: Int -> Int
+largestPalidromeOfSize n = foldr max 0 . map (uncurry (*)) . filter (isPalindrome . show . uncurry (*)) $ [ (x,y) | x <- [s,s-1..t], y <- [s,s-1..t] ]
+  where s = (10 ^ n) - 1
+        t = s `quot` 2
+        

Haskell/Lockers.hs

@@ -0,0 +1,23 @@
+import Data.Foldable
+import qualified Data.Map.Lazy as Map
+
+type Lockers = Map.Map Int Bool
+               
+makeLockers :: Int -> Lockers
+makeLockers n = Map.fromList $ zip [1..n] $ replicate n False
+
+changeLockersState :: Int -> Lockers -> Lockers
+changeLockersState n l = foldr' (Map.adjust not) l modNList
+  where modNList = [ n * m | m <- take (Map.size l `quot` n) [1..] ]
+
+runLockers :: Lockers -> Lockers
+runLockers l = foldr' changeLockersState l [1..Map.size l]
+
+main :: IO ()
+main = do
+  putStrLn "Enter how many lockers: "
+  n <- fmap read getLine :: IO Int
+  let lockers = runLockers $ makeLockers n
+
+  putStrLn $ "The following lockers remained open after " ++ show n ++ " iterations: "
+  print (Map.keys $ Map.filterWithKey (flip const) lockers)

Haskell/ProjectEuler.hs

@@ -0,0 +1,193 @@
+-- (C) Copyright Collin Doering 2014
+--
+-- This program is free software: you can redistribute it and/or modify
+-- it under the terms of the GNU General Public License as published by
+-- the Free Software Foundation, either version 3 of the License, or
+-- (at your option) any later version.
+-- 
+-- This program is distributed in the hope that it will be useful,
+-- but WITHOUT ANY WARRANTY; without even the implied warranty of
+-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+-- GNU General Public License for more details.
+-- 
+-- You should have received a copy of the GNU General Public License
+-- along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-- File: ProjectEuler.hs
+-- Author: Collin J. Doering <rekahsoft@gmail.com>
+-- Date: May 18, 2014
+
+-----------------------------------------------------------------------------------------------
+-- Problem 4: Largest palindrome product                                                     --
+-----------------------------------------------------------------------------------------------
+isPalindrome :: (Eq a) => [a] -> Bool
+isPalindrome x
+  | mod len 2 == 0 && take (div len 2) x == reverse (drop (div len 2) x) = True
+  | otherwise                                                            = False
+  where len = length x
+
+largestPalidromeOfSize :: Int -> Int
+largestPalidromeOfSize n = foldr max 0 . map (uncurry (*)) . filter (isPalindrome . show . uncurry (*)) $ [ (x,y) | x <- [s,s-1..t], y <- [s,s-1..t] ]
+  where s = (10 ^ n) - 1
+        t = s `quot` 2
+-----------------------------------------------------------------------------------------------
+
+-----------------------------------------------------------------------------------------------
+-- Problem 5: Smallest multiple                                                              --
+-----------------------------------------------------------------------------------------------
+-----------------------------------------------------------------------------------------------
+
+-----------------------------------------------------------------------------------------------
+-- Problem 7: 10001 prime                                                                    --
+-----------------------------------------------------------------------------------------------
+isPrime :: Integral b => b -> Bool
+isPrime n = all (not . (== 0) . (n `mod`)) [2..quot n 2]
+
+nthPrime :: Integral a => Int -> a
+nthPrime n = [ x | x <- [2..], isPrime x] !! n
+-----------------------------------------------------------------------------------------------
+
+-----------------------------------------------------------------------------------------------
+-- Problem 8: Largest product in a series                                                    --
+-----------------------------------------------------------------------------------------------
+p8Series :: Integer
+p8Series = read . concat $
+           [ "73167176531330624919225119674426574742355349194934"
+           , "96983520312774506326239578318016984801869478851843"
+           , "85861560789112949495459501737958331952853208805511"
+           , "12540698747158523863050715693290963295227443043557"
+           , "66896648950445244523161731856403098711121722383113"
+           , "62229893423380308135336276614282806444486645238749"
+           , "30358907296290491560440772390713810515859307960866"
+           , "70172427121883998797908792274921901699720888093776"
+           , "65727333001053367881220235421809751254540594752243"
+           , "52584907711670556013604839586446706324415722155397"
+           , "53697817977846174064955149290862569321978468622482"
+           , "83972241375657056057490261407972968652414535100474"
+           , "82166370484403199890008895243450658541227588666881"
+           , "16427171479924442928230863465674813919123162824586"
+           , "17866458359124566529476545682848912883142607690042"
+           , "24219022671055626321111109370544217506941658960408"
+           , "07198403850962455444362981230987879927244284909188"
+           , "84580156166097919133875499200524063689912560717606"
+           , "05886116467109405077541002256983155200055935729725"
+           , "71636269561882670428252483600823257530420752963450" ]
+
+
+largestProduct :: Integer -> Integer
+largestProduct n = foldr max 0 . flip fiveProducts [] $ [ read [x] | x <- show n]
+
+fiveProducts :: Num a => [a] -> [a] -> [a]
+fiveProducts [] acc = acc
+fiveProducts (a:b:c:d:e:f:g:h:i:j:k:l:m:xs) acc = fiveProducts (b:c:d:e:f:g:h:i:j:k:l:m:xs) (a * b * c * d * e * f * g * h * i * j * k * l * m : acc)
+fiveProducts _ acc = acc
+-----------------------------------------------------------------------------------------------
+
+-----------------------------------------------------------------------------------------------
+-- Problem 13: Large Sum                                                                     --
+-----------------------------------------------------------------------------------------------
+
+numsToSum = [ 37107287533902102798797998220837590246510135740250
+            , 46376937677490009712648124896970078050417018260538
+            , 74324986199524741059474233309513058123726617309629
+            , 91942213363574161572522430563301811072406154908250
+            , 23067588207539346171171980310421047513778063246676
+            , 89261670696623633820136378418383684178734361726757
+            , 28112879812849979408065481931592621691275889832738
+            , 44274228917432520321923589422876796487670272189318
+            , 47451445736001306439091167216856844588711603153276
+            , 70386486105843025439939619828917593665686757934951
+            , 62176457141856560629502157223196586755079324193331
+            , 64906352462741904929101432445813822663347944758178
+            , 92575867718337217661963751590579239728245598838407
+            , 58203565325359399008402633568948830189458628227828
+            , 80181199384826282014278194139940567587151170094390
+            , 35398664372827112653829987240784473053190104293586
+            , 86515506006295864861532075273371959191420517255829
+            , 71693888707715466499115593487603532921714970056938
+            , 54370070576826684624621495650076471787294438377604
+            , 53282654108756828443191190634694037855217779295145
+            , 36123272525000296071075082563815656710885258350721
+            , 45876576172410976447339110607218265236877223636045
+            , 17423706905851860660448207621209813287860733969412
+            , 81142660418086830619328460811191061556940512689692
+            , 51934325451728388641918047049293215058642563049483
+            , 62467221648435076201727918039944693004732956340691
+            , 15732444386908125794514089057706229429197107928209
+            , 55037687525678773091862540744969844508330393682126
+            , 18336384825330154686196124348767681297534375946515
+            , 80386287592878490201521685554828717201219257766954
+            , 78182833757993103614740356856449095527097864797581
+            , 16726320100436897842553539920931837441497806860984
+            , 48403098129077791799088218795327364475675590848030
+            , 87086987551392711854517078544161852424320693150332
+            , 59959406895756536782107074926966537676326235447210
+            , 69793950679652694742597709739166693763042633987085
+            , 41052684708299085211399427365734116182760315001271
+            , 65378607361501080857009149939512557028198746004375
+            , 35829035317434717326932123578154982629742552737307
+            , 94953759765105305946966067683156574377167401875275
+            , 88902802571733229619176668713819931811048770190271
+            , 25267680276078003013678680992525463401061632866526
+            , 36270218540497705585629946580636237993140746255962
+            , 24074486908231174977792365466257246923322810917141
+            , 91430288197103288597806669760892938638285025333403
+            , 34413065578016127815921815005561868836468420090470
+            , 23053081172816430487623791969842487255036638784583
+            , 11487696932154902810424020138335124462181441773470
+            , 63783299490636259666498587618221225225512486764533
+            , 67720186971698544312419572409913959008952310058822
+            , 95548255300263520781532296796249481641953868218774
+            , 76085327132285723110424803456124867697064507995236
+            , 37774242535411291684276865538926205024910326572967
+            , 23701913275725675285653248258265463092207058596522
+            , 29798860272258331913126375147341994889534765745501
+            , 18495701454879288984856827726077713721403798879715
+            , 38298203783031473527721580348144513491373226651381
+            , 34829543829199918180278916522431027392251122869539
+            , 40957953066405232632538044100059654939159879593635
+            , 29746152185502371307642255121183693803580388584903
+            , 41698116222072977186158236678424689157993532961922
+            , 62467957194401269043877107275048102390895523597457
+            , 23189706772547915061505504953922979530901129967519
+            , 86188088225875314529584099251203829009407770775672
+            , 11306739708304724483816533873502340845647058077308
+            , 82959174767140363198008187129011875491310547126581
+            , 97623331044818386269515456334926366572897563400500
+            , 42846280183517070527831839425882145521227251250327
+            , 55121603546981200581762165212827652751691296897789
+            , 32238195734329339946437501907836945765883352399886
+            , 75506164965184775180738168837861091527357929701337
+            , 62177842752192623401942399639168044983993173312731
+            , 32924185707147349566916674687634660915035914677504
+            , 99518671430235219628894890102423325116913619626622
+            , 73267460800591547471830798392868535206946944540724
+            , 76841822524674417161514036427982273348055556214818
+            , 97142617910342598647204516893989422179826088076852
+            , 87783646182799346313767754307809363333018982642090
+            , 10848802521674670883215120185883543223812876952786
+            , 71329612474782464538636993009049310363619763878039
+            , 62184073572399794223406235393808339651327408011116
+            , 66627891981488087797941876876144230030984490851411
+            , 60661826293682836764744779239180335110989069790714
+            , 85786944089552990653640447425576083659976645795096
+            , 66024396409905389607120198219976047599490197230297
+            , 64913982680032973156037120041377903785566085089252
+            , 16730939319872750275468906903707539413042652315011
+            , 94809377245048795150954100921645863754710598436791
+            , 78639167021187492431995700641917969777599028300699
+            , 15368713711936614952811305876380278410754449733078
+            , 40789923115535562561142322423255033685442488917353
+            , 44889911501440648020369068063960672322193204149535
+            , 41503128880339536053299340368006977710650566631954
+            , 81234880673210146739058568557934581403627822703280
+            , 82616570773948327592232845941706525094512325230608
+            , 22918802058777319719839450180888072429661980811197
+            , 77158542502016545090413245809786882778948721859617
+            , 72107838435069186155435662884062257473692284509516
+            , 20849603980134001723930671666823555245252804609722
+            , 53503534226472524250874054075591789781264330331690 ]
+
+first10DigitsOfSum :: [Integer] -> Integer
+first10DigitsOfSum = read . take 10 . show . sum
+-----------------------------------------------------------------------------------------------

Racket/DFA.rkt

@@ -0,0 +1,114 @@
+#lang racket
+
+;; (C) Copyright Collin J. Doering 2014
+;;
+;; This program is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+;; 
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+;; 
+;; You should have received a copy of the GNU General Public License
+;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+;; File: DFA.rkt
+;; Author: Collin J. Doering <collin.doering@rekahsoft.ca>
+;; Date: Aug 27, 2014
+;; Description: an implementation of Determinalistic Finite Autamata
+
+(require (for-syntax syntax/parse))
+
+;; Some structures to represent a DFA
+(struct dfaState (trans))
+(struct dfaEndState dfaState ())
+(struct dfaStartState dfaState ())
+(struct dfaStartEndState dfaState ())
+
+(struct dfa (alpha start states))
+
+(define (compute-dfa m xs)
+  (define/match (run-dfa state ys)
+    [((or (dfaEndState _)
+          (dfaStartEndState _)) '()) 'accept]
+    [(_ '()) 'reject]
+    [((dfaState f) (cons z zs)) (run-dfa (f z) zs)])
+  (run-dfa (dfa-start m) xs))
+
+(define-syntax (define-dfa stx)
+  (define-syntax-class transition
+    #:description "dfa state transition"
+    (pattern (in (~optional ->) out:id)))
+
+  (define-syntax-class state
+    #:description "dfa state"
+    (pattern (name:id (~optional (~seq (~and #:end end?))) trans:transition ...+)
+             #:with (in ...) #'(trans.in ...)
+             #:with (out ...) #'(trans.out ...)))
+  ;; (pattern (name:id (~seq (~and #:end end2?)) (~optional (~and #:end end?))))
+  
+  (syntax-parse stx
+    [(_ name:id alpha:expr start:state rests:state ...)
+     #:fail-when (check-duplicate-identifier
+                  (syntax->list
+                   #'(start.name rests.name ...)))
+                 "duplicate state names"
+     #'(define name
+         (letrec ([start.name
+                   (dfaStartState
+                    (match-lambda [start.in start.out] ...))]
+                  [rests.name
+                   (dfaState
+                    (match-lambda [rests.in rests.out] ...))] ...)
+           (dfa 'alpha start.name '(start.name rests.name ...))))]))
+
+;; ----------------------------------------------------------------------------
+
+(define-dfa odd-binary (0 1)
+  [s0 (0 -> s0)
+      (1 -> s1)]
+  [s1 (0 -> s0)
+      (1 -> s1)]
+  [s2 #:end
+      (0 -> s2)
+      (1 -> s1)]
+  [s3 #:dead (0 -> s3) (1 -> s3)])
+
+;; Odd binary dfa expansion
+(define odd-dfa
+  (letrec ([s0 (dfaStartState (match-lambda [0 s0]
+                                            [1 s1]))]
+           [s1 (dfaEndState (match-lambda [0 s0]
+                                          [1 s1]))])
+    (dfa '(0 1) s0 '(s0 s1))))
+
+;; Even binary dfa expansion
+(define even-dfa
+  (letrec ([s0 (dfaStartState (match-lambda [0 s0]
+                                               [1 s1]))]
+           [s1 (dfaState (match-lambda [0 s2]
+                                       [1 s1]))]
+           [s2 (dfaEndState (match-lambda [0 s0]
+                                          [1 s1]))])
+    (dfa '(0 1) s0 '(s0 s1 s2))))
+
+;; Odd binary dfa macro
+;; (define-dfa odd-dfa (0 1)
+;;      [s0 (0 -> s0)
+;;          (1 -> s1)]
+;;      [s1 end
+;;          (0 -> s0)
+;;          (1 -> s1)])
+
+;; ;; Even binary dfa macro
+;; (define-dfa even-dfa (0 1)
+;;      [s0 (0 -> s0)
+;;          (1 -> s1)]
+;;      [s1 (0 -> s2)
+;;          (1 -> s1)]
+;;      [s2 end
+;;          (0 -> s0)
+;;          (1 -> s1)])

Racket/avl-tree.rkt

@@ -0,0 +1,141 @@
+#lang racket
+
+;; (C) Copyright Collin J. Doering 2014
+;;
+;; This program is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+;; 
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+;; 
+;; You should have received a copy of the GNU General Public License
+;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+;; File: avl-tree.rkt
+;; Author: Collin J. Doering <collin.doering@rekahsoft.ca>
+;; Date: Sep  2, 2014
+
+(require "comparable.rkt")
+
+;; Structure representing a Binary Search Tree 
+(struct bst ())
+(struct bst-empty bst () #:transparent)
+(struct bst-node bst (val left right) #:transparent)
+
+;; Make a leaf in a binary tree
+(define (bst-make-leaf i)
+  (bst-node i (bst-empty) (bst-empty)))
+
+;; ----------------------------------------------------------------------
+
+;; First a naive approach to binary search trees
+;; Specifically these functions do not maintain any balance
+;; of the bst and thus are inefficient in many cases
+
+;; Naive bst insert (not balanced)
+(define/match (bst-insert-naive t i)
+  [((bst-empty) _) (bst-node i (bst-empty) (bst-empty))]
+  [((bst-node v (bst-empty) (bst-empty)) _)
+   (if (gte i v)
+       (bst-node v (bst-empty) (bst-make-leaf i))
+       (bst-node v (bst-make-leaf i) (bst-empty)))]
+  [((bst-node v l r) _) #:when (gte i v)
+   (bst-node v l (bst-insert-naive r i))]
+  [((bst-node v l r) _) #:when (lt i v)
+   (bst-node v (bst-insert-naive l i) l)])
+
+;; Naive bst delete (not balanced)
+;; (define (bst-delete-naive t i)
+;;   (match t
+;;     [(bst-empty) t]
+;;     [(bst-node v l r) #:when (> i v)
+;;      (bst-node v l (bst-delete-naive r i))]
+;;     [(bst-node v l r) #:when (lt i v)
+;;      (bst-node v (bst-delete-naive l i) r)]
+;;     [(bst-node v l r) #:when (= i v)
+;;      (match* (l r)
+;;              [((bst-empty) (bst-empty)) (bst-empty)]
+;;              [((bst-node v1 l1 r1) (bst-empty)) ???]
+;;              [((bst-empty) (bst-node v1 l1 r1)) ???]
+;;              [((bst-node v1 l1 r1) (bst-node v2 l2 r2)) ???])]))
+
+;; ----------------------------------------------------------------------
+
+;; Below is a more effiecient implementation of BST's; specifically using
+;; the AVL binary seach tree algorithm.
+;; See: https://en.wikipedia.org/wiki/AVL_tree
+
+;; Calculate AVL score for a particular node
+(define/match (avl-score t)
+  [((bst-empty)) 0]
+  [((bst-node v l r)) (- (bst-height l) (bst-height r))])
+
+;; Rotate a bst 
+(define/match (bst-rotate dir t)
+  [((quote left-right) _) (bst-rotate 'left (bst-rotate 'right t))]
+  [((quote right-left) _) (bst-rotate 'right (bst-rotate 'left t))]
+  [((quote left) (bst-node v1 l1 (bst-node v2 l2 r2)))
+   (bst-node v2 (bst-node v1 l1 l2) r2)]
+  [((quote right) (bst-node v1 (bst-node v2 l2 r2) r1))
+   (bst-node v2 l2 (bst-node v1 r2 r1))])
+
+;; Balance AVL binary tree
+(define (avl-balance t)
+  (let ([score (avl-score t)])
+    (match t
+      [(bst-node v l r) #:when (= score 2)
+       (cond [(< (avl-score l) 0) (bst-rotate 'right-left t)]
+             [else (bst-rotate 'right t)])]
+      [(bst-node v l r) #:when (= score -2)
+       (cond [(> (avl-score r) 0) (bst-rotate 'left-right t)]
+             [else (bst-rotate 'left t)])]
+      [_ t])))
+
+;; Insert into AVL binary tree
+(define (bst-insert t i)
+  (match t
+    [(bst-empty) (bst-make-leaf i)]
+    [(bst-node v l r) #:when (eql i v) t]
+    [(bst-node v l r) #:when (gte i v)
+     (let* ([r-not (bst-insert r i)]
+            [rt (bst-node v l r-not)])
+       (avl-balance rt))]
+    [(bst-node v l r) #:when (lt i v)
+     (let* ([l-not (bst-insert l i)]
+            [rt (bst-node v l-not r)])
+       (avl-balance rt))]))
+
+;; Delete item from AVL binary tree
+(define (bst-delete t i)
+  'undefined)
+
+(define (bst-search t i)
+  (match t
+    [(bst-empty) #f]
+    [(bst-node v _ _) #:when (eql i v) #t]
+    [(bst-node v _ r) #:when (gt i v) (bst-search r i)]
+    [(bst-node v l _) #:when (lt i v) (bst-search l i)]))
+
+(define (bst-flatten t)
+  (match t
+     [(bst-empty) '()]
+     [(bst-node v l r) `(,@(bst-flatten l) ,v ,@(bst-flatten r))]))
+
+(define (bst-height t)
+  (match t
+    [(bst-empty) 0]
+    [(bst-node _ l (bst-empty)) (+ 1 (bst-height l))]
+    [(bst-node _ (bst-empty) r) (+ 1 (bst-height r))]
+    [(bst-node _ l r) (+ 1 (max (bst-height l) (bst-height r)))]))
+
+(define (list->bst xs)
+  (foldr (lambda (x acc)
+           (bst-insert acc x))
+         (bst-empty) xs))
+
+(define (bst-sort xs)
+  (bst-flatten (list->bst xs)))

Racket/comparable.rkt

@@ -0,0 +1,46 @@
+#lang racket
+
+;; (C) Copyright Collin J. Doering 2014
+;;
+;; This program is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+;; 
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+;; 
+;; You should have received a copy of the GNU General Public License
+;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+;; File: comparable.rkt
+;; Author: Collin J. Doering <collin.doering@rekahsoft.ca>
+;; Date: Sep 11, 2014
+
+(require racket/generic)
+
+;; (provide (contract-out
+;;           [bst-make-leaf (-> any bst-node?)]
+;;           [bst-insert (-> bst-node? any)]))
+
+;; Define a generic interface for orderable things (thatis things that can be sorted)
+(define-generics orderable
+  [lt orderable other]
+  [lte orderable other]
+  [gt orderable other]
+  [gte orderable other]
+  [eql orderable other]
+  #:defaults ([number?
+               (define lt <)
+               (define lte <=)
+               (define gt >)
+               (define gte >=)
+               (define eql =)]
+              [string?
+               (define lt string-ci<?)
+               (define lte string-ci<=?)
+               (define gt string-ci>?)
+               (define gte string-ci>=?)
+               (define eql equal?)]))

Racket/macros.rkt

@@ -0,0 +1,44 @@
+#lang racket
+
+;; (C) Copyright Collin J. Doering 2014
+;;
+;; This program is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+;; 
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+;; 
+;; You should have received a copy of the GNU General Public License
+;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+;; File: macros.rkt
+;; Author: Collin J. Doering <collin.doering@rekahsoft.ca>
+;; Date: Aug 28, 2014
+;; Description: various implementions of macros for learning purposes
+
+(require (for-syntax syntax/parse))
+
+(define-syntax my-while
+  (syntax-rules ()
+    [(my-while n body ...)
+     (if (and (integer? n) (>= n 0))
+         (letrec ([f (lambda () body ...)]
+                  [g (lambda (i)
+                       (cond [(= i 0) (f)]
+                             [else (begin
+                                     (f)
+                                     (g (- i 1)))]))])
+           (g n))
+         (error"Must be a positive integer"))]))
+
+(define-syntax mylet
+  (syntax-rules ()
+    [(mylet ([var rhs] ...) body ...) ((lambda (var ...) body ...) rhs ...)]))
+
+(define-syntax (mylet2 stx)
+  (syntax-parse stx
+    [(_ ((var:id rhs:expr) ...) body ...+) #'((lambda (var ...) body ...) rhs ...)]))

Racket/rdm.rkt

@@ -17,6 +17,13 @@
       (factorial-helper n 1)
       (error "Expects argument to be an integer!")))
 
+;; factorial function written using pattern matching
+(define (factorial1 n)
+  (define/match (fac i acc)
+      [(0 _) acc]
+      [(n _) (fac (- n 1) (* n acc))])
+  (fac n 1))
+
 (define factorial!
   (letrec ([fact-helper (lambda (n acc)
 			  (if (<= n 1) acc (fact-helper (- n 1) (* acc n))))]
@@ -146,6 +153,12 @@
           [else (interval-helper (+ i 1) j (cons i acc))]))
   (reverse (interval-helper i j empty)))
 
+(define (repeat f n)
+  (define (rep i acc)
+    (cond [(<= i 0) acc]
+          [else (rep (- i 1) (cons (f) acc))]))
+  (rep n '()))
+
 ;; common poduct interval
 (define (cp-interval i j m)
   (map (lambda (x) (if (= x 0) x (* m x))) (interval i j)))
@@ -247,21 +260,11 @@
   (let ([f (/ n (expt 10 (+ i 1)))])
     (floor (* 10 (- f (floor f))))))
 
-(define (merge xs ys)
-  (cond [(and (empty? xs) (empty? ys)) empty]
-	[(empty? xs) ys]
-	[(empty? ys) xs]
-	[(< (first xs) (first ys)) (cons (first xs) (merge (rest xs) ys))]
-	[(equal? (first xs) (first ys))
-	   (cons (first xs) (cons (first ys) (merge (rest xs) (rest ys))))]
-	[else (cons (first ys) (merge xs (rest ys)))]))
-
-
-(define (merge-sort xs)
-  (cond [(empty? xs) empty]
-	[(empty? (rest xs)) xs]
-	[else (merge (merge-sort (take xs (quotient (length xs) 2)))
-		     (merge-sort (drop xs (quotient (length xs) 2))))]))
+(define (random-list n)
+  (define (randlst i acc)
+    (cond [(<= i 0) acc]
+          [else (randlst (sub1 i) (cons (random n) acc))]))
+  (randlst n '()))
 
 (define (append-all a b)
   (cond [(and (list? a) (list? b)) (append a b)]
@@ -295,3 +298,24 @@
 	     (my-flatten2-h (rest xs) (append (my-flatten2-h (first xs) '()) acc))]
 	  [else (my-flatten2-h (rest xs) (cons (first xs) acc))]))
   (reverse (my-flatten2-h xs '())))
+
+(define (rpn-calc xs)
+  (define (symbol->operator s)
+    (cond [(eq? s '+) +]
+          [(eq? s '-) -]
+          [(eq? s '*) *]
+          [(eq? s '/) /]))
+  (define (symbol-urinary-op? s)
+    (cond [(eq? s '!) #t]
+          [else #f]))
+  (define (symbol-urinary->op s)
+    (cond [(eq? s '!) (lambda (n) (foldr * 1 (if (>= n 0) (range 1 (+ n 1)) (range n 0))))]))
+  (define/match (rpn ys acc)
+    [('() (cons a '())) a]
+    [('() _) (error "Not a valid RPN expression")]
+    [((cons y ys) acc) #:when (number? y) (rpn ys (cons y acc))]
+    [((cons y ys) (cons a acc)) #:when (symbol-urinary-op? y)
+     (rpn ys (cons ((symbol-urinary->op y) a) acc))]
+    [((cons y ys) (cons a1 (cons a2 acc))) #:when (symbol? y)
+     (rpn ys (cons ((symbol->operator y) a2 a1) acc))])
+  (rpn xs '()))

Racket/simple-searches.rkt

@@ -0,0 +1,26 @@
+#lang racket
+
+;; (C) Copyright Collin J. Doering 2014
+;;
+;; This program is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+;; 
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+;; 
+;; You should have received a copy of the GNU General Public License
+;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+;; File: simple-searches.rkt
+;; Author: Collin J. Doering <collin.doering@rekahsoft.ca>
+;; Date: Sep 11, 2014
+
+(define (list-search-naive x ys)
+  (match ys
+    ['() #f]
+    [(cons a bs) #:when (equal? x a) #t]
+    [(cons _ bs) (list-search-naive x bs)]))

Racket/simple-sorts.rkt

@@ -0,0 +1,64 @@
+#lang racket
+
+;; (C) Copyright Collin J. Doering 2014
+;;
+;; This program is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+;; 
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+;; 
+;; You should have received a copy of the GNU General Public License
+;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+;; File: simple-sorts.rkt
+;; Author: Collin J. Doering <collin.doering@rekahsoft.ca>
+;; Date: Sep 11, 2014
+
+;; Insert a element into a sorted list
+(define (insert i lst)
+  (cond [(empty? lst) (list i)]
+        [(>= i (first lst)) (cons (first lst) (insert i (rest lst)))]
+        [(< i (first lst)) (cons i lst)]))
+
+;; Implementation of insertion sort
+(define (insert-sort lst)
+  (define (isort xs acc)
+    (cond [(empty? xs) acc]
+          [else (isort (rest xs) (insert (first xs) acc))]))
+  (isort lst '()))
+
+;; Implementation of selection sort using immutable data
+(define (selection-sort xs)
+  (define (selsort xs acc)
+    (cond [(empty? xs) acc]
+          [else (selsort (remove (apply min xs) xs) (cons (apply min xs) acc))]))
+  (reverse (selsort xs '())))
+
+;; Merge two lists such that order is maintained
+(define (merge xs ys)
+  (cond [(empty? xs) ys]
+	[(empty? ys) xs]
+	[(< (first xs) (first ys)) (cons (first xs) (merge (rest xs) ys))]
+	[(equal? (first xs) (first ys))
+	   (cons (first xs) (cons (first ys) (merge (rest xs) (rest ys))))]
+	[else (cons (first ys) (merge xs (rest ys)))]))
+
+;; The merge function re-written using pattern matching instead of cond
+(define/match (merge as bs)
+  [('() _) bs]
+  [(_ '()) as]
+  [((cons x xs) (cons y _)) #:when (< x y) (cons x (merge xs bs))]
+  [((cons x xs) (cons y ys)) #:when (= x y) (cons x (cons y (merge xs ys)))]
+  [((cons x _) (cons y ys)) #:when (> x y) (cons y (merge as ys))])
+
+;; Implementation of merge sort
+(define (merge-sort xs)
+  (cond [(empty? xs) empty]
+	[(empty? (rest xs)) xs]
+	[else (merge (merge-sort (take xs (quotient (length xs) 2)))
+		     (merge-sort (drop xs (quotient (length xs) 2))))]))

Shell/rdm.sh

@@ -0,0 +1,23 @@
+#!/bin/sh
+
+# (C) Copyright Collin J. Doering 2014
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# File: rdm.sh
+# Author: Collin J. Doering <collin.doering@rekahsoft.ca>
+# Date: Jun  5, 2014
+
+# odd numbers in sed
+sed -n '=; n'