The snippets are under the CC-BY-SA license.

Creative Commons Attribution-ShareAlike 3.0


  • The snippets are under the CC-BY-SA license.
  • Please consider keeping a bookmark
  • (instead of printing)
Print a literal string on standard output
(display "Hello World")
Loop to execute some code a constant number of times
(define (hellos i)
        (if (> i 0)    
                (display "Hello")
                (hellos (- i 1)))))
(hellos 10)
Alternative implementation:
(for-each (lambda (x) (display "Hello\n")) (iota 10))
Alternative implementation:
(do ((i 0 (+ i 1)))
    ((= i 10))
  (display "Hello")
Like a function which doesn't return any value, thus has only side effects (e.g. Print to standard output)
(define (finish name)
    (display "My job here is done. Goodbye ")
    (display name)
Alternative implementation:
(define finish
    (lambda (name)
        (display "My job here is done. Goodbye ")
        (display name)
Create a function which returns the square of an integer
(define square
    (lambda (x)
        (* x x)))
Alternative implementation:
(define (square x)
    (* x x))
Declare a container type for two floating-point numbers x and y
(define (make-point x y)
  (cons x y))
(define (point-x p)
  (car p))
(define (point-y p)
  (cdr p))
Do something with each item x of the list (or array) items, regardless indexes.
(define (doSomething x)
    (if (not (null? x))
            (display "Item=")
            (display (car x))
            (doSomething (cdr x)))))
Alternative implementation:
(define (sum a b)
 (sum-iter a b 0))

(define (sum-iter index n sum)
   (if (= n index)
    (+ sum index) 
    (+  (sum-iter  n (+ index 1) (+ sum index)))
Alternative implementation:
(map doSomething items)
Print each index i with its value x from an array-like collection items
(define (display-list items)
  (define (display-list items i)
    (if (not (null? items))
          (display (string-append
                    (number->string i)
                    ": "
                    (number->string (first items))
          (display-list (rest items) (+ i 1)))
  (display-list items 0))
Create a new map object x, and provide some (key, value) pairs as initial content.
(define x '(
    ("one" 1) 
    ("two" 2) 
    ("three" 3)))
The structure must be recursive because left child and right child are binary trees too. A node has access to children nodes, but not to its parent.
(define (make-btree value left right)
  (cons value (cons left right)))

(define (btree-value bt) (car bt))
(define (btree-left bt) (cadr bt))
(define (btree-right bt) (cddr bt))
Generate a random permutation of the elements of list x
(shuffle x)
Alternative implementation:
(define shuffle
  (lambda (x)
    (if (< (length x) 2) 
        (let ((item (list-ref list (random (length x)))))
          (cons item (shuffle (remove item x)))))))
The list x must be non-empty.
(list-ref x (random (length x)))
Check if the list contains the value x.
list is an iterable finite container.
(define (contains list x)
	(cond [(null? list) #f]
		[(equal? (car list) x) #t]
		[else (contains (cdr list) x)]))
Alternative implementation:
(member x list)
Pick a random number greater than or equals to a, strictly inferior to b. Precondition : a < b.
(+ a (* (- b a) (random 1.0)))

Pick a random integer greater than or equals to a, inferior or equals to b. Precondition : a < b.
(+ a (random (add1 (- b a))))
Alternative implementation:
(floor (+ a (* (add1 (- b a)) (random 1.0))))
Call a function f on every node of binary tree bt, in depth-first infix order
(define (map-btree f bt)
  (if (not (null? bt))
      (make-btree (f (btree-value bt))
                  (map-btree f (btree-left bt))
                  (map-btree f (btree-right bt)))
The structure must be recursive. A node may have zero or more children. A node has access to its children nodes, but not to its parent.
(define (make-tree value children)
  (cons value children))

(define (tree-value t) (car t))
(define (tree-first-child t) (cadr t))
(define (tree-rest-children t) (cddr t))
Reverse the order of the elements of the list x.
This may reverse "in-place" and destroy the original ordering.
(reverse x)
Swap the values of the variables a and b
(define (swap a b)
  (list b a))
Extract the integer value i from its string representation s (in radix 10)
(define i (string->number s))
Declare and initialize a matrix x having m rows and n columns, containing real numbers.
(build-list m (lambda (x)
                (build-list n (lambda (y) 0))))
Sort the elements of the list (or array-like collection) items in ascending order of x.p, where p is a field of the type Item of the objects in items.
(define-struct item (p x y) #:transparent)
(define items (list (item 1 2 3) (item 0 0 0) (item 5 2 1)))
(sort items < #:key item-p)
Remove i-th item from list items.
This will alter the original list or return a new list, depending on which is more idiomatic.
Note that in most languages, the smallest valid value for i is 0.
(define (removeElementByIndex L i)
  (if (null? L)
      (if (= i 0)
          (cdr L)
          (cons (car L) (removeElementByIndex (cdr L) (- i 1)))
Create the recursive function f which returns the factorial of the non-negative integer i, calculated from f(i-1)
(define (f i)
  (if (> i 1)
      (* (f (- i 1)) i)
Implement a function compose (A -> C) with parameters f (A -> B) and g (B -> C), which returns the composition function g ∘ f
(define (compose f g)
  (lambda (x) (g (f (x)))))
Implement a function compose which returns composition function g ∘ f for any functions f and g having exactly 1 parameter.
(define (compose f g) 
	(lambda x 
		(f (apply g x))))
Alternative implementation:
(define compose
 (lambda (f g)
   (lambda (x) (f (g x)))))
Transform a function that takes multiple arguments into a function for which some of the arguments are preset.
(define add5 (curry + 5))
Find substring t consisting in characters i (included) to j (excluded) of string s.
Character indices start at 0 unless specified otherwise.
Make sure that multibyte characters are properly handled.
(define t (substring s i j))
Create string t containing the same characters as string s, in reverse order.
Original string s must remain unaltered. Each character must be handled correctly regardless its number of bytes in memory.
(define t (list->string (reverse (string->list s))))
Sleep for 5 seconds in current thread, before proceeding with the next instructions.
(sleep 5)
Assign to variable s a string literal consisting in several lines of text, including newlines.
(define s "This is my multi-line literal.
Line number two!
  This line starts with two spaces.")
Build list chunks consisting in substrings of the string s, separated by one or more space characters.
(define (tokenize l)
  (let loop ((t '())
             (l l))
    (if (pair? l)
        (let ((c (car l)))
          (if (char=? c #\space)
              (cons (reverse t) (loop '() (cdr l)))
              (loop (cons (car l) t) (cdr l))))
        (if (null? t)
            (list (reverse t))))))

(define (string-split s)
  (map list->string (tokenize (string->list s))))
Write a loop that has no end clause.
(let forever ()
Determine whether the map m contains an entry for the key k
(assoc k m)
Concatenate elements of string list x joined by the separator ", " to create a single string y.
(define y
  (foldr (lambda (a b)
           (if (string=? b "")
               (string-append a ", " b)))
Calculate the sum s of the integer list or array x.
(define s (foldr + 0 x))
Alternative implementation:
(define s (fold-right + 0 x))
Alternative implementation:
(define s (apply + x))
Alternative implementation:
(define s (apply fx+ x))
Alternative implementation:
(define s (apply + x))
Create the string representation s (in radix 10) of the integer value i.
(define s (number->string i))
Create the list y containing the items from the list x that satisfy the predicate p. Respect the original ordering. Don't modify x in-place.
(define y (filter p x))
Assign to x the value 3^247
(define x (expt 3 247))
Basic implementation of the Echo program: Print all arguments except the program name, separated by space, followed by newline.
The idiom demonstrates how to skip the first argument if necessary, concatenate arguments as strings, append newline and print it to stdout.
(display (string-join (list-tail (command-line) 1) " "))
Create the string s of integer x written in base 2.

E.g. 13 -> "1101"
(define (binary-representation x)
  (let loop ([N x]
             [s '()])
    (let ([NN (arithmetic-shift N -1)])
      (cond [(zero? N) (list->string s)]
            [(odd? N) (loop NN (cons #\1 s))]
            [else (loop NN (cons #\0 s))]))))
Declare a complex x and initialize it with value (3i - 2). Then multiply it by i.
(define x -2+3i)
(display (* x 0+1i))
Declare the integer y and initialize it with the rounded value of the floating point number x .
Ties (when the fractional part of x is exactly .5) must be rounded up (to positive infinity).
(define y (round x))
Exit immediately.
If some extra cleanup work is executed by the program runtime (not by the OS itself), describe it.
Implement the procedure control which receives one parameter f, and runs f.
(define (control f) (f))
Set the boolean blank to true if the string s is empty, or null, or contains only whitespace ; false otherwise.
(define (empty-string? s)
  (= (string-length s) 0))

(define blank (empty-string? (string-trim s)))
Set boolean b to true if objects x and y contain the same values, recursively comparing all referenced elements in x and y.
Tell if the code correctly handles recursive types.
(define b (equal? x y))
Set n to the number of elements of the list x.
(define n (length x))
Remove duplicates from the list x.
Explain if the original order is preserved.
(define (remove-duplicates l)
  (cond ((null? l)
        ((member (car l) (cdr l))
         (remove-duplicates (cdr l)))
         (cons (car l) (remove-duplicates (cdr l))))))
(remove-duplicates x)
Write a function foo that returns a string and a boolean value.
(define (foo) (cons "bar" false))
Alternative implementation:
(define (foo) 
  (values "foo" #t))
Execute f1 if condition c1 is true, or else f2 if condition c2 is true, or else f3 if condition c3 is true.
Don't evaluate a condition when a previous condition was true.
(cond (c1 (f1))
      (c2 (f2))
      (c3 (f3)))
Declare and initialize a new list items, containing 3 elements a, b, c.
(define items (list a b c))
Iterate in sequence over the elements of the list items1 then items2. For each iteration print the element.
(map (lambda (x)
       (display x)
     (append items1 items2))
Iterate alternatively over the elements of the lists items1 and items2. For each iteration, print the element.

Explain what happens if items1 and items2 have different size.
(map (lambda (x)
       (display x)
     (foldr append '()
            (map list items1 items2)))
Print all the list elements, two by two, assuming list length is even.
(let print-pairs ((l list))
  (if (null? l)
        (display (car l))
        (display " ")
        (display (cadr l))
        (print-pairs (cddr l)))))
Assign to the variable x the last element of the list items.
(define items (list 1 2 3 4))
(define x (last items))
Create the list ab containing all the elements of the list a, followed by all the elements of the list b.
(define ab (append a b))
Append the element x to the list s.
(reverse (cons x (reverse s)))
Output the source of the program.
Given a one-dimensional array a, check if any value is larger than x, and execute the procedure f if that is the case
(let iter ((l a))
  (cond ((null? l) '())
        ((> (car l) x) (f))
        (else (iter (cdr l)))))
Assign to the string s the standard base64 encoding of the byte array data, as specified by RFC 4648.
  (map char->integer
       (string->list "hi there"))))
Print the contents of the list or array a on the standard output.
(write a)
Print the numbers 5, 4, ..., 0 (included), one line per number.
(let loop ([x 5])
  (when (>= x 0)
    (display x)
    (loop (sub1 x))))
Print each index i and value x from the list items, from the last down to the first.
(define (reversed-inspect items)
  (foldl (lambda (x i)
          (display (format "~a ~a\n" i x))
          (sub1 i))
         (sub1 (length items))
        (reverse items)))
Assign to the string x the value of fields (hours, minutes, seconds) of the date d, in format HH:MM:SS.
(define d (current-date))
(define x (substring (date-and-time d) 11 19))

Calculate the parity p of the integer variable i : 0 if it contains an even number of bits set, 1 if it contains an odd number of bits set.
(define (popcount x)
  (let loop ([s x]
             [count 0])
    (cond [(zero? s) count]
          [(odd? s) (loop (arithmetic-shift s -1) (add1 count))]
          [else (loop (arithmetic-shift s -1) count)])))

(define i 42)
(popcount i)
Declare an argument x to a procedure foo that can be of any type. If the type of the argument is a string, print it, otherwise print "Nothing."

Test by passing "Hello, world!" and 42 to the procedure.
(define (foo x)
   (if (string? x)

(foo "Hello, world!")
(foo 42)