Fundamental Information Technology Engineer Examination flashcards

31 cards. Read the term and the definition here. The deck at the top of this page is optional.

Two's complement range

For n bits, signed values run from −2^(n−1) to 2^(n−1)−1. Negation is done by inverting every bit and adding 1, which is why there is one more negative value than positive.

MTBF and availability

MTBF is mean time between failures, total operating time divided by failure count. Availability equals MTBF divided by MTBF plus MTTR, so shortening repair time raises availability without changing reliability.

Cache average access time

With hit rate h, cache time t1, and memory time t2, average access time is h×t1 + (1−h)×t2. A higher hit rate pulls the average close to the fast cache time.

Third normal form

A relation is in 3NF when it is in 2NF and no non-key attribute depends transitively on a non-key attribute. Every non-key attribute must depend only on candidate keys.

SQL WHERE versus HAVING

WHERE filters individual rows before grouping, while HAVING filters whole groups after GROUP BY. Aggregate conditions such as COUNT(*) > 3 belong in HAVING, not WHERE.

TCP versus UDP

TCP is connection-oriented, ordered, and reliable, using acknowledgements and retransmission. UDP is connectionless and unreliable with low overhead, suited to streaming and DNS queries.

Digital signature keys

A sender signs with their own private key, and any receiver verifies with the sender's public key. This proves origin and detects tampering but does not hide the message content.

Hybrid encryption in TLS

TLS uses slow public-key cryptography to share a session key, then fast symmetric encryption such as AES for the actual data. This combines key exchange safety with bulk throughput.

PERT expected duration

Expected duration equals (optimistic + 4×most likely + pessimistic) divided by 6. The weighted average favors the most likely estimate and smooths out optimistic or pessimistic extremes.

CPI and SPI

Cost performance index is earned value divided by actual cost; schedule performance index is earned value divided by planned value. Values below 1 mean over budget or behind schedule.

Critical path

The critical path is the longest path through a project network diagram and determines the shortest possible completion time. Activities on it have zero total float.

RAID levels

RAID 0 stripes with no redundancy, RAID 1 mirrors for full redundancy, and RAID 5 stripes with distributed parity so it survives one disk failure at lower cost than mirroring.

Private IPv4 ranges

The private ranges are 10.0.0.0/8, 172.16.0.0/12, and 192.168.0.0/16. They are not routed on the internet and require NAT to reach external hosts.

Subnet host count

With an IPv4 /n prefix, host bits equal 32−n, giving 2^(32−n) addresses. Subtract two for the network and broadcast addresses, so a /24 yields 254 usable hosts.

Break-even quantity

Break-even quantity equals fixed cost divided by price minus variable cost per unit. Above that volume each unit sold adds to profit; below it the product runs at a loss.

Parallel redundancy failure

Two independent units each failing with probability p fail together with probability p². Parallel redundancy therefore sharply lowers system failure probability compared with a single unit.

Binary search complexity

Binary search requires sorted data and halves the range each comparison, so it needs about ⌈log2 n⌉+1 comparisons at most. A thousand elements need roughly ten comparisons.

Stack versus queue

A stack is last-in-first-out with push and pop, used for expression evaluation and recursion. A queue is first-in-first-out with enqueue and dequeue, used for buffering and breadth-first search.

Sorting complexity summary

Bubble, selection, and insertion sort are O(n²). Quicksort averages O(n log n) but degrades to O(n²) with bad pivots, while merge sort guarantees O(n log n) using extra memory.

Stable sorting

A stable sort keeps equal keys in their original relative order. Insertion sort and merge sort are stable; selection sort and typical quicksort implementations are not.

Binary search tree traversal

In-order traversal of a binary search tree visits keys in ascending order. Search, insert, and delete cost O(log n) when balanced but O(n) when the tree degenerates into a chain.

Binary tree node bound

A binary tree of height h has at most 2^h−1 nodes, and a node at depth d has at most 2^d descendants at that level. A full level d holds exactly 2^d nodes.

Hash table load factor

Load factor is stored elements divided by table size. Average lookup is O(1), but the worst case is O(n) when every key collides, handled by chaining or open addressing.

Recursion base case

Every recursive procedure needs a base case and must make progress toward it each call. Without a base case or with non-shrinking arguments it recurses until the stack overflows.

Naive Fibonacci cost

Naive recursive Fibonacci makes two calls per level, giving O(2^n) time. Memoizing results or iterating from the bottom gives O(n) time instead.

DFS versus BFS

Depth-first search uses a stack or recursion and explores deep paths first. Breadth-first search uses a queue and visits level by level; both run in O(V+E) on a graph.

Dijkstra precondition

Dijkstra's algorithm finds single-source shortest paths when all edge weights are non-negative. Negative weights require Bellman-Ford, and all-pairs shortest paths can use Floyd-Warshall in O(n³).

Pass by value

Passing by value copies the argument, so changes inside the function do not affect the caller's variable. Passing by reference shares storage, so modifications are visible after return.

Integer division truncation

In many languages integer division truncates toward zero, so −7/2 gives −3, not −4. Modulo then satisfies a = (a/b)×b + (a mod b) with the truncated quotient.

Triangular loop count

When the inner loop bound depends on the outer index, total iterations are n(n+1)/2. That is still O(n²) in big-O notation because constants and lower terms drop out.

Dynamic programming condition

Dynamic programming applies when a problem has overlapping subproblems and optimal substructure. Results are stored in a table so each subproblem is computed only once.