Skip to content

Instantly share code, notes, and snippets.

@lyxal
Created August 9, 2022 12:46
Show Gist options
  • Save lyxal/3f87a3129891498687af91391b64f24f to your computer and use it in GitHub Desktop.
Save lyxal/3f87a3129891498687af91391b64f24f to your computer and use it in GitHub Desktop.
λ = lambda - λ...;
ƛ = lambda that automatically gets mapped - ƛ...;
¬ (any a) -> num = logical NOT (non-vectorising)
∧ (any a, any b) -> num = logical AND
⟑ (any a, any b) -> [*num] = vectorised AND
∨ (any a, any b) -> num = logical OR
⟇ (any a, any b) -> [*num] = vectorised OR
÷ (num a, num b) -> num = a / b # division
(num a, str b) -> [*str] = b split into a even length pieces. There may be an extra part if the string is too long.
(str a, num b) -> [*str] = a split into b even length pieces. There may be an extra part if the string is too long.
(str a, str b) -> [*str] = a.split_on_first_occurance(b)
(otherwise) = vectorise
× (num a, num b) -> num = a × b # multiply, multiplication, times
(num a, str b) -> str = b repeated a times
(str a, num b) -> str = a repeated b times
(str a, str b) -> [*str] = [char + b for char in a]
(otherwise) = vectorise
« = base-255 compressed string - «...«
<newline> = NOP # no-op, nothing
» = base-255 compressed number - »...»
° = function reference - °defined_function_name;
• (num a, num b) -> num = log_a(b)
(num a, str b) -> [*str] = [char * a for char in b]
(str a, num b) -> [*str] = [char * b for char in a]
(str a, str b) -> str = a.with_capitalisation_of(b)
([*any] a, [*any] b) -> [*any] = a molded to the shape of b
(otherwise) -> [*any] = vectorise
¿ (any a, any b?) -> any = apply element if a is truthy - <element>¿
⋄ (num a) -> num = number of prime factors
(str a) -> any = execute as Vyxal
(fun a, any... b) -> any = call function
([*any]) -> [*any] = vectorise
μ = last element as a function - <element>μ
ξ = last two elements as a single element - <element><element>ξ
π = last three elements as a single element - <element><element><element>π
ρ = last four elements as a single element - ....ρ
ς (any a) -> [*any] = inner product - <element>ς
σ (any a) -> [*any] = sort by element - <element>σ
φ (any a) -> [*any] = everything until last φ as an element. if no previous φ, until newline
χ = everything to the start of the line as a single element
ψ (any a, any b?, any c?) -> any, any = apply last two elements "parallel" - 3 4 +-ψ -> 7, -1
ω (any a, any b?, any c?) -> [*any] = apply last two elements "parallel" and collect - equivalent to ψ"
ɓ = perform last element without popping - <element>ɓ
ƈ (any a) -> [*any] = collect while applying last element is truthy - <element>ƈ
ɗ ([*any] a) -> any = maximum by last element - <element>ɗ
ƒ ([*any] a) -> [*any] = filter by last element - <element>ƒ
ɠ ([*any] a) -> [*any] = minimum by last element - <element>ɠ
ɦ ([*any] a) -> [*any] = map last element over prefixes - <element>ɦ
<space> = NOP
! (num a) = factorial(a)
(str a) = sentence_case(a)
([*any] a) = vectorise
" (any a, any b) -> [*any] = [a, b] (pair items)
# = comment
$ (any a, any b) -> any, any = b, a (swap items)
% (num a, num b) -> num = a % b # modulo
(num a, str b) -> str = (b split into a equal pieces)[-1]
(str a, num b) -> str = (a split into b equal pieces)[-1]
(str a, str b) -> str = a.format(b)
(str a, [*any] b) -> str = a.format(b)
(otherwise) -> [*any] = vectorise
& = apply last element to the register - <element>&
' = single character string
( = open for loop: (variable|...)
) = close for loop
* (num a, num b) -> num = a ** b # exponent, exponentiation
(num a, str b) -> str = every ath letter of b
(str a, num b) -> str = every bth letter of a
(str a, str b) -> [*num] = regex.search(pattern=a, string=b).span()
(otherwise) -> [*any] = vectorise
+ (num a, num b) -> num = a + b # addition
(num a, str b) -> str = concat(a, b)
(str a, num b) -> str = concat(a, b)
(str a, str b) -> str = concat(a, b)
(otherwise) -> [*any] = vectorised
, (any a) = print(a)
- (num a, num b) -> num = a - b # subtraction
(num a, str b) -> str = ("-" × a) + b
(str a, num b) -> str = a + ("-" × b)
(str a, str b) -> str = a.remove(b)
(otherwise) -> [*any] = vectorise
. = decimal seperator
/ (any a) = reduce by last element - <element>/
0 = numeric literal
1 = numeric literal
2 = numeric literal
3 = numeric literal
4 = numeric literal
5 = numeric literal
6 = numeric literal
7 = numeric literal
8 = numeric literal
9 = numeric literal
: (any a) -> any, any = a, a # duplicate
; = closes a structure
< (num a, num b) -> num = a < b (less than)
(num a, str b) -> num = str(a) < b
(str a, num b) -> num = a < str(b)
(str a, str b) -> num = a < b (python string less than)
([*any] a, scl b) -> [*num] = [n < b for n in a]
([*any] a, [*any] b) -> [*num] = [a[n] < b[n] for n in range(len(a))]
= (scl a, scl b) -> num = a == b
([*any] a, scl b) -> [*num] = a == b # vectorising equals
([*any] a, [*any] b) -> [*num] = a == b # vectorise element wise
< (num a, num b) -> num = a < b (less than)
(num a, str b) -> num = str(a) < b
(str a, num b) -> num = a < str(b)
(str a, str b) -> num = a < b (python string less than)
([*any] a, scl b) -> [*num] = [n < b for n in a]
([*any] a, [*any] b) -> [*num] = [a[n] < b[n] for n in range(len(a))]
? -> any = input()
@ = define a function: @name:parameters|...;
= call a function: @name;
A ([*any] a) -> num = all(a)
B (scl a) -> num = int(a, 2)
([*any] a) -> [*num] = vectorise
C (num a) -> str = chr(a)
(str a) -> num OR [*num] = ord(a) if len(a) == 1 else map(ord, a)
(otherwise) -> [*any] = vectorise
D (any a) -> any, any, any = a, a, a (triplicate)
E (num a) -> num = 2 ** a # 2 power, two power
(str a) -> any = eval(a)
(otherwise) -> [*any] = vectorise
F (val a, val b) -> any = remove elements of a that are in b
([*any] a, fun b) -> [*any] = filter(b, a) # filter, keep, python filter
(fun a, [*any] b) -> [*any] = filter(a, b) # filter, keep, python filter
G ([*any] a) -> any = max(a) # monadic maximum, maximum iterable
H ([*any] a) -> any = a[0]
I (num a) -> num = int(a)
(str a) -> num = int(a)
([*any] a) -> num = int(a) using list items as digits
J ([*any] a, scl b) -> [*any] = a.append(b) # Append
(scl a, [*any] b) -> [*any] = b.prepend(a) # Prepend
([*any] a, [*any] b) -> [*any] = merged(a, b) # Merge
(scl a, scl b) -> scl = concatenated(a, b) # Concatenate
K (num a) -> [*num] = divisors(a)
(str a) -> [*str] = prefixes(a)
(otherwise) -> [*any] = prefixes(a)
L (any a) -> num = len(a)
M (val a, val b) -> [[any, any]] = [[a, item] for item in b] # Vectorised pair
([*any] a, fun b) -> [*any] = map(b, a)
(fun a, [*any] b) -> [*any] = map(a, b)
N (num a) -> num = -a (negate)
(str a) -> str = swapcase(a)
([*any] a) -> [*any] = vectorise
O (any a, any b) -> num = a.count(b) (non-vectorising)
P (any a, any b) -> [*any] = prepend b to a
Q = stop execution (quit)
R (val a, val b) -> any, [*any] = a, vectorised_reverse(b)
([*any] a, fun b) -> [*any] = reduce a by b # reduction, reduce
(fun a, [*any] b) -> [*any] = reduce b by a # reduction, reduce
S (num a) -> str = str(a)
(str a) -> [*str] = a.splitlines()
([*any] a) -> [*any] = vectorise
T (any a) -> any = a[-1]
U (any a) -> [*any] = uniquifed(a) # uniquify, unique items
V (any a, any b, any c) -> [*any] = a.replace(b, c)
W (any a) -> [any] = [a] # wrap item
X (num a) -> num = random.choice(range(a))
(str a) -> str = random.choice(a)
([*any] a) -> any = random.choice(a)
Y (any a) -> [*any], [*any] = uninterleave(a)
Z (any a, any b) -> [[any, any]] = zip(a, b)
(any a, fun b) -> [*any] = zip(a, map(b, a)) #zipmap, map and zip
[ = open if statement: [truthy|falsey]
\ = cumulative reduce by last element - <element>\
] = close if statement
` = string - `...`
^ = reverse stack
_ (any a) = discard/pop/trash
a (any a) -> num = any(a)
b (num a) -> [*num] = binary repr of a
(str a) -> [[*num]] = [bin(ord(char)) for char in a]
([*any] a) -> [*any] = vectorise
c (any a, any b) -> num = a in b (contains)
d (num a) -> num = a × 2
(str a) -> str = a + a
([*any] a) -> [*any] = vectorise
e (num a, num b) -> num = copysign(a, b)
(num a, str b) -> [*str] = Split b into two sections, the first of which has length a.
(str a, num b) -> [*str] = Split a into two sections, the first of which has length b.
(str a, str b) -> [*str] = Split a on the first occurance of b
(fun a, num b) -> [*num] = first b integers where a() is truthy
(num a, fun b) -> [*num] = first a integers where b() is truthy
(otherwise) -> [*any] = vectorise
f (num a) -> [*num] = list of a's digits
(str a) -> [*str] = list of a's characters
(otherwise) -> [*any] = flattened(a) # flatten, deep flatten
g ([*any] a) -> any = min(a) # monadic minimum, minimum iterable
h (any a, num b) -> [*any] = a[0:b] # Slice until b
(str a, str b) -> [*any] = regex.findall(pattern=a, string=b) # re.findall
(otherwise) -> [*any] = vectorise
i (any a, num b) -> any = a[b] # index
(any a, [*num] b) = a[:b] # 0 to bth item of a, use t for a[b:], needs wrapping index
(any a, [num x, num y] b) = a[x:y] # index, xth to yth item, needs wrapping index
(any a, [num x, num y, num m] b) = a[x:y:m] # index, xth to yth item step m items, needs wrapping index
j (any a, any b) -> str = a.join(b)
k = constant digraphs (see near the end of docs)
l (any a, num b) -> [[*any]] = n-wise_group(a, b) # Cummulative grouping/pairing
(any a, [*any] b) -> num = length(a) == length(b) # Length of a and b are same?
m (any a) = mirror(a) # numbers are reversed and added
n = context variable
o (num a, num b) -> num = how many times does b divide a? # order
(num a, str b) -> str = a * a grid of b, joined with newlines
(str a, num b) -> str = b * b grid of a, joined with newlines
(str a, str b) -> str = remove b from a until a does not change
(otherwise) -> [*any] = vectorise
p (num a, num b) -> [*num] = range(a, b + 1) # inclusive range from a to b
(num a, str b) -> [*str] = cartesian_power(b, times=a)
(str a, num b) -> [*str] = cartesian_power(a, times=b)
(num a, [*any] b) -> [*any] = cartesian_power(b, times=a)
([*any] a, num b) -> [*any] = cartesian_power(a, times=b)
(str a, str b) -> str = a.strip(b)
(otherwise) -> [*any] = vectorise
q (any a) -> str = "`" + a + "`" # uneval, quotify
r (num a, num b) -> [*num] = range(a, b) # Exclusive range from a to b
(num a, str b) -> str = stretch left; repeat the first character of b enough times to make it at least length a. Use spaces if b is empty.
(str a, num b) -> str = stretch left; repeat the first character of a enough times to make it at least length b. Use spaces if a is empty.
(any a, fun b) -> [*any] = cumulative_reduce(a, function=b) # also works with (fun a, any b), Cumulative reduce
(otherwise) -> num = regex.has_match(pattern=a, string=b) # regex match
s (any a) -> any = sorted(a) # min → max, sort
t (any a, num b) -> [*any] = a[b:] # slice from b
(str a, str b) -> [*any] = regex.match(pattern=a, string=b).groups() # regex groups
(otherwise) -> [*any] = vectorise
u ([*any] a, num b) -> [*any] = rotate a b units to the left
(any a, [*any] b) -> any, [*any] = a, b rotated to the left once
v = vectorise last element - <element>v
w (any a, num b) -> [*any] = a wrapped in chunks of length b
(any a, str b) -> [*any] = split a on b, discarding empty items
([*any] a, fun b) -> [*any] = apply b to every second item of a
(fun a, [*any] b) -> [*any] = apply a to every second item of b
x = call current function # recursion. Prints entire stack if not in a function/lambda
y (any a, any b) -> any = interleave(a, b) # Interleave
z (any a) -> [*any] = zip(a, a)
{ = open while loop: {condition|...}
| = branch in structure (syntax), Used to seperate blocks in If/For/While/Lambda/Function definition
} = close while loop
~ ([*any] a) -> any... = push each item of a onto the stack
½ (num a) -> num = a / 2 # half, halve
(str a) -> [*str] = a split into two strings of equal lengths (as close as possible)
([*any] a) -> [*any] = vectorised
Ȧ ([*any] a, num b, any c) -> [*any] = a[b] = c
Ḃ (any a) -> any, any = a, reversed(a)
Ċ (num a, num b) -> [num, num] = a choose b
(num a, str b) -> str = diagonal of char b of length a - 5`/`Ċ -> ` /\n / \n / \n / \n/ `
(str a, num b) -> str = diagonal of char a of length b
(str a, str b) -> str = a.partition(b)
([*any] a, scl b) -> [*num] = b in a (vectorised)
(scl a, [*any] b) -> [*num] = a in b (vectorised)
([*any] a, [*any] b) -> [*num] = [n in a for n in b]
Ḋ (num a, num b) -> num = a % b == 0
(num a, str b) -> str = anti-diagonal of char b of length a - 5`/`Ḋ -> `/ \n / \n / \n / \n /`
(str a, num b) -> str = diagonal of char b of length a
(str a, str b) -> str = overwrite the start of a with b -> `abcdef` `Joe`Ḋ -> `Joedef`
(otherwise) -> [*any] = vectorise
Ė (num a, num b) -> num = a // b (integer divide)
(str a, str b) -> str = b + a + b (surround)
(fun a, any b) -> any = apply a to every second item of b
(any a, fun b) -> any = apply b to every second item of a
(otherwise) -> [*any] = vectorise
Ḟ (any a, any b) -> num = a.find(b)
Ġ (num a) -> num = 1 / a
(str a) -> [*str] = a split into int(sqrt(a)) parts
([*any] a) -> [*any] = vectorise
Ḣ ([*any] a) -> [*any] = a[1:b]
İ (num a) -> num = proper divisor count
(str a) -> str = GET request with url=a
([*any] a) -> [*any] = matrix inverse of a
Ŀ (any a, any b, any c) -> any = transliterate(a, b, c) # Transliterate
(fun a, fun b, any c) -> any = repeat_until_false(predicate=a, modifying_function=b, inital=c) # equivalent to ŀt
Ṁ (num a, num b) -> [*num] = roots of quadratic ax^2 + bx = 0 # Solve quadratic equation
(num a, str b) -> num = evaluate single variable equation b with x=a
(str a, num b) -> num = evaluate single variable equation a with x=b
(str a, str b) -> num = set(a) == set(b) # Check if two lists are same except duplicates
([*any] a, [*any] b) -> [*any] = matrix multiply a and b
(fun a, [*any] b) -> any = right reduce b by a # foldr
([*any] a, fun b) -> any = right reduce a by b # foldr
(otherwise) -> [*any] = vectorised
Ṅ (num a) -> [*num] = integer_paritions(a) # Integer partitions
(str a) -> str = insert spaces between characters
([*any] a) -> str = join on spaces
(fun a) -> num = first integer where a(x) is truthy
Ȯ (num a) -> num = log_2(a)
(str a) -> str = remove all non-alphanumeric characters from a
([*any] a) -> [*any] = sums of rows (∑v)
Ṗ (any a) -> [*any] = permutations(a) # Permutations
Ṙ (any a) -> any = reverse a
Ṡ (num a) -> [*num] = range from −abs(a) to abs(a) inclusive
(str a) -> any = exec(a) # Execute python code, Python exec
([*any] a) -> [*any] = sums of columns of a
Ṫ (num a) -> num = len(prime_factors(a)) # Number of prime factors
(str a) -> str = read from file a
([*any] a) -> [*any] = transpose a
Ẇ (num a, num b) -> [*num] = a * b array of 0s
(num a, str b) -> str = stretch right; repeat the first character of b enough times to make it at least length a. Use spaces if b is empty.
(str a, num b) -> str = stretch right; repeat the first character of a enough times to make it at least length b. Use spaces if a is empty.
(str a, str b) -> num = insert b between each character of a
([*any] a, [*any] b) -> [*any] = dot product of a and b
([*any] a, fun b) -> [*any] = map b over prefixes of a
(fun a, [*any] b) -> [*any] = map a over prefixes of b
(otherwise) -> [*any] = vectorise
Ẋ ([*any] a, [*any] b) -> [*any] = cartesian product
([*any] a, fun b) -> [*any] = map b over suffixes of a
(fun a, [*any] b) -> [*any] = map a over suffixes of b
Ẏ ([*any] a) -> [*any] = cartesian product with self (:Ẋ)
Ż ([*any] a, any b) -> [*any] = zip(a, filler=b)
ȧ (num a) -> num = abs(a)
(str a) -> str = remove whitespace from a
([*any] a) -> [*any] = vectorise
ḃ (num a) -> num = a != 0
(str a) -> num = len(a) != 0
([*any] a) -> [*num] = vectorise
ċ (num a, num b) -> num = a choose b
(num a, str b) -> [*str] = l but sublists are joined as a string instead
(str a, num b) -> [*str] = l but sublists are joined as a string instead
(str a, str b) -> str = replace spaces in a with b
(fun a, num b) -> [*num] = first b integers where a() is truthy, starting at 1
(num a, fun b) -> [*num] = first a integers where b() is truthy, starting at 1
(otherwise) -> [*any] = vectorise
ḋ (num a, num b) -> [*num] = [a / b, a % b] # divmod, div mod, [div, mod], Quotient and modulo
([*any] a, num b) -> [*any] = combinations of a with length b
(num a, [*any] b) -> [*any] = combinations of b with length a
(str a, str b) -> str = a.trim(b)
(fun a, any b) -> any = apply a on b until b doesn't change
(any a, fun b) -> any = apply b on a until a doesn't change
ė (any a) -> [*any] = enumerate(a) # :ʀZ
ḟ (fun a, [*any] b) -> [*any] = push Generator of function a with initial vector b
(fun a, [*any] b, num c) -> [*any] = push Generator of function a with initial vector b, limited to c items (if present)
ġ (num a) -> num = (e ** a) - 1 # uses math.expm1()
(otherwise) -> [*any] = format a as grid
ḣ (num a) -> str = a to base 16
(str a) -> num = a from base 16
(otherwise) -> [*any] = vectorise
ŀ (num a, num b, num c) -> num = a <= c <= b
(num a, num b, str c) -> str = a by b grid of c
(num a, str b, num c) -> str = a by c grid of b
(num a, str b, str c) -> str = b.ljust(a,filler=c)
(str a, num b, num c) -> str = b by c grid of a
(str a, num b, str c) -> str = a.ljust(c,filler=b)
(str a, str b, num c) -> str = a.ljust(b,filler=c)
(str a, str b, str c) -> str = a.infinite_replace(b, c)
(fun a, fun b, any c) -> any = collect_until_false(predicate=a, modifying_function=b, inital=c) # Collect the results of apply a on c while b(c) is truthy
(otherwise) -> [*any] = vectorise
ṁ (num a) -> [*num] = all prime factors of a (includes duplicates)
(str a) -> str = remove all non-letters of a `^[A-Za-z]`
([*any] a) -> any = determinant of matrix a. For non-square a, computes det(aa^T)^½; if z is a row vector, this is its norm.
ṅ (num a) -> [*num] = integer_paritions(a) # Integer partitions
(str a) -> str = insert newlines between characters
([*any] a) -> str = join on newlines
(fun a) -> [*num] = all integers where a() is truthy
ȯ (any a, any b) -> [*any] = a.split_before(b) # https://chat.stackexchange.com/transcript/message/58361993#58361993
ṗ (any a) -> [*any] = powerset(a)
ṙ (num a, num b) -> num = round a to b decimal places
([*any] a, any b) -> [*any] = remove b from a
([*any] a, fun b) -> any = cumulative right reduce a by b
(fun a, [*any] b) -> any = cumulative right reduce b by a
ṡ (num a, num b) -> num = [a * b, a / b]
([*any a], val b) -> [*any] = split a on b
([*any a], fun b) -> [*any] = sort a by function b
(fun a, [*any b]) -> [*any] = sort b by function a
ṫ (num a) -> num = prime factorisation of a
([*any a]) -> [*any], any = a[:-1], a[-1] # tail extract
ẇ (num a, num b, num c) -> = range from a to b with step c
(num a, num b, str c) -> = shape c as an a * b rectangle
(num a, str b, num c) -> = shape b as an a * c rectangle
(num a, str b, str c) -> = pad b on both sides with a prefix of repeated copies of c to a length of the nearest multiple of a
(str a, num b, num c) -> = shape a as a b * c rectangle
(str a, num b, str c) -> = pad c on the left with a prefix of repeated copies of a to a length of the nearest multiple of b
(str a, str b, num c) -> = pad a on the right with a prefix of repeated copies of b to a length of the nearest multiple of c
(str a, str b, str c) -> = regex substitution. In a, replace b with c
([*any] a, fun b, num c) -> [*any] = b() applied to every cth element of a
([*any] a, fun b, [*num] c) -> [*any] = b() applied to items in a with indexes in c
(otherwise) -> [*any] = vectorise
ẋ (any a, num b) -> [*any] = repeat(a, times=b) # Repeat a b times
(any a, str b) -> [*any] = can each item of a be found in b?
ẏ (num a, num b) -> num = are a and b coprime?
(num a, str b) -> str = b repeated a times joined on newlines
(str a, num b) -> str = a repeated b times joined on newlines
(str a, str b) -> str = vertically merge a and b
(otherwise) -> [*any] = vectorise
ż (num a, num b, num c) -> num = a >= c >= b
(num a, num b, str c) -> str = line of c of length a in direction b (0: north, 1: north-east, 2: east, 3: south-east, etc)
(num a, str b, num c) -> str = line of b of length a in direction c
(num a, str b, str c) -> num, str = spaces in b replaced with corresponding chars in c
(str a, num b, num c) -> str = line of a of length b in direction c
(str a, num b, str c) -> str = first b spaces in a replaced with corresponding chars in c
(str a, str b, num c) -> str = last c spaces in a replaced with corresponding chars in b
(str a, str b, str c) -> num = vertically mirror a using the mapping b->c
(scl a, [*any b], [*num c]) -> [*any] = stencil any-d
([*any a], num b, num c) -> [*any] = stencil 2d (stencil takes overlapping submatrices from a matrix)
≤ (any a, any b) -> [*num] = a <= b (similar to <=ψ∨)
≥ (any a, any b) -> [*num] = a >= b (similar to >=ψ∨)
≠ (any a, any b) -> num = a != b (non-vectorising)
⁼ (any a, any b) -> num = a == b (non-vectorising)
© (any a) = put a into the register
® -> any = push register
∞ -> [*num] = infinite list of integers, starting at 0
₀ -> num = 10
₁ -> num = 100
₂ (num a) -> num = a % 2 == 0
(str a) -> str = quad palindromize with overlap
([*any] a) -> [*any] = vectorise
₃ (num a) -> num = a % 3 == 0
(str a) -> str = quad palindromize without overlap
₄ -> num = 26
₅ (num a) -> num = a % 5 == 0
(str a) -> str = len(a) == 1
([*any] a) -> [*any] = vectorise
₆ -> num = 64
₇ -> num = 128
₈ -> num = 256
₉ -> num = 16
⁰ -> any = first input or "abcdefghijklmnopqrstuvwxyz"
¹ -> any = second input or "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
² (num a) -> num = a ** 2
(str a) -> [*str] = a formatted as a square
([*any] a) -> [*any] = vectorise
³ -> any = third input or 512
⁴ -> any = fourth input or []
⁵ -> any = fifth input or " "
∑ ([*any] a) -> any = sum(a) # Sum
¦ ([*any] a) -> [*any] = cumulative_sum(a) # cumulative sum
⌈ (num a) -> num = ceiling(a) # Ceiling, ceil
(str a) -> [*str] = a.split(" ") # Split on space
⌊ (num a) -> num = floor(a)
(str a) -> str = int(keep only digits of a)
¯ ([*any] a) -> [*any] = deltas(a) # differences, cumulative subtraction
± (num a) -> num = sign_of(a) # negative = -1, 0 = 0, positive = 1, signum
(str a) -> str = a formatted into rectangle with smallest perimeter
↳ (num a, num b) -> num = a >> b # Right bit shift, right shift
(str a, num b) -> str = a.rjust(b) # right justify
(num a, str b) -> str = b.rjust(a) # right justify
(str a, str b) -> str = a.rjust(len(b) - len(a)) # right justify by length
(otherwise) -> [*any] = vectorised
↲ (num a, num b) -> num = a << b # Left bit shift, left shift
(str a, num b) -> str = a.ljust(b) # left justify
(num a, str b) -> str = b.ljust(a) # left justify
(str a, str b) -> str = a.ljust(len(b) - len(a)) # left justify by length
(otherwise) -> [*any] = vectorised
⋏ (num a, num b) -> num = a and b (bitwise) # a & b
(str a, num b) -> str = a.center(b) # center
(num a, str b) -> str = b.center(a) # center
(str a, str b) -> str = a.center(len(b) - len(a)) # center by length
(otherwise) -> [*any] = vectorised
⋎ (num a, num b) -> num = a or b (bitwise) # a | b
(str a, num b) -> num = remove bth character of a
(num a, str b) -> str = remove ath character of b
(str a, str b) -> str = a and b joined on longest common prefix and suffix # `abc``cabc`⋎ -> `abcabc`
(otherwise) -> [*any] = vectorised
꘍ (num a, num b) -> num = a xor b (bitwise)
(str a, num b) -> str = a + " " * b # append b spaces to a
(num a, str b) -> str = " " * a + b # prepend a spaces to b
(str a, str b) -> num = levenshtein_distance(a, b) # Levenshtein distance of two strings
(otherwise) -> [*any] = vectorised
ꜝ (num a) -> num = not a (bitwise) # ~a
(str a) -> num = are any letters in a uppercase?
([*any] a) -> [*any] = vectorised
” = ""
‡ (any a, any b, any c) -> any, any, any = c, a, b # shift
⇧ (num a) -> num = a + 2
(str a) -> str = a.uppercase()
([*any] a) -> [*num] = a graded up
⇩ (num a) -> num = a - 2
(str a) -> str = a.lowercase()
([*any] a) -> [*num] = a graded down
∆ = mathematical digraphs
ø = string digraphs
Þ = list digraphs
¨ = misc./transformer digraphs
‘ = two char string
“ = dictionary string
ð ([*any] a, [*num] b) -> [*any] = [a[n] for a in b]
□ -> [*any] = [stack]
↑ (num a) -> num = next prime
(str a) -> str = a.titlecase() # To title case
([*scl]) -> [*scl] = vectorise
([[any, any]] a) -> any = max(a, key=lambda x: x[-1]) # Maximum by tail/last element
↓ (num a) -> num = ath prime
(str a) -> str = substrings(a) # All substrings
([*scl]) -> [*scl] = vectorise
([[any, any]] a) -> any = min(a, key=lambda x: x[-1]) # Minimum by tail/last element
∴ (any a, any b) -> any = max(a, b) # Maximum between a and b
∵ (any a, any b) -> any = min(a, b) # Minimum between a and b
› (num a) -> num = a + 1
(str a) -> str = last half of a
([*any] a) -> [*any] = vectorise
‹ (num a) -> num = a - 1
(str a) -> str = a + "-"
([*any] a) -> [*any] = vectorise
β (any a, num b) -> num = a to base 10 from arbitrary base b # Base conversion
(str a, str b) -> num = a to base 10 from custom base b # Base conversion
τ (num a, num b) -> [*num] = a from base 10 to arbitrary base b # Base conversion
(num a, str b) -> str = a from base 10 to custom base b # Base conversion
(num a, [*any] b) -> [*num] = a from base 10 to custom base b # Base conversion
¶ -> str = "\n"
§ (any a) = print(a, end="") # Print without newline
ε (num a, num b) -> num = abs(a - b)
(non-num a, num b) -> [*any] = rotate a b units to the right
(any a, [*any] b) -> any, [*any] = a, b rotated to the right once
ʀ (num a) -> [*num] = range(0, a + 1)
(otherwise) -> [*num] = range(0, len(a) + 1)
ʁ (num a) -> [*num] = range(0, a)
(otherwise) -> [*num] = range(0, len(a))
ɾ (num a) -> [*num] = range(1, a + 1)
(otherwise) -> [*num] = range(1, len(a) + 1)
ɽ (num a) -> [*num] = range(1, a)
(otherwise) -> [*num] = range(1, len(a))
Π (any a) -> any = product(a) # reduce by multiplication, product
⁽ (any a) = push a to global array
↕ -> [*any] = push global array
⁾ -> any = pop from global array and push to stack
⁺ -> num = index of next character in codepage + 101: ⁺<character>
Ɓ ([*any] a) -> any = cycle reduce between two elements over a: <elementA><elementB>Ɓ -> ((a[0] elementA a[1]) elementB a[2] elementA a[3] ...
Ƈ ([*any] a) -> any = foldr by last element: <element>Ƈ
Ɗ ([*any] a) -> [*any] = cycle map last two elements over a: <elementA><elementB>Ɗ -> [A(a[0]), B(a[1]), A(a[2]), B(a[3])...]
Ƒ ([*any] a) -> [*any] = map last element over pairs: <element>Ƒ
Ɠ (any a, any... b) = if a is truthy, element B, else element A: ABƓ -> if a: A(b) else B(b)
Ƙ ([*any] a) -> [*any] = map last element over suffixes
Ɱ (any a, any b) = over: ABⱮ -> B(A(a), A(b))
Ɲ (any a) = S combinator: ABƝ -> A(a, B(a))
Ƥ (any... a) = parallel apply last N elements: ABCD...ZnƤ
Ƭ (num a) = first a numbers where last element is truthy: <element>Ƭ
Ʋ ([*any] a) -> [*any] = apply last element to each item, treating the item as a stack: <element>Ʋ -> ƛ~<element>;
Ȥ ([*any] a) -> [*any] = zipwith: <element>
δ -> any = stack[-2]
⟨ = open a list: ⟨...⟩
⟩ = close a list
→ (any a) = variable set (= a): →name
← -> any = variable get: ←name
∪ (any a, any b) -> [*any] = set union # Merge without duplicates
∩ (any a, any b) -> [*any] = set intersection # Common elements
⊍ (any a, any b) -> [*any] = set(a) ^ set(b)
kA = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" (uppercase alphabet)
ke = 2.718281828459045 (math.e, Eulers number)
kf = "Fizz"
kb = "Buzz"
kF = "FizzBuzz"
kH = "Hello, World!"
kh = "Hello World"
k1 = 1000
k2 = 10000
k3 = 100000
k4 = 1000000
ka = "abcdefghijklmnopqrstuvwxyz" (lowercase alphabet)
kL = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" (uppercase+lowercase alphabet)
kd = "0123456789" (Digits 0-9)
k6 = "0123456789abcdef" (Hex digits)
k^ = "0123456789ABCDEF" (Hex digits uppercase)
ko = "01234567" (Octal digits)
kp = string.punctuation (Punctuations)
kP = printable ascii
kw = All ASCII whitespace
kr = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" (0-9A-Za-z)
kB = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" (A-Za-z)
kZ = "ZYXWVUTSRQPONMLKJIHGFEDCBA" (uppercase alphabet reversed)
kz = "zyxwvutsrqponmlkjihgfedcba" (lowercase alphabet reversed)
kl = "ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba" (Z-Az-a)
ki = 3.141592653589793 (Pi)
kn = math.nan
kD = * Current day in the format YYYY-MM-DD
kN = * Current time as a list of ⟨hh|mm|ss⟩
kḋ = * Current day in the format DD/MM/YYYY
kḊ = * Current day in the format MM/DD/YYYY
kð = * Current day in the format ⟨DD|MM|YYYY⟩
kβ = "{}[]<>()"
kḂ = "()[]{}" (Brackets)
kƁ = "()[]"
kḃ = "([{" (Open brackets)
k≥ = ")]}" (Close brackets)
k≤ = "([{<" (Fish bones :P)
kΠ = ")]}>"
kv = "aeiou" (Vowels lowercase)
kV = "AEIOU" (Vowels uppercase)
k∨ = "aeiouAEIOU" (vowelsVOWELS)
k⟇ = * Yields the Vyxal codepage
k½ = [1, 2]
k¦ = 2 ** 32, 2^32, 4294967296
k+ = [1, -1]
k- = [-1, 1]
k⁼ = [0, 1]
k/ = "/\\"
kW = "https://"
kẋ = "http://"
k↳ = "https://www."
k² = "http://www.
k₀ = 2048
k₁ = 4096
k₂ = 8192
k₃ = 16384
k₄ = 32768
k₅ = 65536
k₆ = 2147483648
k₇ = 1024
k₈ = 512
k₉ = 360
k⁰ = "bcfghjklmnpqrstvwxyz"
k¹ = "bcfghjklmnpqrstvwxz"
k□ = printable ascii
k• = ["qwertyuiop", "asdfghjkl", "zxcvbnm"] (Qwerty keyboard)
kṠ = current second
kṀ = current minute
kḢ = current hour
kτ = day number of the year, day of year
kṡ = seconds since epoch
k□ = [[0,1],[1,0],[0,-1],[-1,0]]
k‡ = [[0,1],[1,0]]
kɽ = [-1,0,1]
k[ = "[]"
k] = "]["
k( = "()"
k) = ")("
k{ = "{}"
k} = "}{"
kẇ = day of the week - 0 indexed
kẆ = day of the week - 1 indexed
k§ = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
kɖ = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]
----
Apply at specific indices -> element
foldl -> transformer
" " n-wise -> transformer
foldr -> transformer
Cumulative reduce -> transformer [t: done, e: ]
Ternary if -> transformer
First n where -> element
Vectorise -> transformer
outer product -> transformer [t: done, e: ]
dyad => monad -> transformer
sort by -> transformer
map over prefixes -> transformer
filter -> transformer
perform to register -> transformer
collect while unique -> element
loop while unique -> element
map over suffixes -> element
---
zip with -> transformer
apply twice -> element
---
collect while truthy -> element
para Apply -> transformer
" " and collect -> transformer
maximum by -> transformer
minimum by -> transformer
----
deep vectorise -> transformer
split by function -> element
permutations by function -> element
group by -> transformer
first where truthy -> element
first where falsey -> element
applied to every bth term -> transformer
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment