The whole Programming in C formula sheet, to print

Holds for any fixed-width integer type once its width $n$ in bits and its signedness are known. Use it to check whether a constant fits the type it is stored in.

The standard leaves this conversion implementation-defined. On the two's complement machines these notes assume, the result is the value above. For example, 200 stored in a signed 8-bit char gives $200-256=-56$. An unsigned $n$-bit type always stores $r$, and that case is defined by the standard.

Here $\sim x$ is the bitwise complement. Arithmetic done in unsigned int (or a wider unsigned type) never overflows in the undefined-behaviour sense: it is defined to wrap modulo $2^n$. Signed overflow, such as INT_MAX + 1, is undefined behaviour. Converting an out-of-range value to a signed type is implementation-defined (see the storing rule in the previous section).

Holds for C integer operands when $a/b$ is representable. Truncation toward zero means that the sign of a % b follows the sign of a. Division or % by zero is undefined behaviour.

For any array a with element type T. The same value is the address a + i. C arrays always start at index 0, and memory is byte-addressable.

The array is declared T a[R][C]. C is the number of COLUMNS (the row length), i is the row index and j is the column index, both starting at 0. The number of rows R does not appear.

The array is declared T a[X][Y][Z], with all indices starting at 0. The first dimension X does not appear.

Use this for a language-neutral array A[l1..u1][l2..u2] with element size w bytes, where Base is the address of A[l1][l2]. For column-major storage, swap the roles of the two indices: Base + ((j − l2)(u1 − l1 + 1) + (i − l1)) × w. For C arrays, l1 = l2 = 0 and this reduces to the formula above.

n is the number of characters in the literal, which contains no embedded '\0'. The +1 is the terminator. So char t[] = "GATE"; gives sizeof(t) = 5 while strlen(t) = 4. If a size is written, the array has that size: char t[10] = "GATE"; has sizeof(t) = 10, with the unused bytes set to '\0'. char t[4] = "GATE"; is legal C but stores NO terminator.

Apply it member by member, in declaration order. 'End of previous member' is that member's offset plus its size, and it is 0 for the first member. align(m) is the alignment of m's type, equal to its size under the convention above.

E is the end offset of the last member (its offset plus its size). A_max is the largest alignment among all members.

S_max is the size of the largest member and A_max is the largest alignment among all members.

For a function that makes exactly one recursive call, on $n-1$, and stops at n == 0 without a further call (for example, a factorial with base case n == 0). $C(n)$ counts the initial call and the base-case call. If the base case is at n == 1 instead (with $n\ge 1$), the count is $n$. Always check where the base case fires.

For a function that makes one recursive call on n / 2 (integer division) and stops at n == 0, like bin above. The calls that print or do work (those with $n\ge 1$) number $\lfloor {\log }_{2}n\rfloor +1$, which is the number of bits of $n$. The extra call is the base case n == 0.

For a function with base cases n == 0 and n == 1 that makes no further calls, and otherwise calls itself on $n-1$ and $n-2$. The $+1$ counts the current call. $F_k$ is the standard Fibonacci sequence $F_0=0,F_1=1,F_k=F_{k-1}+F_{k-2}$. Of the $2F_{n+1}-1$ calls, $F_{n+1}$ are base-case calls (leaves) and $F_{n+1}-1$ make further calls. The count grows as $\Theta ({\phi }^n)$, where $\phi =(1+\sqrt{5})/2\approx 1.618$.

Holds when each non-base call does a constant amount of work $c$ and makes exactly one recursive call on $n-1$, and the base case at $n=0$ costs $c_0$. Substitute $T(n-1)=T(n-2)+c$ repeatedly: $T(n)=T(n-k)+kc$, then put $k=n$.

Unrolling gives $M(n)=2^{k}M(n-k)+(2^k-1)$; put $k=n$. The same shape counts calls when the base case is n == 0 and is itself counted: $C(n)=2C(n-1)+1,C(0)=1\Rightarrow C(n)=2^{n+1}-1$.