This Solidity contract includes a function to reverse an array of unsigned integers in place. It efficiently swaps elements from the beginning and end of the array until the middle is reached. This is a fundamental array...

The `reverseArray` function takes a storage array of `uint256` and reverses its elements in place. It iterates from the start of the array up to `n / 2`, where `n` is the length of the array. In each iteration, it swaps the element at index `i` with the element at index `n - 1 - i`. This ensures that elements are correctly mirrored. The loop condition `i < n / 2` correctly handles both even and odd length arrays; for odd length arrays, the middle element remains in its position. An edge case for an empty array (`n == 0`) is handled by returning immediately. The time complexity is O(n/2), which simplifies to O(n), where n is the number of elements in the array, due to the single loop and constant time swap operations. The space complexity is O(1) as it only uses a temporary variable for swapping and modifies the array in place.

Function reverseArray(arr): n = length of arr If n is 0: Return For i from 0 to n / 2 - 1: temp = arr[i] arr[i] = arr[n - 1 - i] arr[n - 1 - i] = temp

This Solidity contract provides safe arithmetic operations for unsigned integers. It prevents common overflow and underflow errors that can occur in smart contracts, ensuring that calculations do not wrap around unexpect...

The `SafeMath` contract implements several utility functions for basic arithmetic operations: `add`, `sub`, `mul`, `div`, and `mod`. Each function includes checks to prevent common integer vulnerabilities. For addition, it checks if the result `c` is less than `a`, which indicates an overflow. For subtraction, it ensures `b` is not greater than `a` to prevent underflow. Multiplication checks if `c / a` equals `b`, catching overflows. Division and modulo operations explicitly check for division by zero. These checks ensure that any operation that would result in an invalid state will cause the transaction to revert, maintaining the integrity of the contract's state. The time complexity for each operation is O(1) as they involve a fixed number of arithmetic operations and comparisons. The space complexity is also O(1).

Function add(a, b): c = a + b If c < a: Revert "Overflow" Return c Function sub(a, b): If b > a: Revert "Underflow" c = a - b Return c Function mul(a, b): If a == 0: Return 0 c = a * b If c / a != b: Revert "Overflow" Re...

This Solidity contract computes Fibonacci numbers using a recursive approach enhanced with memoization. The Fibonacci sequence is defined by F(0) = 0, F(1) = 1, and F(n) = F(n-1) + F(n-2) for n > 1. Memoization stores pr...

The `fibonacci` function calculates the Nth Fibonacci number. It employs recursion with memoization to avoid recalculating values. The base cases are `n = 0` returning 0 and `n = 1` returning 1. For `n > 1`, it first checks if `memo[n]` is already populated (i.e., not 0). If it is, the stored value is returned directly. Otherwise, it recursively calls `fibonacci(n - 1)` and `fibonacci(n - 2)`, sums their results, stores this sum in `memo[n]`, and then returns it. This memoization drastically reduces the number of function calls from exponential (O(2^n)) to linear (O(n)). The space complexity is also O(n) due to the storage of computed values in the `memo` mapping. The `clearMemo` function provides a way to reset the cache, though it has limitations for very large caches due to gas costs. The `getMemoizedValue` is a view helper for inspection.

Function fibonacci(n): If n is 0: Return 0 If n is 1: Return 1 If memo[n] is not 0: Return memo[n] result = fibonacci(n - 1) + fibonacci(n - 2) memo[n] = result Return result

This Solidity contract implements a binary search algorithm, a highly efficient method for finding a specific element within a sorted array. It works by repeatedly dividing the search interval in half. If the value of th...

The `binarySearch` function efficiently finds a `target` value within a sorted `uint256` array `arr`. It initializes `low` to 0 and `high` to the last index of the array. The `while (low <= high)` loop continues as long as the search space is valid. Inside the loop, `mid` is calculated to prevent overflow. If `arr[mid]` equals `target`, `mid` is returned. If `arr[mid]` is less than `target`, `low` is updated to `mid + 1` (searching the right half). Otherwise, `high` is updated to `mid - 1` (searching the left half). If the loop finishes without finding the target, -1 is returned. The time complexity is O(log n) because the search space is halved in each iteration. The space complexity is O(1) as it uses a fixed amount of extra space for variables. The `findFirstOccurrence` function is a variation that adapts binary search to find the first instance of a target value.

