This function finds a peak element in an array where elements are not necessarily sorted but have the property that nums[i] != nums[i+1]. A peak element is defined as an element that is strictly greater than its neighbor...

The algorithm uses binary search to efficiently find a peak element. The key insight is that if an element `nums[mid]` is not a peak, then either its left neighbor or its right neighbor must be greater. If `nums[mid+1]` is greater, a peak must exist in the right half (including `mid+1`). If `nums[mid-1]` is greater (or `nums[mid+1]` is not greater), a peak must exist in the left half (including `mid`). This process halves the search space in each step, leading to a time complexity of O(log n). The space complexity is O(1) as it only uses a few variables. Edge cases like single-element arrays or peaks at the array boundaries are implicitly handled by the loop condition and the way `left` and `right` are updated. The invariant maintained is that a peak element is guaranteed to exist within the `[left, right]` range.

function FindPeakElement(nums): left = 0 right = length(nums) - 1 while left < right: mid = left + (right - left) / 2 if nums[mid] < nums[mid + 1]: left = mid + 1 else: right = mid return left

This C++ code defines a Doubly Linked List data structure with essential operations. A doubly linked list allows traversal in both forward and backward directions. It's commonly used in scenarios requiring efficient inse...

The Doubly Linked List implementation involves a `Node` struct with `data`, `next`, and `prev` pointers, and a `DoublyLinkedList` class managing `head`, `tail`, and `count`. Insertion at the beginning and end involves creating a new node and carefully updating pointers of the new node and the existing head/tail. Deletion by value requires traversing the list, finding the node, and then reconnecting the `prev` and `next` pointers of its neighbors, with special handling for deleting the head or tail. Searching is a simple linear traversal. The destructor iterates through the list, deleting each node to prevent memory leaks. Time complexity for insertion, deletion, and search is O(n) in the worst case (traversing the list), but O(1) for insertion at head/tail if the pointers are maintained. Space complexity is O(n) to store n elements. Edge cases like an empty list, deleting the only node, or deleting the head/tail are handled explicitly to ensure pointer integrity.

class Node: data next_pointer prev_pointer class DoublyLinkedList: head_pointer tail_pointer size_count function InsertAtBeginning(value): create newNode with value if list is empty: set head = newNode set tail = newNode...

This C++ code provides functions for serializing and deserializing a custom struct (`FReplicatedData`) into and from a byte array. This is a fundamental technique for network communication, particularly for sending compl...

The `SerializeReplicatedData` function takes an `FReplicatedData` struct and appends its members, in a specific order, to a `TArray<uint8>` buffer. For primitive types like `int32` and `float`, it directly appends their byte representations. For strings, it first serializes their length and then their character data. Arrays are serialized by first writing the number of elements, followed by each element's serialized form. The `DeserializeReplicatedData` function reverses this process. It reads data from the buffer sequentially, using an `Offset` to track the current position. It first reads the size of each element (like string length or array size) and then reads the actual data. Crucially, both functions must use the exact same order and data types for serialization and deserialization to maintain data integrity. Error checking is performed at each step to ensure the buffer is not read past its bounds and that lengths are valid. The time complexity for both serialization and deserialization is O(S), where S is the total size of the data being serialized/deserialized, as each byte is processed. Space complexity is O(S) for storing the serialized buffer.

Struct ReplicatedData: IntValue (int) FloatValue (float) StringValue (string) IntArray (array of int) StringArray (array of string) NestedVector (Vector) Function SerializeReplicatedData(Buffer, Data): Append Data.IntVal...

This C++ code implements a cooldown manager for Unreal Engine's Gameplay Ability System. It allows developers to track and manage cooldowns for various player abilities. The system uses a map to store when each ability's...

The `UAbilityCooldownManager` class uses a `TMap` to store the expiration time for each ability's cooldown. The keys are `FGameplayTag`s representing abilities, and the values are `float`s representing the game time at which the cooldown ends. The `ApplyCooldown` function adds or updates an entry in the map, calculating the end time based on the current game time and cooldown duration. `IsAbilityOnCooldown` checks if the current game time is before the stored end time for a given ability. `GetRemainingCooldownTime` calculates the difference between the end time and current time, ensuring it's not negative. `TickCooldowns` iterates through the map and removes entries where the cooldown has expired. Edge cases like zero or negative cooldown durations are handled by immediately removing the cooldown. Floating-point precision is managed by comparing current time against the end time. The time complexity for `ApplyCooldown`, `IsAbilityOnCooldown`, `RemoveCooldown`, and `GetRemainingCooldownTime` is typically O(1) on average due to the hash-based nature of `TMap`. `TickCooldowns` has a time complexity of O(N), where N is the number of active cooldowns, as it may iterate through all entries. Space complexity is O(M), where M is the number of abilities that can have a cooldown simultaneously.

Class AbilityCooldownManager: Map CooldownEndTimes (Tag -> EndTime) Function ApplyCooldown(AbilityTag, Duration, CurrentTime): If Duration <= 0: RemoveCooldown(AbilityTag) Return EndTime = CurrentTime + Duration Add/Upda...

This C++ code provides a basic function `CanActivateAbilityBasic` to determine if a character can activate a gameplay ability. It checks if the character's current health and mana (represented as percentages) meet the mi...

