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

Creative Commons Attribution-ShareAlike 3.0

Logo

Programming-Idioms.org

  • The snippets are under the CC-BY-SA license.
  • Please consider keeping a bookmark
  • (instead of printing)
Scheme
1
Print a literal string on standard output
(display "Hello World")
2
Loop to execute some code a constant number of times
(define (hellos i)
        (if (> i 0)    
            (begin
                (display "Hello")
                (newline)
                (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")
  (newline))
3
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)
    (newline))
Alternative implementation:
(define finish
    (lambda (name)
        (display "My job here is done. Goodbye ")
        (display name)
        (newline)))
4
Create a function which returns the square of an integer
(define square
    (lambda (x)
        (* x x)))
Alternative implementation:
(define (square x)
    (* x x))
5
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))
6
Do something with each item x of an array-like collection items, regardless indexes.
(define (doSomething x)
    (if (not (null? x))
        (begin 
            (display "Item=")
            (display (car x))
            (newline)
            (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)
7
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))
        (begin
          (display (string-append
                    (number->string i)
                    ": "
                    (number->string (first items))
                    "\n"))
          (display-list (rest items) (+ i 1)))
        'done))
  (display-list items 0))
8
Create a new map object x, and provide some (key, value) pairs as initial content.
(define x '(
    ("one" 1) 
    ("two" 2) 
    ("three" 3)))
9
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))
10
Generate a random permutation of the elements of list x
(shuffle x)
Alternative implementation:
(define shuffle
  (lambda (x)
    (if (< (length x) 2) 
        list
        (let ((item (list-ref list (random (length x)))))
          (cons item (shuffle (remove item x)))))))
11
The list x must be non-empty.
(list-ref x (random (length x)))
12
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)
14
Pick a random number greater than or equals to a, strictly inferior to b. Precondition : a < b.
(+ a (* (- b a) (random 1.0)))


15
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))))
16
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)))
      bt))
17
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))
19
Reverse the order of the elements of the list x.
This may reverse "in-place" and destroy the original ordering.
(reverse x)
21
Swap the values of the variables a and b
(define (swap a b)
  (list b a))
22
Extract the integer value i from its string representation s (in radix 10)
(define i (string->number s))
26
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))))
28
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)
29
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)
      null
      (if (= i 0)
          (cdr L)
          (cons (car L) (removeElementByIndex (cdr L) (- i 1)))
       )
    )
)
31
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)
      1))
35
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)))))
36
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)))))
37
Transform a function that takes multiple arguments into a function for which some of the arguments are preset.
(define add5 (curry + 5))
38
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))
41
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))))
45
Sleep for 5 seconds in current thread, before proceeding with the next instructions.
(sleep 5)
48
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.")
49
Build list chunks consisting in substrings of input 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))))
50
Write a loop that has no end clause.
(let forever ()
  (forever))
51
Determine whether the map m contains an entry for the key k
(assoc k m)
53
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 "")
               a
               (string-append a ", " b)))
         ""
         x))
54
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))
55
Create the string representation s (in radix 10) of the integer value i.
(define s (number->string i))
57
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))
64
Assign to x the value 3^247
(define x (expt 3 247))
71
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) " "))
(newline)
76
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))]))))
77
Declare a complex x and initialize it with value (3i - 2). Then multiply it by i.
(define x -2+3i)
(display (* x 0+1i))
81
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))
87
Exit immediately.
If some extra cleanup work is executed by the program runtime (not by the OS itself), describe it.
(exit)
93
Implement procedure control which receives one parameter f, and runs f.
(define (control f) (f))
110
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)))
117
Set n to the number of elements of the list x.
(define n (length x))
119
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)))
        (else
         (cons (car l) (remove-duplicates (cdr l))))))
(remove-duplicates x)
126
Write a function foo that returns a string and a boolean value.
(define (foo) (cons "bar" false))
Alternative implementation:
(define (foo) 
  (values "foo" #t))
131
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)))
134
Declare and initialize a new list items, containing 3 elements a, b, c.
(define items (list a b c))
141
Iterate in sequence over the elements of the list items1 then items2. For each iteration print the element.
(map (lambda (x)
       (display x)
       (newline))
     (append items1 items2))
143
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)
       (newline))
     (foldr append '()
            (map list items1 items2)))
163
Print all the list elements, two by two, assuming list length is even.
(let print-pairs ((l list))
  (if (null? l)
      '()
      (begin
        (display (car l))
        (display " ")
        (display (cadr l))
        (newline)
        (print-pairs (cddr l)))))
165
Assign to the variable x the last element of the list items.
(define items (list 1 2 3 4))
(define x (last items))
166
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))
171
Append element x to the list s.
(reverse (cons x (reverse s)))
182
Output the source of the program.
1
191
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)))))
234
Assign to string s the standard base64 encoding of the byte array data, as specified by RFC 4648.
(base64-encode
 (list->bytes
  (map char->integer
       (string->list "hi there"))))
243
Print the contents of the list or array a on the standard output.
(write a)
256
Print the numbers 5, 4, ..., 0 (included), one line per number.
(let loop ([x 5])
  (when (>= x 0)
    (display x)
    (newline)
    (loop (sub1 x))))
257
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)))
261
Assign to string x the value of fields (hours, minutes, seconds) of date d, in format HH:MM:SS.
(define d (current-date))
(define x (substring (date-and-time d) 11 19))

265
Set the integer variable i to 42 and calculate its parity (i.e. 0 if it contains an even number of bits, 1 if it contains an odd number of bits).
(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)
267
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)
  (displayln
   (if (string? x)
       x
       "Nothing")))

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