Function binarySearch(arr, target): low = 0 high = length of arr - 1 While low <= high: mid = low + (high - low) / 2 If arr[mid] == target: Return mid Else if arr[mid] < target: low = mid + 1 Else: high = mid - 1 Return...

This Solidity contract `ArrayUtils` contains a function `findMax` that determines the largest integer within a given array of `int256`. It is designed to be robust by handling the critical edge case of an empty input arr...

The `findMax` function initializes a variable `maxVal` with the first element of the input array. It then iterates through the rest of the array, comparing each element with `maxVal`. If an element is found to be greater than `maxVal`, `maxVal` is updated. The loop terminates when all elements have been checked. The time complexity is O(n), where n is the number of elements in the array, because each element is visited once. The space complexity is O(1) as only a few variables are used regardless of the array size. The function correctly handles edge cases like an empty array (by reverting) and an array with a single element. The invariant is that `maxVal` always holds the maximum value encountered up to the current iteration.

function findMax(numbers): if numbers is empty: revert "Empty array" maxVal = numbers[0] for i from 1 to length(numbers) - 1: if numbers[i] > maxVal: maxVal = numbers[i] return maxVal

This Solidity contract `MathUtils` provides a `factorialRecursive` function to compute the factorial of a non-negative integer using recursion. The factorial of a non-negative integer `n`, denoted by `n!`, is the product...

The `factorialRecursive` function calculates `n!` by first checking the base case: if `n` is 0, it returns 1. Otherwise, it recursively calls itself with `n-1` to get `(n-1)!`. Before performing the multiplication `n * (n-1)!`, it checks for potential `uint256` overflow. If `n` is greater than `type(uint256).max / (n-1)!`, it reverts. The time complexity of this recursive implementation is O(n) because each call to `factorialRecursive` makes one recursive call, leading to `n` calls. However, due to the overhead of function calls and the repeated calculation of subproblems (e.g., `factorialRecursive(3)` is calculated multiple times when computing `factorialRecursive(5)`), it's less efficient than an iterative approach. The space complexity is O(n) due to the call stack depth. The invariant is that `factorialRecursive(k)` correctly computes `k!` for all `k < n` when `factorialRecursive(n)` is called.

function factorialRecursive(n): if n is 0: return 1 else: prevFactorial = factorialRecursive(n - 1) if n > MAX_UINT256 / prevFactorial: revert "Overflow" return n * prevFactorial

This Solidity contract `SimpleMath` contains a basic function `add` that takes two unsigned 256-bit integers (`uint256`) and returns their sum. This is a fundamental operation in smart contract development, often used as...

The `add` function performs a straightforward addition of two `uint256` values. It takes `a` and `b` as input and returns `a + b`. The time complexity is O(1) as it involves a single arithmetic operation. The space complexity is also O(1). This function relies on Solidity's built-in arithmetic operations. It does not include explicit overflow checks, meaning it will behave according to Solidity's default overflow behavior (which is to wrap around for `uint` types in older versions, or revert in `^0.8.0` and above by default). The primary goal is to practice basic function definition and return statements.

function add(a, b): return a + b

This Solidity contract `SearchAlgorithms` implements a `binarySearch` function, a highly efficient algorithm for finding a specific value within a sorted array. It works by repeatedly dividing the search interval in half...

The `binarySearch` function operates on a sorted array. It maintains two pointers, `low` and `high`, defining the current search range. In each iteration, it calculates the middle index `mid` using `low + (high - low) / 2` to prevent potential overflow. It then compares the element at `mid` with the `target`. If they match, the index `mid` is returned. If `sortedArray[mid]` is less than `target`, the search continues in the right half (`low = mid + 1`). Otherwise, the search continues in the left half (`high = mid`). The loop terminates when `low` is no longer less than `high`, indicating the target was not found. The time complexity is O(log n) because the search space is halved in each step. The space complexity is O(1). Edge cases include an empty array (handled by `high` being 0 initially, loop doesn't run, returns sentinel) and the target not being present. The invariant is that the target, if it exists, is always within the `[low, high)` range.

function binarySearch(sortedArray, target): low = 0 high = length(sortedArray) while low < high: mid = low + (high - low) / 2 if sortedArray[mid] == target: return mid else if sortedArray[mid] < target: low = mid + 1 els...