---
description: k files
globs: *.k
---
Use ngn/k for k files.

ngn/k Cheatsheet

Basics

Running k Code

1+2     / Addition
3-1     / Subtraction
2*3     / Multiplication
10%3    / Division (floating point if needed)

Right-to-Left Evaluation

1+5*2-2  / Evaluates as: 1 + (5 * (2 - 2)) = 1
1+(5*2)-2  / Parentheses force standard order

Assignments

a: 10      / Assign 10 to a
b: a+5     / Assign 15 to b

Comments

/ This is a comment

Data Types

Atoms (Scalars)

42        / Integer
3.14      / Float
"c"       / Character
`symbol   / Symbol

Vectors (1D Arrays)

1 2 3 4        / Integer vector
1.2 3.4 5.6    / Float vector
"abcd"         / Character vector
`foo`bar`baz   / Symbol vector

Lists (Nested Arrays)

(1 2 3; 4 5)   / List of vectors
("abc"; 1 2 3) / Mixed-type list

Vectorized Operations

Unlike traditional languages, operations apply element-wise:

1 2 3 + 4      / 5 6 7
2 * 1 2 3      / 2 4 6

Operations also work on nested lists:

(1 2; 3 4) + 10  / (11 12; 13 14)

Indexing

x: 10 20 30 40
x[2]        / Returns 30
x[1 3]      / Returns 20 40

For lists:

l: (10 20 30; "abc"; `sym)
l[1]        / Returns "abc"
l[0][2]     / Returns 30

Built-in Verbs

Arithmetic

+  Flip (transpose matrix), Add
-  Negate (monadic), Subtract (dyadic)
*  First (monadic), Multiply (dyadic)
%  Square root (monadic), Divide (dyadic)
!  Factorial (monadic), Modulo (dyadic)

Comparisons

<  Less than, Ascend (monadic)
>  Greater than, Descend (monadic)
=  Equal, Group (monadic)
~  Match (deep equality), Not (monadic)

Logical Operations

&  Min (dyadic), Where (monadic)
|  Max (dyadic), Reverse (monadic)

Data Manipulation

,  Concat, Enlist (monadic)
^  Without (dyadic), Null (monadic)
#  Reshape (dyadic), Length (monadic)
_  Drop (dyadic), Floor (monadic)
$  Cast (dyadic), String (monadic)
?  Find (dyadic), Unique (monadic), Random selection
@  Apply (indexing and function calls)
.  Drill (deep indexing)

Adverbs (Higher-order Operations)

Each (')

2*'1 2 3  / Returns 2 4 6

Reduce (/)

+/1 2 3   / Returns sum: 6

Scan (\)

+\1 2 3   / Returns running sum: 1 3 6

Each-Prior (':)

+': 1 2 3 4  / Returns 1 3 5 7 (pairwise sum)

Each-Right (/:)

1 2*/:3 4  / Returns (3 6; 4 8)

Each-Left (\:)

1 2*\:3 4  / Returns (3 4; 6 8)

Window (i':)

3':!10  / Sliding window

Stencil (i f':)

3+/':!10  / Stencil sum

Bin Search (X')

1 3 5 7 9'8 9 0  / Bin classification

Array-Oriented Typing vs Traditional Languages

Key Differences

Operations are implicitly vectorized

No need for loops to apply operations to arrays

Example: 2 * 1 2 3 produces 2 4 6 directly

Data is homogeneously typed

Unlike Python lists, k enforces consistent typing in arrays

Example: 1 2 "a" would cause an error

Functions behave like array transformations

Monadic (single argument) and dyadic (two arguments) versions exist

Example: * 1 2 3 returns 1 (first element), 1*2 3 returns 2 3

Indexing and function application use the same syntax

f[2] calls f with argument 2

arr[2] retrieves index 2 from arr

Example: Simple Statistics

x: 1 2 3 4 5
mean: (+/x) % #x  / Sum divided by count
mean / this will print to screen aka return from main