The `CanActivateAbilityBasic` function takes an `UAbilitySystemComponent` pointer and the required health and mana percentages as input. It first validates that the `ASC` pointer is valid. Then, it calculates the current health percentage by dividing `ASC->GetHealth()` by `ASC->GetMaxHealth()`. If this current percentage is less than the `RequiredHealthPercent`, the function immediately returns `false`. If the health condition is met, it proceeds to calculate the current mana percentage using `ASC->GetMana()` and `ASC->GetMaxMana()`. If this is less than `RequiredManaPercent`, it returns `false`. If both health and mana conditions are satisfied, the function returns `true`, indicating that the ability can be activated. The time complexity is O(1) because it performs a fixed number of arithmetic operations and comparisons, regardless of the character's state. The space complexity is also O(1) as it only uses a few local variables.

Function CanActivateAbilityBasic(ASC, RequiredHealthPercent, RequiredManaPercent): If ASC is null: Return false CurrentHealthPercent = ASC.GetHealth() / ASC.GetMaxHealth() If CurrentHealthPercent < RequiredHealthPercent:...

This C++ code implements an `UObjectPoolManager` for Unreal Engine, designed to efficiently manage a pool of reusable actors. Instead of constantly spawning and destroying actors (which can be performance-intensive), thi...

The `UObjectPoolManager` utilizes two `TArray`s: `AvailableActors` for actors ready to be reused, and `ActiveActors` for actors currently in use. `InitializePool` pre-spawns a number of actors up to `InitialPoolSize` and adds them to `AvailableActors`, hiding and deactivating them. `GetPooledActor` first checks `AvailableActors`. If empty, it checks if `MaxPoolSize` is reached; if not, it spawns a new actor. The retrieved actor is then moved to `ActiveActors`, its transform is set, and it's made visible and enabled. `ReturnPooledActor` removes the actor from `ActiveActors`, adds it to `AvailableActors`, resets its state via `ResetActorState`, and hides/disables it. `ResetActorState` is a crucial helper that must be customized based on the pooled actor's type to ensure it's in a clean state for reuse. `ClearPool` destroys all actors managed by the pool. The time complexity for `GetPooledActor` is O(1) on average if actors are available in the pool or if spawning is not limited by `MaxPoolSize`. If the pool is exhausted and `MaxPoolSize` is reached, it returns `nullptr` in O(1). `ReturnPooledActor` is O(1) on average due to `TArray::Remove` and `TArray::Add`. `InitializePool` is O(I) where I is `InitialPoolSize`, and `ClearPool` is O(N) where N is the total number of actors in the pool. Space complexity is O(M) where M is `MaxPoolSize`.

Class ObjectPoolManager: PooledActorClass (Class) MaxPoolSize (int) InitialPoolSize (int) AvailableActors (Array of Actors) ActiveActors (Array of Actors) OwningWorld (World) Function InitializePool(World): Set OwningWor...

This C++ code defines a simplified AI Behavior Tree structure and a function to find the highest priority executable branch. It simulates how an AI might decide which action to take next by traversing a tree of condition...

The `FindHighestPriorityBranch` function recursively traverses a simplified Behavior Tree. It starts at the `RootNode`. If the node has a condition and it fails, it returns `nullptr`. For leaf nodes (Tasks), it returns the node if its condition is met or if it has no condition. For composite nodes, it behaves as follows: a Selector node iterates through its children and returns the first one for which `FindHighestPriorityBranch` returns a non-null result. A Sequence node iterates through its children, and if all children can potentially execute (i.e., `FindHighestPriorityBranch` returns a non-null result for each), it returns the last successfully evaluated child. The time complexity is proportional to the number of nodes visited in the worst case, which can be O(N) where N is the total number of nodes in the tree. In a balanced tree, it might be closer to O(log N) if conditions frequently prune branches. Space complexity is O(H) due to the recursion depth, where H is the height of the Behavior Tree. Edge cases include an empty tree (`RootNode` is null), nodes with no conditions, and composite nodes with no children.

Function FindHighestPriorityBranch(Node): If Node is null: Return null If Node has a Condition and Condition is false: Return null If Node is a Task: If Node has a Condition and Condition is true: Return Node Else if Nod...

This C++ code defines a `UHealthComponent` for Unreal Engine actors, managing their health and defense. The core functionality is the `TakeDamage` function, which calculates the final damage dealt to an actor after apply...

The `UHealthComponent` class manages an actor's health and defense. The `TakeDamage` function is the primary logic for calculating damage. It first checks if the `BaseDamage` is valid (greater than 0). It then determines the `DamageMitigation` based on the `DamageType` (case-insensitively compared to "physical" or "magical"), applying `Armor` or `MagicResistance` respectively. The `FinalDamage` is calculated by subtracting mitigation from base damage, with a minimum of 1 damage to prevent trivial negation. This `FinalDamage` is then subtracted from `CurrentHealth`, ensuring health does not drop below 0. The `Heal` function increases `CurrentHealth` up to `MaxHealth`. `IsDead` simply checks if `CurrentHealth` is 0 or less. The time complexity for `TakeDamage`, `Heal`, and `IsDead` is O(1) as they involve a fixed number of arithmetic operations and comparisons. Space complexity is O(1) as it only uses a few member variables.

Class HealthComponent: CurrentHealth, MaxHealth, Armor, MagicResistance Function TakeDamage(BaseDamage, DamageType): If BaseDamage <= 0: Return 0 Mitigation = 0 LowercaseDamageType = ToLowercase(DamageType) If LowercaseD...