function linearSearch(list: number[], target: number): number {
for (let i = 0; i < list.length; i += 1) {
if (list[i] === target) return i;
}
return -1;
}function sentinelLinearSearch(list: number[], target: number): number {
if (!list.length) return -1;
const copy = [...list, target];
let i = 0;
while (copy[i] !== target) i += 1;
return i < list.length ? i : -1;
}function binarySearchIterative(list: number[], target: number): number {
let left = 0;
let right = list.length - 1;
while (left <= right) {
const mid = Math.floor((left + right) / 2);
if (list[mid] === target) return mid;
if (list[mid] < target) left = mid + 1;
else right = mid - 1;
}
return -1;
}function binarySearchRecursive(
list: number[],
target: number,
left = 0,
right = list.length - 1,
): number {
if (left > right) return -1;
const mid = Math.floor((left + right) / 2);
if (list[mid] === target) return mid;
if (list[mid] < target) return binarySearchRecursive(list, target, mid + 1, right);
return binarySearchRecursive(list, target, left, mid - 1);
}function jumpSearch(list: number[], target: number): number {
const size = Math.floor(Math.sqrt(list.length));
let prev = 0;
let step = size;
while (list[Math.min(step, list.length) - 1] < target) {
prev = step;
step += size;
if (prev >= list.length) return -1;
}
for (let i = prev; i < Math.min(step, list.length); i += 1) {
if (list[i] === target) return i;
}
return -1;
}function interpolationSearch(list: number[], target: number): number {
let low = 0;
let high = list.length - 1;
while (low <= high && target >= list[low] && target <= list[high]) {
const pos = low + Math.floor(((target - list[low]) * (high - low)) /
(list[high] - list[low] || 1));
if (list[pos] === target) return pos;
if (list[pos] < target) low = pos + 1;
else high = pos - 1;
}
return -1;
}function ternarySearch(list: number[], target: number): number {
let left = 0;
let right = list.length - 1;
while (left <= right) {
const step = Math.floor((right - left) / 3);
const mid1 = left + step;
const mid2 = right - step;
if (list[mid1] === target) return mid1;
if (list[mid2] === target) return mid2;
if (target < list[mid1]) right = mid1 - 1;
else if (target > list[mid2]) left = mid2 + 1;
else { left = mid1 + 1; right = mid2 - 1; }
}
return -1;
}function bfs(graph: Record<string, string[]>, start: string): string[] {
const queue = [start];
const seen = new Set([start]);
const order: string[] = [];
while (queue.length) {
const node = queue.shift()!;
order.push(node);
for (const next of graph[node] ?? []) {
if (!seen.has(next)) { seen.add(next); queue.push(next); }
}
}
return order;
}function dfs(graph: Record<string, string[]>, start: string): string[] {
const stack = [start];
const seen = new Set<string>();
const order: string[] = [];
while (stack.length) {
const node = stack.pop()!;
if (seen.has(node)) continue;
seen.add(node);
order.push(node);
stack.push(...(graph[node] ?? []).reverse());
}
return order;
}function depthFirstSearchRecursive(
graph: Record<string, string[]>,
node: string,
seen = new Set<string>(),
order: string[] = [],
): string[] {
if (seen.has(node)) return order;
seen.add(node);
order.push(node);
for (const next of graph[node] ?? []) {
depthFirstSearchRecursive(graph, next, seen, order);
}
return order;
}function depthLimitedSearch(
graph: Record<string, string[]>,
start: string,
target: string,
limit: number,
): boolean {
const search = (node: string, depth: number, seen: Set<string>): boolean => {
if (node === target) return true;
if (depth === limit) return false;
seen.add(node);
for (const next of graph[node] ?? []) {
if (!seen.has(next) && search(next, depth + 1, seen)) return true;
}
return false;
};
return search(start, 0, new Set());
}function linearSearch(list: number[], target: number): number {
for (let i = 0; i < list.length; i += 1) {
if (list[i] === target) return i;
}
return -1;
}function sentinelLinearSearch(list: number[], target: number): number {
if (!list.length) return -1;
const copy = [...list, target];
let i = 0;
while (copy[i] !== target) i += 1;
return i < list.length ? i : -1;
}function binarySearchIterative(list: number[], target: number): number {
let left = 0;
let right = list.length - 1;
while (left <= right) {
const mid = Math.floor((left + right) / 2);
if (list[mid] === target) return mid;
if (list[mid] < target) left = mid + 1;
else right = mid - 1;
}
return -1;
}function binarySearchRecursive(
list: number[],
target: number,
left = 0,
right = list.length - 1,
): number {
if (left > right) return -1;
const mid = Math.floor((left + right) / 2);
if (list[mid] === target) return mid;
if (list[mid] < target) return binarySearchRecursive(list, target, mid + 1, right);
return binarySearchRecursive(list, target, left, mid - 1);
}function jumpSearch(list: number[], target: number): number {
const size = Math.floor(Math.sqrt(list.length));
let prev = 0;
let step = size;
while (list[Math.min(step, list.length) - 1] < target) {
prev = step;
step += size;
if (prev >= list.length) return -1;
}
for (let i = prev; i < Math.min(step, list.length); i += 1) {
if (list[i] === target) return i;
}
return -1;
}function interpolationSearch(list: number[], target: number): number {
let low = 0;
let high = list.length - 1;
while (low <= high && target >= list[low] && target <= list[high]) {
const pos = low + Math.floor(((target - list[low]) * (high - low)) /
(list[high] - list[low] || 1));
if (list[pos] === target) return pos;
if (list[pos] < target) low = pos + 1;
else high = pos - 1;
}
return -1;
}function ternarySearch(list: number[], target: number): number {
let left = 0;
let right = list.length - 1;
while (left <= right) {
const step = Math.floor((right - left) / 3);
const mid1 = left + step;
const mid2 = right - step;
if (list[mid1] === target) return mid1;
if (list[mid2] === target) return mid2;
if (target < list[mid1]) right = mid1 - 1;
else if (target > list[mid2]) left = mid2 + 1;
else { left = mid1 + 1; right = mid2 - 1; }
}
return -1;
}function bfs(graph: Record<string, string[]>, start: string): string[] {
const queue = [start];
const seen = new Set([start]);
const order: string[] = [];
while (queue.length) {
const node = queue.shift()!;
order.push(node);
for (const next of graph[node] ?? []) {
if (!seen.has(next)) { seen.add(next); queue.push(next); }
}
}
return order;
}function dfs(graph: Record<string, string[]>, start: string): string[] {
const stack = [start];
const seen = new Set<string>();
const order: string[] = [];
while (stack.length) {
const node = stack.pop()!;
if (seen.has(node)) continue;
seen.add(node);
order.push(node);
stack.push(...(graph[node] ?? []).reverse());
}
return order;
}function depthFirstSearchRecursive(
graph: Record<string, string[]>,
node: string,
seen = new Set<string>(),
order: string[] = [],
): string[] {
if (seen.has(node)) return order;
seen.add(node);
order.push(node);
for (const next of graph[node] ?? []) {
depthFirstSearchRecursive(graph, next, seen, order);
}
return order;
}function depthLimitedSearch(
graph: Record<string, string[]>,
start: string,
target: string,
limit: number,
): boolean {
const search = (node: string, depth: number, seen: Set<string>): boolean => {
if (node === target) return true;
if (depth === limit) return false;
seen.add(node);
for (const next of graph[node] ?? []) {
if (!seen.has(next) && search(next, depth + 1, seen)) return true;
}
return false;
};
return search(start, 0, new Set());
}function linearSearch(list: number[], target: number): number {
for (let i = 0; i < list.length; i += 1) {
if (list[i] === target) return i;
}
return -1;
}function sentinelLinearSearch(list: number[], target: number): number {
if (!list.length) return -1;
const copy = [...list, target];
let i = 0;
while (copy[i] !== target) i += 1;
return i < list.length ? i : -1;
}function binarySearchIterative(list: number[], target: number): number {
let left = 0;
let right = list.length - 1;
while (left <= right) {
const mid = Math.floor((left + right) / 2);
if (list[mid] === target) return mid;
if (list[mid] < target) left = mid + 1;
else right = mid - 1;
}
return -1;
}function binarySearchRecursive(
list: number[],
target: number,
left = 0,
right = list.length - 1,
): number {
if (left > right) return -1;
const mid = Math.floor((left + right) / 2);
if (list[mid] === target) return mid;
if (list[mid] < target) return binarySearchRecursive(list, target, mid + 1, right);
return binarySearchRecursive(list, target, left, mid - 1);
}function jumpSearch(list: number[], target: number): number {
const size = Math.floor(Math.sqrt(list.length));
let prev = 0;
let step = size;
while (list[Math.min(step, list.length) - 1] < target) {
prev = step;
step += size;
if (prev >= list.length) return -1;
}
for (let i = prev; i < Math.min(step, list.length); i += 1) {
if (list[i] === target) return i;
}
return -1;
}function interpolationSearch(list: number[], target: number): number {
let low = 0;
let high = list.length - 1;
while (low <= high && target >= list[low] && target <= list[high]) {
const pos = low + Math.floor(((target - list[low]) * (high - low)) /
(list[high] - list[low] || 1));
if (list[pos] === target) return pos;
if (list[pos] < target) low = pos + 1;
else high = pos - 1;
}
return -1;
}function ternarySearch(list: number[], target: number): number {
let left = 0;
let right = list.length - 1;
while (left <= right) {
const step = Math.floor((right - left) / 3);
const mid1 = left + step;
const mid2 = right - step;
if (list[mid1] === target) return mid1;
if (list[mid2] === target) return mid2;
if (target < list[mid1]) right = mid1 - 1;
else if (target > list[mid2]) left = mid2 + 1;
else { left = mid1 + 1; right = mid2 - 1; }
}
return -1;
}function bfs(graph: Record<string, string[]>, start: string): string[] {
const queue = [start];
const seen = new Set([start]);
const order: string[] = [];
while (queue.length) {
const node = queue.shift()!;
order.push(node);
for (const next of graph[node] ?? []) {
if (!seen.has(next)) { seen.add(next); queue.push(next); }
}
}
return order;
}function dfs(graph: Record<string, string[]>, start: string): string[] {
const stack = [start];
const seen = new Set<string>();
const order: string[] = [];
while (stack.length) {
const node = stack.pop()!;
if (seen.has(node)) continue;
seen.add(node);
order.push(node);
stack.push(...(graph[node] ?? []).reverse());
}
return order;
}function depthFirstSearchRecursive(
graph: Record<string, string[]>,
node: string,
seen = new Set<string>(),
order: string[] = [],
): string[] {
if (seen.has(node)) return order;
seen.add(node);
order.push(node);
for (const next of graph[node] ?? []) {
depthFirstSearchRecursive(graph, next, seen, order);
}
return order;
}function depthLimitedSearch(
graph: Record<string, string[]>,
start: string,
target: string,
limit: number,
): boolean {
const search = (node: string, depth: number, seen: Set<string>): boolean => {
if (node === target) return true;
if (depth === limit) return false;
seen.add(node);
for (const next of graph[node] ?? []) {
if (!seen.has(next) && search(next, depth + 1, seen)) return true;
}
return false;
};
return search(start, 0, new Set());
}function linearSearch(list: number[], target: number): number {
for (let i = 0; i < list.length; i += 1) {
if (list[i] === target) return i;
}
return -1;
}function sentinelLinearSearch(list: number[], target: number): number {
if (!list.length) return -1;
const copy = [...list, target];
let i = 0;
while (copy[i] !== target) i += 1;
return i < list.length ? i : -1;
}function binarySearchIterative(list: number[], target: number): number {
let left = 0;
let right = list.length - 1;
while (left <= right) {
const mid = Math.floor((left + right) / 2);
if (list[mid] === target) return mid;
if (list[mid] < target) left = mid + 1;
else right = mid - 1;
}
return -1;
}function binarySearchRecursive(
list: number[],
target: number,
left = 0,
right = list.length - 1,
): number {
if (left > right) return -1;
const mid = Math.floor((left + right) / 2);
if (list[mid] === target) return mid;
if (list[mid] < target) return binarySearchRecursive(list, target, mid + 1, right);
return binarySearchRecursive(list, target, left, mid - 1);
}function jumpSearch(list: number[], target: number): number {
const size = Math.floor(Math.sqrt(list.length));
let prev = 0;
let step = size;
while (list[Math.min(step, list.length) - 1] < target) {
prev = step;
step += size;
if (prev >= list.length) return -1;
}
for (let i = prev; i < Math.min(step, list.length); i += 1) {
if (list[i] === target) return i;
}
return -1;
}function interpolationSearch(list: number[], target: number): number {
let low = 0;
let high = list.length - 1;
while (low <= high && target >= list[low] && target <= list[high]) {
const pos = low + Math.floor(((target - list[low]) * (high - low)) /
(list[high] - list[low] || 1));
if (list[pos] === target) return pos;
if (list[pos] < target) low = pos + 1;
else high = pos - 1;
}
return -1;
}function ternarySearch(list: number[], target: number): number {
let left = 0;
let right = list.length - 1;
while (left <= right) {
const step = Math.floor((right - left) / 3);
const mid1 = left + step;
const mid2 = right - step;
if (list[mid1] === target) return mid1;
if (list[mid2] === target) return mid2;
if (target < list[mid1]) right = mid1 - 1;
else if (target > list[mid2]) left = mid2 + 1;
else { left = mid1 + 1; right = mid2 - 1; }
}
return -1;
}function bfs(graph: Record<string, string[]>, start: string): string[] {
const queue = [start];
const seen = new Set([start]);
const order: string[] = [];
while (queue.length) {
const node = queue.shift()!;
order.push(node);
for (const next of graph[node] ?? []) {
if (!seen.has(next)) { seen.add(next); queue.push(next); }
}
}
return order;
}function dfs(graph: Record<string, string[]>, start: string): string[] {
const stack = [start];
const seen = new Set<string>();
const order: string[] = [];
while (stack.length) {
const node = stack.pop()!;
if (seen.has(node)) continue;
seen.add(node);
order.push(node);
stack.push(...(graph[node] ?? []).reverse());
}
return order;
}function depthFirstSearchRecursive(
graph: Record<string, string[]>,
node: string,
seen = new Set<string>(),
order: string[] = [],
): string[] {
if (seen.has(node)) return order;
seen.add(node);
order.push(node);
for (const next of graph[node] ?? []) {
depthFirstSearchRecursive(graph, next, seen, order);
}
return order;
}function depthLimitedSearch(
graph: Record<string, string[]>,
start: string,
target: string,
limit: number,
): boolean {
const search = (node: string, depth: number, seen: Set<string>): boolean => {
if (node === target) return true;
if (depth === limit) return false;
seen.add(node);
for (const next of graph[node] ?? []) {
if (!seen.has(next) && search(next, depth + 1, seen)) return true;
}
return false;
};
return search(start, 0, new Set());
}function linearSearch(list: number[], target: number): number {
for (let i = 0; i < list.length; i += 1) {
if (list[i] === target) return i;
}
return -1;
}function sentinelLinearSearch(list: number[], target: number): number {
if (!list.length) return -1;
const copy = [...list, target];
let i = 0;
while (copy[i] !== target) i += 1;
return i < list.length ? i : -1;
}function binarySearchIterative(list: number[], target: number): number {
let left = 0;
let right = list.length - 1;
while (left <= right) {
const mid = Math.floor((left + right) / 2);
if (list[mid] === target) return mid;
if (list[mid] < target) left = mid + 1;
else right = mid - 1;
}
return -1;
}function binarySearchRecursive(
list: number[],
target: number,
left = 0,
right = list.length - 1,
): number {
if (left > right) return -1;
const mid = Math.floor((left + right) / 2);
if (list[mid] === target) return mid;
if (list[mid] < target) return binarySearchRecursive(list, target, mid + 1, right);
return binarySearchRecursive(list, target, left, mid - 1);
}function jumpSearch(list: number[], target: number): number {
const size = Math.floor(Math.sqrt(list.length));
let prev = 0;
let step = size;
while (list[Math.min(step, list.length) - 1] < target) {
prev = step;
step += size;
if (prev >= list.length) return -1;
}
for (let i = prev; i < Math.min(step, list.length); i += 1) {
if (list[i] === target) return i;
}
return -1;
}function interpolationSearch(list: number[], target: number): number {
let low = 0;
let high = list.length - 1;
while (low <= high && target >= list[low] && target <= list[high]) {
const pos = low + Math.floor(((target - list[low]) * (high - low)) /
(list[high] - list[low] || 1));
if (list[pos] === target) return pos;
if (list[pos] < target) low = pos + 1;
else high = pos - 1;
}
return -1;
}function ternarySearch(list: number[], target: number): number {
let left = 0;
let right = list.length - 1;
while (left <= right) {
const step = Math.floor((right - left) / 3);
const mid1 = left + step;
const mid2 = right - step;
if (list[mid1] === target) return mid1;
if (list[mid2] === target) return mid2;
if (target < list[mid1]) right = mid1 - 1;
else if (target > list[mid2]) left = mid2 + 1;
else { left = mid1 + 1; right = mid2 - 1; }
}
return -1;
}function bfs(graph: Record<string, string[]>, start: string): string[] {
const queue = [start];
const seen = new Set([start]);
const order: string[] = [];
while (queue.length) {
const node = queue.shift()!;
order.push(node);
for (const next of graph[node] ?? []) {
if (!seen.has(next)) { seen.add(next); queue.push(next); }
}
}
return order;
}function dfs(graph: Record<string, string[]>, start: string): string[] {
const stack = [start];
const seen = new Set<string>();
const order: string[] = [];
while (stack.length) {
const node = stack.pop()!;
if (seen.has(node)) continue;
seen.add(node);
order.push(node);
stack.push(...(graph[node] ?? []).reverse());
}
return order;
}function depthFirstSearchRecursive(
graph: Record<string, string[]>,
node: string,
seen = new Set<string>(),
order: string[] = [],
): string[] {
if (seen.has(node)) return order;
seen.add(node);
order.push(node);
for (const next of graph[node] ?? []) {
depthFirstSearchRecursive(graph, next, seen, order);
}
return order;
}function depthLimitedSearch(
graph: Record<string, string[]>,
start: string,
target: string,
limit: number,
): boolean {
const search = (node: string, depth: number, seen: Set<string>): boolean => {
if (node === target) return true;
if (depth === limit) return false;
seen.add(node);
for (const next of graph[node] ?? []) {
if (!seen.has(next) && search(next, depth + 1, seen)) return true;
}
return false;
};
return search(start, 0, new Set());
}function linearSearch(list: number[], target: number): number {
for (let i = 0; i < list.length; i += 1) {
if (list[i] === target) return i;
}
return -1;
}function sentinelLinearSearch(list: number[], target: number): number {
if (!list.length) return -1;
const copy = [...list, target];
let i = 0;
while (copy[i] !== target) i += 1;
return i < list.length ? i : -1;
}function binarySearchIterative(list: number[], target: number): number {
let left = 0;
let right = list.length - 1;
while (left <= right) {
const mid = Math.floor((left + right) / 2);
if (list[mid] === target) return mid;
if (list[mid] < target) left = mid + 1;
else right = mid - 1;
}
return -1;
}function binarySearchRecursive(
list: number[],
target: number,
left = 0,
right = list.length - 1,
): number {
if (left > right) return -1;
const mid = Math.floor((left + right) / 2);
if (list[mid] === target) return mid;
if (list[mid] < target) return binarySearchRecursive(list, target, mid + 1, right);
return binarySearchRecursive(list, target, left, mid - 1);
}function jumpSearch(list: number[], target: number): number {
const size = Math.floor(Math.sqrt(list.length));
let prev = 0;
let step = size;
while (list[Math.min(step, list.length) - 1] < target) {
prev = step;
step += size;
if (prev >= list.length) return -1;
}
for (let i = prev; i < Math.min(step, list.length); i += 1) {
if (list[i] === target) return i;
}
return -1;
}function interpolationSearch(list: number[], target: number): number {
let low = 0;
let high = list.length - 1;
while (low <= high && target >= list[low] && target <= list[high]) {
const pos = low + Math.floor(((target - list[low]) * (high - low)) /
(list[high] - list[low] || 1));
if (list[pos] === target) return pos;
if (list[pos] < target) low = pos + 1;
else high = pos - 1;
}
return -1;
}function ternarySearch(list: number[], target: number): number {
let left = 0;
let right = list.length - 1;
while (left <= right) {
const step = Math.floor((right - left) / 3);
const mid1 = left + step;
const mid2 = right - step;
if (list[mid1] === target) return mid1;
if (list[mid2] === target) return mid2;
if (target < list[mid1]) right = mid1 - 1;
else if (target > list[mid2]) left = mid2 + 1;
else { left = mid1 + 1; right = mid2 - 1; }
}
return -1;
}function bfs(graph: Record<string, string[]>, start: string): string[] {
const queue = [start];
const seen = new Set([start]);
const order: string[] = [];
while (queue.length) {
const node = queue.shift()!;
order.push(node);
for (const next of graph[node] ?? []) {
if (!seen.has(next)) { seen.add(next); queue.push(next); }
}
}
return order;
}function dfs(graph: Record<string, string[]>, start: string): string[] {
const stack = [start];
const seen = new Set<string>();
const order: string[] = [];
while (stack.length) {
const node = stack.pop()!;
if (seen.has(node)) continue;
seen.add(node);
order.push(node);
stack.push(...(graph[node] ?? []).reverse());
}
return order;
}function depthFirstSearchRecursive(
graph: Record<string, string[]>,
node: string,
seen = new Set<string>(),
order: string[] = [],
): string[] {
if (seen.has(node)) return order;
seen.add(node);
order.push(node);
for (const next of graph[node] ?? []) {
depthFirstSearchRecursive(graph, next, seen, order);
}
return order;
}function depthLimitedSearch(
graph: Record<string, string[]>,
start: string,
target: string,
limit: number,
): boolean {
const search = (node: string, depth: number, seen: Set<string>): boolean => {
if (node === target) return true;
if (depth === limit) return false;
seen.add(node);
for (const next of graph[node] ?? []) {
if (!seen.has(next) && search(next, depth + 1, seen)) return true;
}
return false;
};
return search(start, 0, new Set());
}function linearSearch(list: number[], target: number): number {
for (let i = 0; i < list.length; i += 1) {
if (list[i] === target) return i;
}
return -1;
}function sentinelLinearSearch(list: number[], target: number): number {
if (!list.length) return -1;
const copy = [...list, target];
let i = 0;
while (copy[i] !== target) i += 1;
return i < list.length ? i : -1;
}function binarySearchIterative(list: number[], target: number): number {
let left = 0;
let right = list.length - 1;
while (left <= right) {
const mid = Math.floor((left + right) / 2);
if (list[mid] === target) return mid;
if (list[mid] < target) left = mid + 1;
else right = mid - 1;
}
return -1;
}function binarySearchRecursive(
list: number[],
target: number,
left = 0,
right = list.length - 1,
): number {
if (left > right) return -1;
const mid = Math.floor((left + right) / 2);
if (list[mid] === target) return mid;
if (list[mid] < target) return binarySearchRecursive(list, target, mid + 1, right);
return binarySearchRecursive(list, target, left, mid - 1);
}function jumpSearch(list: number[], target: number): number {
const size = Math.floor(Math.sqrt(list.length));
let prev = 0;
let step = size;
while (list[Math.min(step, list.length) - 1] < target) {
prev = step;
step += size;
if (prev >= list.length) return -1;
}
for (let i = prev; i < Math.min(step, list.length); i += 1) {
if (list[i] === target) return i;
}
return -1;
}function interpolationSearch(list: number[], target: number): number {
let low = 0;
let high = list.length - 1;
while (low <= high && target >= list[low] && target <= list[high]) {
const pos = low + Math.floor(((target - list[low]) * (high - low)) /
(list[high] - list[low] || 1));
if (list[pos] === target) return pos;
if (list[pos] < target) low = pos + 1;
else high = pos - 1;
}
return -1;
}function ternarySearch(list: number[], target: number): number {
let left = 0;
let right = list.length - 1;
while (left <= right) {
const step = Math.floor((right - left) / 3);
const mid1 = left + step;
const mid2 = right - step;
if (list[mid1] === target) return mid1;
if (list[mid2] === target) return mid2;
if (target < list[mid1]) right = mid1 - 1;
else if (target > list[mid2]) left = mid2 + 1;
else { left = mid1 + 1; right = mid2 - 1; }
}
return -1;
}function bfs(graph: Record<string, string[]>, start: string): string[] {
const queue = [start];
const seen = new Set([start]);
const order: string[] = [];
while (queue.length) {
const node = queue.shift()!;
order.push(node);
for (const next of graph[node] ?? []) {
if (!seen.has(next)) { seen.add(next); queue.push(next); }
}
}
return order;
}function dfs(graph: Record<string, string[]>, start: string): string[] {
const stack = [start];
const seen = new Set<string>();
const order: string[] = [];
while (stack.length) {
const node = stack.pop()!;
if (seen.has(node)) continue;
seen.add(node);
order.push(node);
stack.push(...(graph[node] ?? []).reverse());
}
return order;
}function depthFirstSearchRecursive(
graph: Record<string, string[]>,
node: string,
seen = new Set<string>(),
order: string[] = [],
): string[] {
if (seen.has(node)) return order;
seen.add(node);
order.push(node);
for (const next of graph[node] ?? []) {
depthFirstSearchRecursive(graph, next, seen, order);
}
return order;
}function depthLimitedSearch(
graph: Record<string, string[]>,
start: string,
target: string,
limit: number,
): boolean {
const search = (node: string, depth: number, seen: Set<string>): boolean => {
if (node === target) return true;
if (depth === limit) return false;
seen.add(node);
for (const next of graph[node] ?? []) {
if (!seen.has(next) && search(next, depth + 1, seen)) return true;
}
return false;
};
return search(start, 0, new Set());
}function linearSearch(list: number[], target: number): number {
for (let i = 0; i < list.length; i += 1) {
if (list[i] === target) return i;
}
return -1;
}function sentinelLinearSearch(list: number[], target: number): number {
if (!list.length) return -1;
const copy = [...list, target];
let i = 0;
while (copy[i] !== target) i += 1;
return i < list.length ? i : -1;
}function binarySearchIterative(list: number[], target: number): number {
let left = 0;
let right = list.length - 1;
while (left <= right) {
const mid = Math.floor((left + right) / 2);
if (list[mid] === target) return mid;
if (list[mid] < target) left = mid + 1;
else right = mid - 1;
}
return -1;
}function binarySearchRecursive(
list: number[],
target: number,
left = 0,
right = list.length - 1,
): number {
if (left > right) return -1;
const mid = Math.floor((left + right) / 2);
if (list[mid] === target) return mid;
if (list[mid] < target) return binarySearchRecursive(list, target, mid + 1, right);
return binarySearchRecursive(list, target, left, mid - 1);
}function jumpSearch(list: number[], target: number): number {
const size = Math.floor(Math.sqrt(list.length));
let prev = 0;
let step = size;
while (list[Math.min(step, list.length) - 1] < target) {
prev = step;
step += size;
if (prev >= list.length) return -1;
}
for (let i = prev; i < Math.min(step, list.length); i += 1) {
if (list[i] === target) return i;
}
return -1;
}function interpolationSearch(list: number[], target: number): number {
let low = 0;
let high = list.length - 1;
while (low <= high && target >= list[low] && target <= list[high]) {
const pos = low + Math.floor(((target - list[low]) * (high - low)) /
(list[high] - list[low] || 1));
if (list[pos] === target) return pos;
if (list[pos] < target) low = pos + 1;
else high = pos - 1;
}
return -1;
}function ternarySearch(list: number[], target: number): number {
let left = 0;
let right = list.length - 1;
while (left <= right) {
const step = Math.floor((right - left) / 3);
const mid1 = left + step;
const mid2 = right - step;
if (list[mid1] === target) return mid1;
if (list[mid2] === target) return mid2;
if (target < list[mid1]) right = mid1 - 1;
else if (target > list[mid2]) left = mid2 + 1;
else { left = mid1 + 1; right = mid2 - 1; }
}
return -1;
}function bfs(graph: Record<string, string[]>, start: string): string[] {
const queue = [start];
const seen = new Set([start]);
const order: string[] = [];
while (queue.length) {
const node = queue.shift()!;
order.push(node);
for (const next of graph[node] ?? []) {
if (!seen.has(next)) { seen.add(next); queue.push(next); }
}
}
return order;
}function dfs(graph: Record<string, string[]>, start: string): string[] {
const stack = [start];
const seen = new Set<string>();
const order: string[] = [];
while (stack.length) {
const node = stack.pop()!;
if (seen.has(node)) continue;
seen.add(node);
order.push(node);
stack.push(...(graph[node] ?? []).reverse());
}
return order;
}function depthFirstSearchRecursive(
graph: Record<string, string[]>,
node: string,
seen = new Set<string>(),
order: string[] = [],
): string[] {
if (seen.has(node)) return order;
seen.add(node);
order.push(node);
for (const next of graph[node] ?? []) {
depthFirstSearchRecursive(graph, next, seen, order);
}
return order;
}function depthLimitedSearch(
graph: Record<string, string[]>,
start: string,
target: string,
limit: number,
): boolean {
const search = (node: string, depth: number, seen: Set<string>): boolean => {
if (node === target) return true;
if (depth === limit) return false;
seen.add(node);
for (const next of graph[node] ?? []) {
if (!seen.has(next) && search(next, depth + 1, seen)) return true;
}
return false;
};
return search(start, 0, new Set());
}function linearSearch(list: number[], target: number): number {
for (let i = 0; i < list.length; i += 1) {
if (list[i] === target) return i;
}
return -1;
}function sentinelLinearSearch(list: number[], target: number): number {
if (!list.length) return -1;
const copy = [...list, target];
let i = 0;
while (copy[i] !== target) i += 1;
return i < list.length ? i : -1;
}function binarySearchIterative(list: number[], target: number): number {
let left = 0;
let right = list.length - 1;
while (left <= right) {
const mid = Math.floor((left + right) / 2);
if (list[mid] === target) return mid;
if (list[mid] < target) left = mid + 1;
else right = mid - 1;
}
return -1;
}function binarySearchRecursive(
list: number[],
target: number,
left = 0,
right = list.length - 1,
): number {
if (left > right) return -1;
const mid = Math.floor((left + right) / 2);
if (list[mid] === target) return mid;
if (list[mid] < target) return binarySearchRecursive(list, target, mid + 1, right);
return binarySearchRecursive(list, target, left, mid - 1);
}function jumpSearch(list: number[], target: number): number {
const size = Math.floor(Math.sqrt(list.length));
let prev = 0;
let step = size;
while (list[Math.min(step, list.length) - 1] < target) {
prev = step;
step += size;
if (prev >= list.length) return -1;
}
for (let i = prev; i < Math.min(step, list.length); i += 1) {
if (list[i] === target) return i;
}
return -1;
}function interpolationSearch(list: number[], target: number): number {
let low = 0;
let high = list.length - 1;
while (low <= high && target >= list[low] && target <= list[high]) {
const pos = low + Math.floor(((target - list[low]) * (high - low)) /
(list[high] - list[low] || 1));
if (list[pos] === target) return pos;
if (list[pos] < target) low = pos + 1;
else high = pos - 1;
}
return -1;
}function ternarySearch(list: number[], target: number): number {
let left = 0;
let right = list.length - 1;
while (left <= right) {
const step = Math.floor((right - left) / 3);
const mid1 = left + step;
const mid2 = right - step;
if (list[mid1] === target) return mid1;
if (list[mid2] === target) return mid2;
if (target < list[mid1]) right = mid1 - 1;
else if (target > list[mid2]) left = mid2 + 1;
else { left = mid1 + 1; right = mid2 - 1; }
}
return -1;
}function bfs(graph: Record<string, string[]>, start: string): string[] {
const queue = [start];
const seen = new Set([start]);
const order: string[] = [];
while (queue.length) {
const node = queue.shift()!;
order.push(node);
for (const next of graph[node] ?? []) {
if (!seen.has(next)) { seen.add(next); queue.push(next); }
}
}
return order;
}function dfs(graph: Record<string, string[]>, start: string): string[] {
const stack = [start];
const seen = new Set<string>();
const order: string[] = [];
while (stack.length) {
const node = stack.pop()!;
if (seen.has(node)) continue;
seen.add(node);
order.push(node);
stack.push(...(graph[node] ?? []).reverse());
}
return order;
}function depthFirstSearchRecursive(
graph: Record<string, string[]>,
node: string,
seen = new Set<string>(),
order: string[] = [],
): string[] {
if (seen.has(node)) return order;
seen.add(node);
order.push(node);
for (const next of graph[node] ?? []) {
depthFirstSearchRecursive(graph, next, seen, order);
}
return order;
}function depthLimitedSearch(
graph: Record<string, string[]>,
start: string,
target: string,
limit: number,
): boolean {
const search = (node: string, depth: number, seen: Set<string>): boolean => {
if (node === target) return true;
if (depth === limit) return false;
seen.add(node);
for (const next of graph[node] ?? []) {
if (!seen.has(next) && search(next, depth + 1, seen)) return true;
}
return false;
};
return search(start, 0, new Set());
}function linearSearch(list: number[], target: number): number {
for (let i = 0; i < list.length; i += 1) {
if (list[i] === target) return i;
}
return -1;
}function sentinelLinearSearch(list: number[], target: number): number {
if (!list.length) return -1;
const copy = [...list, target];
let i = 0;
while (copy[i] !== target) i += 1;
return i < list.length ? i : -1;
}function binarySearchIterative(list: number[], target: number): number {
let left = 0;
let right = list.length - 1;
while (left <= right) {
const mid = Math.floor((left + right) / 2);
if (list[mid] === target) return mid;
if (list[mid] < target) left = mid + 1;
else right = mid - 1;
}
return -1;
}function binarySearchRecursive(
list: number[],
target: number,
left = 0,
right = list.length - 1,
): number {
if (left > right) return -1;
const mid = Math.floor((left + right) / 2);
if (list[mid] === target) return mid;
if (list[mid] < target) return binarySearchRecursive(list, target, mid + 1, right);
return binarySearchRecursive(list, target, left, mid - 1);
}function jumpSearch(list: number[], target: number): number {
const size = Math.floor(Math.sqrt(list.length));
let prev = 0;
let step = size;
while (list[Math.min(step, list.length) - 1] < target) {
prev = step;
step += size;
if (prev >= list.length) return -1;
}
for (let i = prev; i < Math.min(step, list.length); i += 1) {
if (list[i] === target) return i;
}
return -1;
}function interpolationSearch(list: number[], target: number): number {
let low = 0;
let high = list.length - 1;
while (low <= high && target >= list[low] && target <= list[high]) {
const pos = low + Math.floor(((target - list[low]) * (high - low)) /
(list[high] - list[low] || 1));
if (list[pos] === target) return pos;
if (list[pos] < target) low = pos + 1;
else high = pos - 1;
}
return -1;
}function ternarySearch(list: number[], target: number): number {
let left = 0;
let right = list.length - 1;
while (left <= right) {
const step = Math.floor((right - left) / 3);
const mid1 = left + step;
const mid2 = right - step;
if (list[mid1] === target) return mid1;
if (list[mid2] === target) return mid2;
if (target < list[mid1]) right = mid1 - 1;
else if (target > list[mid2]) left = mid2 + 1;
else { left = mid1 + 1; right = mid2 - 1; }
}
return -1;
}function bfs(graph: Record<string, string[]>, start: string): string[] {
const queue = [start];
const seen = new Set([start]);
const order: string[] = [];
while (queue.length) {
const node = queue.shift()!;
order.push(node);
for (const next of graph[node] ?? []) {
if (!seen.has(next)) { seen.add(next); queue.push(next); }
}
}
return order;
}function dfs(graph: Record<string, string[]>, start: string): string[] {
const stack = [start];
const seen = new Set<string>();
const order: string[] = [];
while (stack.length) {
const node = stack.pop()!;
if (seen.has(node)) continue;
seen.add(node);
order.push(node);
stack.push(...(graph[node] ?? []).reverse());
}
return order;
}function depthFirstSearchRecursive(
graph: Record<string, string[]>,
node: string,
seen = new Set<string>(),
order: string[] = [],
): string[] {
if (seen.has(node)) return order;
seen.add(node);
order.push(node);
for (const next of graph[node] ?? []) {
depthFirstSearchRecursive(graph, next, seen, order);
}
return order;
}function depthLimitedSearch(
graph: Record<string, string[]>,
start: string,
target: string,
limit: number,
): boolean {
const search = (node: string, depth: number, seen: Set<string>): boolean => {
if (node === target) return true;
if (depth === limit) return false;
seen.add(node);
for (const next of graph[node] ?? []) {
if (!seen.has(next) && search(next, depth + 1, seen)) return true;
}
return false;
};
return search(start, 0, new Set());
}function linearSearch(list: number[], target: number): number {
for (let i = 0; i < list.length; i += 1) {
if (list[i] === target) return i;
}
return -1;
}function sentinelLinearSearch(list: number[], target: number): number {
if (!list.length) return -1;
const copy = [...list, target];
let i = 0;
while (copy[i] !== target) i += 1;
return i < list.length ? i : -1;
}function binarySearchIterative(list: number[], target: number): number {
let left = 0;
let right = list.length - 1;
while (left <= right) {
const mid = Math.floor((left + right) / 2);
if (list[mid] === target) return mid;
if (list[mid] < target) left = mid + 1;
else right = mid - 1;
}
return -1;
}function binarySearchRecursive(
list: number[],
target: number,
left = 0,
right = list.length - 1,
): number {
if (left > right) return -1;
const mid = Math.floor((left + right) / 2);
if (list[mid] === target) return mid;
if (list[mid] < target) return binarySearchRecursive(list, target, mid + 1, right);
return binarySearchRecursive(list, target, left, mid - 1);
}function jumpSearch(list: number[], target: number): number {
const size = Math.floor(Math.sqrt(list.length));
let prev = 0;
let step = size;
while (list[Math.min(step, list.length) - 1] < target) {
prev = step;
step += size;
if (prev >= list.length) return -1;
}
for (let i = prev; i < Math.min(step, list.length); i += 1) {
if (list[i] === target) return i;
}
return -1;
}function interpolationSearch(list: number[], target: number): number {
let low = 0;
let high = list.length - 1;
while (low <= high && target >= list[low] && target <= list[high]) {
const pos = low + Math.floor(((target - list[low]) * (high - low)) /
(list[high] - list[low] || 1));
if (list[pos] === target) return pos;
if (list[pos] < target) low = pos + 1;
else high = pos - 1;
}
return -1;
}function ternarySearch(list: number[], target: number): number {
let left = 0;
let right = list.length - 1;
while (left <= right) {
const step = Math.floor((right - left) / 3);
const mid1 = left + step;
const mid2 = right - step;
if (list[mid1] === target) return mid1;
if (list[mid2] === target) return mid2;
if (target < list[mid1]) right = mid1 - 1;
else if (target > list[mid2]) left = mid2 + 1;
else { left = mid1 + 1; right = mid2 - 1; }
}
return -1;
}function bfs(graph: Record<string, string[]>, start: string): string[] {
const queue = [start];
const seen = new Set([start]);
const order: string[] = [];
while (queue.length) {
const node = queue.shift()!;
order.push(node);
for (const next of graph[node] ?? []) {
if (!seen.has(next)) { seen.add(next); queue.push(next); }
}
}
return order;
}function dfs(graph: Record<string, string[]>, start: string): string[] {
const stack = [start];
const seen = new Set<string>();
const order: string[] = [];
while (stack.length) {
const node = stack.pop()!;
if (seen.has(node)) continue;
seen.add(node);
order.push(node);
stack.push(...(graph[node] ?? []).reverse());
}
return order;
}function depthFirstSearchRecursive(
graph: Record<string, string[]>,
node: string,
seen = new Set<string>(),
order: string[] = [],
): string[] {
if (seen.has(node)) return order;
seen.add(node);
order.push(node);
for (const next of graph[node] ?? []) {
depthFirstSearchRecursive(graph, next, seen, order);
}
return order;
}Minh Le
Tinkering with web apps since the early days of dial-up.
WASD