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

Creative Commons Attribution-ShareAlike 3.0

Logo

Programming-Idioms.org

< Cheatsheets
  • The snippets are under the CC-BY-SA license.
  • Please consider keeping a bookmark
  • (instead of printing)
Smalltalk
1
Print Hello World
Print a literal string on standard output 
Transcript cr; show: 'Hello World!'
2
Print Hello 10 times
Loop to execute some code a constant number of times 
10 timesRepeat: [Transcript showln: 'Hello'].
3
Create a procedure
Like a function which doesn't return any value, thus has only side effects (e.g. Print to standard output) 
methodWithoutReturn

   self doSomething.
   [Transcript showln: 'something'] value.
4
Create a function
Create a function which returns the square of an integer 
[:anInteger | anInteger squared]
5
Create a 2D Point data structure
Declare a container type for two floating-point numbers x and y 
Object subclass: #Point
	instanceVariableNames: 'x y'
	classVariableNames: ''
	poolDictionaries: ''
	category: 'Graphics-Primitives'
6
Iterate over list values
Do something with each item x of the list (or array) items, regardless indexes. 
items do: [:x | x doSomething]
7
Iterate over list indexes and values
Print each index i with its value x from an array-like collection items 
items withIndexDo: [:item :index |
  Transcript showln: 'item: ' , item asString , ' index: ' , index asString].
