e!
(exclamation)Arity: 1 • Notation: postfix • Syntax: arg1 e!
Generates all the distinct permutations of an array. If the array has duplicate elements, some of its permutations could end up being identical, but any such duplicate permutations are excluded. If a number n is given instead of an array, it is treated as a range from 0 to n-1. The permutations are generated in lexicographic order.
arg1 | Result | Example | Result |
---|---|---|---|
array or string | Unique permutations of arg1 | "foo"e! |
["foo" "ofo" "oof"] |
numeric | Permutations of 0…arg1-1 | 2e! |
[[0 1] [1 0]] |
e%
(percent)Arity: 2 • Notation: postfix • Syntax: arg1 arg2 e%
Formats a string using a template (format string) and an argument or array of arguments to be inserted into the string. Works like the printf functions in various languages. The full behavior is not specified at this point, but you can assume that the intersection of C's and java's printf behaviour is included (i.e. the parts they agree on).
arg1 | arg2 | Result | Example | Result |
---|---|---|---|---|
string | non-array | arg1 formatted with arg2 as argument | "x=%.2f"2.5e% |
"x=2.50" |
string | array or string | arg1 formatted with arg2 as arguments | "(%d-%d)"[2 3]e% |
"(2-3)" |
"hi %s!"["Jon"]e% |
"hi Jon!" |
|||
non-array | string | arg2 formatted with arg1 as argument | 7"%03d"e% |
"007" |
non-string array | string | arg2 formatted with arg1 as arguments | ["a"3]"%s=%d"e% |
"a=3" |
e&
(ampersand)Arity: 2 • Notation: postfix • Syntax: arg1 arg2 e&
Gets the logical AND of two values. Rather than a 0/1 result, it returns the value that decided the result. Practically, it returns the first value if it is false (0 or empty), or the second value if the first value is true. If the result is a block, it is executed. Note that currently the first value can not be a block, because CJam doesn't have automatic boolean evaluation for blocks (yet).
arg1 | arg2 | Result | Example | Result |
---|---|---|---|---|
non-block | anything | arg1 if arg1 is false, else arg2 | 5{1 3+}e& |
4 |
"""foo"e& |
"" |
e*
(asterisk)Arity: 2 • Notation: postfix • Syntax: arg1 arg2 e*
Given an array (or string) and a number, it repeats each item of the array, in place.
arg1 | arg2 | Result | Example | Result |
---|---|---|---|---|
array or string | numeric | arg1 with each item repeated arg2 times | "foo"2e* |
"ffoooo" |
numeric | array or string | arg2 with each item repeated arg1 times | 3[2 1]e* |
[2 2 2 1 1 1] |
e<
(less than)Arity: 2 • Notation: postfix • Syntax: arg1 arg2 e<
Compares two compatible values and returns the smaller one. Arrays/strings are compared lexicographically.
arg1 | arg2 | Result | Example | Result |
---|---|---|---|---|
numeric or char | numeric or char | min(arg1, arg2) (by numeric value) | 3 2.5e< |
2.5 |
array or string | array or string | min(arg1, arg2) (lexicographically) | "12""3"e< |
"12" |
e=
(equals)Arity: 2 • Notation: postfix • Syntax: arg1 arg2 e=
Given an array/string and another value, it counts how many times the value appears in the array (i.e. how many array items are equal to that value).
arg1 | arg2 | Result | Example | Result |
---|---|---|---|---|
array or string | anything | No. of occurrences of arg2 in arg1 | "foo"'oe= |
2 |
non-array | array or string | No. of occurrences of arg1 in arg2 | 3[1 2]e= |
0 |
e>
(greater than)Arity: 2 • Notation: postfix • Syntax: arg1 arg2 e>
Compares two compatible values and returns the larger one. Arrays/strings are compared lexicographically.
arg1 | arg2 | Result | Example | Result |
---|---|---|---|---|
numeric or char | numeric or char | max(arg1, arg2) (by numeric value) | 64'Ae> |
'A |
array or string | array or string | max(arg1, arg2) (lexicographically) | "foo""bar"e> |
"foo" |
e[
(left square bracket)Arity: 3 • Notation: postfix • Syntax: arg1 arg2 arg3 e[
Pads an array/string to the left with a given value, up to a given size. If the array is not shorter than that size, it is left alone.
arg1 | arg2 | arg3 | Result | Example | Result |
---|---|---|---|---|---|
array or string | integer | anything | arg1 padded to the left with arg3 up to length arg2 | "hi"5'*e[ |
"***hi" |
e\
(backslash)Arity: 3 • Notation: postfix • Syntax: arg1 arg2 arg3 e\
Swaps 2 items of an array/string, based on their positions (indices). The indices wrap around.
arg1 | arg2 | arg3 | Result | Example | Result |
---|---|---|---|---|---|
array or string | integer | integer | swap arg1[arg2] with arg1[arg3] | "hello"0 9e\ |
"oellh" |
integer | array or string | integer | swap arg2[arg1] with arg2[arg3] | -1[2 3 4]1e\ |
[2 4 3] |
integer | integer | array or string | swap arg3[arg1] with arg3[arg2] | 0 1["x""y"]e\ |
["y""x"] |
e]
(right square bracket)Arity: 3 • Notation: postfix • Syntax: arg1 arg2 arg3 e]
Pads an array/string to the right with a given value, up to a given size. If the array is not shorter than that size, it is left alone.
arg1 | arg2 | arg3 | Result | Example | Result |
---|---|---|---|---|---|
array or string | integer | anything | arg1 padded to the right with arg3 up to length arg2 | "hi"5'!e] |
"hi!!!" |
e_
(underscore)Arity: 1 • Notation: postfix • Syntax: arg1 e_
Expands any nested arrays in a given array. Note that strings are arrays too.
arg1 | Result | Example | Result |
---|---|---|---|
array or string | flattened arg1 | ["hi"['!1[2 3.4]]]e_ |
['h'i'!1 2 3.4] |
e`
(backtick)Arity: 1 • Notation: postfix • Syntax: arg1 e`
Compresses an array/string using run-length encoding, converting it to an array of [length item] pairs.
arg1 | Result | Example | Result |
---|---|---|---|
array or string | RLE-compressed arg1 | "hiiiii"e` |
[[1'h][5'i]] |
ea
Arity: 0 • Syntax: ea
Pushes an array of all the command-line arguments. The array is empty if there were no arguments given.
ed
Arity: 0 • Syntax: ed
Prints the string representation of the current contents of the stack as an array, on a separate line. It does not modify the stack.
Example | Result |
---|---|
"foo"ed"bar" |
Stack: ["foo"] foobar |
ee
Arity: 1 • Notation: postfix • Syntax: arg1 ee
Enumerates an array/string, converting it to an array of [index item] pairs.
arg1 | Result | Example | Result |
---|---|---|---|
array or string | array of [i arg1[i]] pairs | "hi"ee |
[[0'h][1'i]] |
el
Arity: 1 • Notation: postfix • Syntax: arg1 el
Converts a character or string to lowercase.
arg1 | Result | Example | Result |
---|---|---|---|
char | lowercase arg1 | 'Ael |
'a |
string | lowercase arg1 | "Hi"el |
"hi" |
er
Arity: 3 • Notation: postfix • Syntax: arg1 arg2 arg3 er
Replaces elements of an array/string, using an array of values to be replaced and another array of values to use instead. The 2nd and 3rd argument can be non-array values, in which case they are treated as a single-element array containing that value. Elements not present in arg2 are left alone, and if arg3 has fewer elements than arg2, the last element of arg3 will be used for the remaining values.
arg1 | arg2 | arg3 | Result | Example | Result |
---|---|---|---|---|---|
array or string | anything | anything | replace elements of arg2 with corresponding elements of arg3 in arg1 | "hello""lo"'yer |
"heyyy" |
es
Arity: 0 • Syntax: es
Pushes the current time, represented as the number of milliseconds that have passed since the Unix epoch (1970-01-01 00:00:00 UTC).
et
Arity: 0 • Syntax: et
Pushes an array containing the current year, month, date, hour, minute, second, millisecond, day of week (Sunday=0, Saturday=6) and timezone offset (in milliseconds) in the default timezone.
eu
Arity: 1 • Notation: postfix • Syntax: arg1 eu
Converts a character or string to uppercase.
arg1 | Result | Example | Result |
---|---|---|---|
char | uppercase arg1 | 'aeu |
'A |
string | uppercase arg1 | "Hi"eu |
"HI" |
ew
Arity: 2 • Notation: postfix • Syntax: arg1 arg2 ew
Given an array/string and a number, returns an array of all the slices of the given length from the given array (starting from every possible position).
arg1 | arg2 | Result | Example | Result |
---|---|---|---|---|
array or string | integer | arg1 slices of length arg2 | "hello"3ew |
["hel""ell""llo"] |
integer | array or string | arg2 slices of length arg1 | 2[5 4 3]ew |
[[5 4][4 3]] |
e|
(pipe)Arity: 2 • Notation: postfix • Syntax: arg1 arg2 e|
Gets the logical OR of two values. Rather than a 0/1 result, it returns the value that decided the result. Practically, it returns the first value if it is true (non-zero or not empty), or the second value if the first value is false. If the result is a block, it is executed. Note that currently the first value can not be a block, because CJam doesn't have automatic boolean evaluation for blocks (yet).
arg1 | arg2 | Result | Example | Result |
---|---|---|---|---|
non-block | anything | arg1 if arg1 is true, else arg2 | 0{1 3+}e | |
4 |
5"foo"e | |
5 |
e~
(tilde)Arity: 1 • Notation: postfix • Syntax: arg1 e~
Decompresses an array of [length item] pairs using run-length encoding.
arg1 | Result | Example | Result |
---|---|---|---|
array | RLE-decompressed arg1 | [[1'h][5'i]]e~ |
"hiiiii" |