• insertion sort:

  (define (part x y)
    (if (eqv? (car x) y)
        (cdr x)
        (cons (car x) (part (cdr x) y))
    )
  )
   
  (define (sort2 x)
    (if (null? x)
        x
        (cons (apply min x) (sort2 (part x (apply min x))))
    )
  )
   
  (sort2 '(4 5 -4 5 1 0 3 2))

  > > (-4 0 1 2 3 4 5 5)

• merge sort:

  (define (part x a b f)
    (if (null? x)
        (list a b)
        (if f
            (part (cdr x) (cons (car x)  a) b (not f))
            (part (cdr x) a (cons (car x) b)   (not f))
        )
    )
  )
   
  (define (merge a b x)
    (cond
        ((null? a) (append (reverse b) x))
        ((null? b) (append (reverse a) x))
        (else (if (< (car a) (car b))
                  (merge (cdr a) b (cons (car a) x))
                  (merge a (cdr b) (cons (car b) x))
              )
        )
    )
  )
   
  (define (sortm x)
    (if (null? (cdr x))
        x
        (let* (
              	(par (part x '() '() #t))
              	(l (sortm (car par)))
         	  	(r (sortm (cadr par)))
              )
              (reverse (merge l r '()))
        )
    )
  )
   
  (sortm '(4 2342 56421 1 213 52 1 5451 -5 2 -4 2 -1 -111))

  >>(-111 -5 -4 -1 1 1 2 2 4 52 213 2342 5451 56421)

• Quicksort

  (define (part x a b f)
    (if (null? x)
        (list a b)
        (if (< (car x) f)
            (part (cdr x) (cons (car x)  a) b f)
            (part (cdr x) a (cons (car x) b)  f)
        )
    )
  )
   
  (define (qsort x)
    (if (null? x)
         x
         (if (null? (cdr x))
             x
             (let* (
                    (par (part (cdr x) '() '() (car x)))
                    (l (qsort (car par)))
                    (r (qsort (cadr par)))
                    )
               (append l (list (car x)) r)
             )
         )
     )
  )
   
  (qsort '(54 4562 243 26345 123 53 -234 -2 -4 -6 1 4 5 -5 5 -5 9 0))

  > > (-234 -6 -5 -5 -4 -2 0 1 4 5 5 9 53 54 123 243 4562 26345)

And here is an example of computing depth of tree:

• (define
    (depth x)
        (begin
          (if (or (null? x) (not (pair? x) ) )
              0
              (max
                   ( + 1 (depth (car x)) )
                   (depth (cdr x))
              )
          )
        )
  )
   
  (depth '( ( ( 1 2 ) ( 3 4 ) ( ( 4 5 ) ( 6 ( 7 ) ) ) ) ) )
  (depth '( 1 ) )
  (depth '( 1 ( 2 ( 3 ( 4 ) ) ) ) )

  > > 5
  > 1
  > 4

I’ve used http://www.plt-scheme.org/software/mzscheme/

Share/Save

#! /usr/bin/env python
# Author: Wojtek Jamrozy (www.wojtekrj.net)
 
def modexp(a, n, m):
	bits = []
	while n:
		bits.append(n%2)
		n /= 2
	solution = 1
	bits.reverse()
	for x in bits:
		solution = (solution*solution)%m
		if x:
			solution = (solution*a)%m
	return solution
 
print modexp(2,34, pow(10,10))
print modexp(2,pow(10,20), pow(10,10))

output:

7179869184
1787109376

Function pow(a,b) is Python’s function, which computes a^b
Function modexp(a, n, m) computes aⁿ mod m. Here is example, which shows running of the function a=2, n=34, m=10¹⁰
Firstly, we want to have bits of binary notation of n in list bits.
Before reversion, bits have following content: [0, 1, 0, 0, 0, 1] (2¹ + 2⁵ = 33)
After reversion of list: bits= [1, 0, 0, 0, 1, 0]
Bits of binary notation of n are in order from “bigger” powers to “lower” ones.
I will use (b) for binary notation of number: 33 = 100001(b)
At the beggining, solution = 2⁰ mod 10¹⁰ = 1. Then, during execution of for loop, solution has following values: 2^1(b) mod 10¹⁰, 2^10(b) mod 10¹⁰, 2^100(b) mod 10¹⁰, 2^1000(b) mod 10¹⁰, 2^10001(b) mod 10¹⁰ and finally 2^100010(b) mod 10¹⁰.
Using (1) and (2) we can calcualte every solution’s value if we know previous one.
Loop for is executed for each element of bits. Bits size is log₂n, so the complexity of whole alghorithm is O(log n)

You can download code here:
Note: There is a file embedded within this post, please visit this post to download the file.

Share/Save