8
Create a map (associative array)
Create a new map object x, and provide some (key, value) pairs as initial content. 
x := Dictionary newFrom: {
	#a -> 1.
	#b -> Object new}.
9
Create a Binary Tree data structure
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. 
Object subclass: #TreeNode 
    instanceVariableNames: 'left right'
    classVariableNames: ''
    poolDictionaries: ''
    category: 'Trees'.
10
Shuffle a list
Generate a random permutation of the elements of list x 
x shuffled.
11
Pick a random element from a list
The list x must be non-empty. 
x atRandom
12
Check if list contains a value
Check if the list contains the value x.
list is an iterable finite container. 
list includes: x.
13
Iterate over map keys and values
Access each key k with its value x from an associative array mymap, and print them. 
mymap keysAndValuesDo: [ :k :x |
	Transcript cr;
		show: 'Key = ', k printString;
		show: ', Value = ', x printString]
14
Pick uniformly a random floating point number in [a..b)
Pick a random number greater than or equals to a, strictly inferior to b. Precondition : a < b. 
| rand |
rand := Random new.
rand next * (b - a) + a
15
Pick uniformly a random integer in [a..b]
Pick a random integer greater than or equals to a, inferior or equals to b. Precondition : a < b. 
(a to: b) atRandom
19
Reverse a list
Reverse the order of the elements of the list x.
This may reverse "in-place" and destroy the original ordering. 
X reversed.
21
Swap values
Swap the values of the variables a and b
 
[| temp | temp := a. a := b. b := temp] value
22
Convert string to integer
Extract the integer value i from its string representation s (in radix 10) 
i := s asInteger.
26
Create a 2-dimensional array
Declare and initialize a matrix x having m rows and n columns, containing real numbers. 
x := Matrix	
    rows: m
    columns: n
    element: 1.0
28
Sort by a property
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. 
items sorted: [:x :y | x p <= y p].
29
Remove item from list, by its index
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. 
items removeAt: i.
31
Recursive factorial (simple)
Create the recursive function f which returns the factorial of the non-negative integer i, calculated from f(i-1) 
f := [:i | i = 0 ifTrue: [1] ifFalse: [i * (f value: i - 1)]].
32
Integer exponentiation by squaring
Create function exp which calculates (fast) the value x power n.
x and n are non-negative integers. 
exp: n
	n = 0 ifTrue: [^ 1].
	n = 1 ifTrue: [^ self].
	n%2 = 0 ifTrue: [^ self * self exp: n/2].
	^ self * (self * self exp: n-1/2)
38
Extract a substring
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. 
t := s copyFrom: i to: j - 1.
39
Check if string contains a word
Set the boolean ok to true if the string word is contained in string s as a substring, or to false otherwise. 
ok := s includesSubstring: word.
41
Reverse a string
Create the string t containing the same characters as the string s, in reverse order.
The original string s must remain unaltered. Each character must be handled correctly regardless its number of bytes in memory. 
t := s reversed.
43
Break outer loop
Look for a negative value v in 2D integer matrix m. Print it and stop searching. 
| negativeValue |
negativeValue := [ :matrix || ctx |
    ctx := thisContext sender.
    matrix do: [ :row |
        row do: [ :value |
            (value < 0) ifTrue: [ ctx resumeWith: value ].
        ]
    ]
] value: m. "ex. m := #((1 2 -1 3))"
Transcript show: negativeValue; cr.
45
Pause execution for 5 seconds
Sleep for 5 seconds in current thread, before proceeding with the next instructions. 
5 seconds wait.
46
Extract beginning of string (prefix)
Create the string t consisting of the 5 first characters of the string s.
Make sure that multibyte characters are properly handled. 
s first: 5
47
Extract string suffix
Create string t consisting in the 5 last characters of string s.
Make sure that multibyte characters are properly handled. 
s last: 5
48
Multi-line string literal
Assign to variable s a string literal consisting in several lines of text, including newlines. 
s := 'Will this compile?
Oh yes, it will!'.
49
Split a space-separated string
Build list chunks consisting in substrings of the string s, separated by one or more space characters. 
chunks := s substrings
50
Make an infinite loop
Write a loop that has no end clause. 
[] repeat.
51
Check if map contains key
Determine whether the map m contains an entry for the key k 
m includesKey: k.
52
Check if map contains value
Determine whether the map m contains an entry with the value v, for some key. 
m includes: v.
53
Join a list of strings
Concatenate elements of string list x joined by the separator ", " to create a single string y. 
y := x joinSeparatedBy: ', '.
Alternative implementation:
', ' join: #('abc' 'def' 'ghi')
54
Compute sum of integers
Calculate the sum s of the integer list or array x. 
s := x sum.
55
Convert integer to string
Create the string representation s (in radix 10) of the integer value i. 
s := i asString.
57
Filter list
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. 
y := x select: [:item | item p].
58
Extract file content to a string
Create the string lines from the content of the file with filename f. 
| lines |
lines := f asFilename readStream upToEnd.
59
Write to standard error stream
Print the message "x is negative" to standard error (stderr), with integer x value substitution (e.g. "-2 is negative"). 
OS.Stderr 
  nextPutAll: x asString;
  nextPutAll: ' is negative';
  nextPut: Character cr.
66
Big integer exponentiation
Calculate the result z of x power n, where x is a big integer and n is a positive integer. 
z := x raisedTo: n.
Alternative implementation:
z := x ** n.
71
Echo program implementation
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. 
| args arg sep |
args := CEnvironment commandLine readStream.
args next.    " skip executable name "
sep := [args peek isNil not ifTrue: [' '] ifFalse: ['']].
[ (arg := args next) isNil ] whileFalse: [
    Transcript show: arg; show: (sep value).
].
Transcript cr. " cr -> carriage return; ie. newline "
78
"do while" loop
Execute a block once, then execute it again as long as boolean condition c is true. 
[
    " do something "
    c
] whileTrue: [].
96
Check string prefix
Set the boolean b to true if string s starts with prefix prefix, false otherwise. 
b := s beginsWith: prefix
99
Format date YYYY-MM-DD
Assign to the string x the value of the fields (year, month, day) of the date d, in format YYYY-MM-DD. 
x := d yyyymmdd.
100
Sort by a comparator
Sort elements of array-like collection items, using a comparator c. 
| c |
c := [ :a :b | a size <= b size ].  " example c for strings "
#('a' 'aaa' 'a' 'aaaa') asSortedCollection: c.
" => SortedCollection('a' 'a' 'aaa' 'aaaa') "
110
Check if string is blank
Set the boolean blank to true if the string s is empty, or null, or contains only whitespace ; false otherwise. 
blank := s isAllSeparators.
117
Get list size
Set n to the number of elements of the list x. 
n := x size.
118
List to set
Create the set y from the list x.
x may contain duplicates. y is unordered and has no repeated values. 
y := x asSet
119
Deduplicate list
Remove duplicates from the list x.
Explain if the original order is preserved. 
x asSet.
Alternative implementation:
x intersection: x asSet.
131
Successive conditions
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. 
true caseOf: {
  [c1] -> [f1].
  [c2] -> [f2].
  [c3] -> [f3]}
134
Create a new list
Declare and initialize a new list items, containing 3 elements a, b, c. 
items := {a . b . c}.
136
Remove all occurrences of a value from a list
Remove all occurrences of the value x from list items.
This will alter the original list or return a new list, depending on which is more idiomatic. 
items reject: [: y | y = x ]
137
Check if string contains only digits
Set the boolean b to true if the string s contains only characters in the range '0'..'9', false otherwise. 
b := s allSatisfy: #isDigit
143
Iterate alternatively over two lists
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. 
items1 with: items2 do: [:item1 :item2 |
  Transcript 
	showln: item1;
	showln: item2].
Alternative implementation:
stream1 := items1 readStream.
stream2 := items2 readStream.
[stream1 atEnd ifFalse: [Transcript showln: stream1 next].
 stream2 atEnd ifFalse: [Transcript showln: stream2 next]]
	doWhileFalse: [stream1 atEnd or: [stream2 atEnd]].
147
Remove all non-ASCII characters
Create string t from string s, keeping only ASCII characters 
t := s select: [:character | character isAscii].
153
Concatenate string with integer
Create the string t as the concatenation of the string s and the integer i. 
t := s, i asString.
157
Declare constant string
Initialize a constant planet with string value "Earth". 
planet := 'Earth'.
158
Random sublist
Create a new list y from randomly picking exactly k elements from list x.

It is assumed that x has at least k elements.
Each element must have same probability to be picked.
Each element from x must be picked at most once.
Explain if the original ordering is preserved or not. 
y := x shuffled first: k.
163
Print list elements by group of 2
Print all the list elements, two by two, assuming list length is even. 
list pairsDo: [:a :b |
  Transcript showln: 'a: ' , a , ' b: ' , b].
165
Last element of list
Assign to the variable x the last element of the list items. 
x := items last.
166
Concatenate two lists
Create the list ab containing all the elements of the list a, followed by all the elements of the list b. 
ab := a,b
169
String length
Assign to the integer n the number of characters of the string s.
Make sure that multibyte characters are properly handled.
n can be different from the number of bytes of s. 
n := s size.
170
Get map size
Set n to the number of elements stored in mymap.

This is not always equal to the map capacity. 
n := mymap size.
172
Insert an entry in a map
Insert value v for key k in map m. 
m at: k put: v.
179
Get center of a rectangle
Return the center c of the rectangle with coördinates(x1,y1,x2,y2) 
c := (x1@y1 corner: x1@y2) center.
184
Tomorrow
Assign to t a string representing the day, month and year of the day after the current date. 
t := Date tomorrow asString.
185
Execute function in 30 seconds
Schedule the execution of f(42) in 30 seconds. 
(f future: 30 "seconds" * 1000) value: 42.
189
Filter and transform list
Produce a new list y containing the result of the function T applied to all elements e of the list x that match the predicate P. 
y := x 
  select: [:ea | ea p]
  thenCollect: [:ea | ea t].
Alternative implementation:
y := x 
  collect: [:ea | ea t]
  thenSelect: [:ea | ea p].
201
Euclidean norm
Calculate n, the Euclidean norm of data, where data is a list of floating point values. 
data := #( 5 4 3 2 1 ).
n := data squared sum sqrt.
205
Get an environment variable
Read an environment variable with the name "FOO" and assign it to the string variable foo. If it does not exist or if the system does not support environment variables, assign a value of "none". 
| foo |
foo := CEnvironment getUserEnvironment at: 'FOO' ifAbsent: [ 'none' ].
256
Count backwards
Print the numbers 5, 4, ..., 0 (included), one line per number. 
5 to: 0 by: -1 do: [:i | Transcript showln: i asString].
272
Play FizzBuzz
Fizz buzz is a children's counting game, and a trivial programming task used to affirm that a programmer knows the basics of a language: loops, conditions and I/O.

The typical fizz buzz game is to count from 1 to 100, saying each number in turn. When the number is divisible by 3, instead say "Fizz". When the number is divisible by 5, instead say "Buzz". When the number is divisible by both 3 and 5, say "FizzBuzz" 
1 to: 100 do: 
	[:ea | (ea isDivisibleBy: 15)
		ifTrue: [Transcript showln: 'FizzBuzz']
		ifFalse: [(ea isDivisibleBy: 5)
				ifTrue: [Transcript showln: 'Buzz']
				ifFalse: [(ea isDivisibleBy: 3)
						ifTrue: [Transcript showln: 'Fizz']
						ifFalse: [Transcript showln: ea]]]].
306
Ensure list capacity
Preallocate memory in the list x for a minimum total capacity of 200 elements.

This is not possible in all languages. It is only meant as a performance optimization, should not change the length of x, and should not have any effect on correctness. 
x := Array new: 200.
"#(nil nil nil nil nil ...)"