This C# code implements Manacher's algorithm to efficiently find the longest palindromic substring within a given string. It preprocesses the string to handle both odd and even length palindromes uniformly. The algorithm...

Manacher's algorithm solves the longest palindromic substring problem in O(n) time. It preprocesses the input string `s` into `processedS` by inserting a special character (e.g., '#') between every character and at the ends. This transformation ensures that all palindromes, regardless of their original length (odd or even), become odd-length palindromes in `processedS`, simplifying the logic. An array `p` stores the radius of the palindrome centered at each index `i` in `processedS`. The algorithm maintains `center` and `right` pointers, representing the center and rightmost boundary of the palindrome that extends furthest to the right. When processing index `i`, it uses the symmetry property: if `i` is within the current `right` boundary, its initial palindrome radius `p[i]` can be at least `min(right - i, p[mirror])`, where `mirror` is the index symmetric to `i` around `center`. Then, it attempts to expand the palindrome centered at `i` character by character. If `i + p[i]` extends beyond `right`, `center` and `right` are updated. The maximum `p[i]` found corresponds to the longest palindrome. The time complexity is O(n) because each character is compared at most a constant number of times during the expansion phase, and the `center`/`right` updates ensure forward progress. The space complexity is O(n) for storing `processedS` and the `p` array.

function LongestPalindrome(s): if s is empty or null, return "" processedS = PreprocessString(s) // Add '#' between chars and at ends n = length of processedS p = array of size n, initialized to 0 // p[i] = radius of pal...

This C# code provides an implementation of Breadth-First Search (BFS) to find the shortest path between two nodes in an unweighted graph. The graph is represented using an adjacency list. BFS systematically explores the...

Breadth-First Search (BFS) is an algorithm for traversing or searching tree or graph data structures. It starts at the graph's root (or an arbitrary node) and explores all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level. For finding the shortest path in an unweighted graph, BFS is optimal because it explores nodes in increasing order of their distance from the source. The algorithm uses a queue to keep track of nodes to visit and a `visited` array to prevent cycles and redundant processing. A `predecessor` array is maintained to store the node from which each node was first reached, enabling path reconstruction. The time complexity of BFS is O(V + E), where V is the number of vertices and E is the number of edges, because each vertex and each edge is visited at most once. The space complexity is O(V) for the queue and the `visited` and `predecessor` arrays. Edge cases include disconnected graphs (where no path exists, returning null), a start node equal to the end node (returning a path with just that node), and invalid node indices (handled by exceptions or null returns). The correctness relies on the layered exploration property of BFS: the first time `endNode` is dequeued, it must be via a shortest path.

function FindShortestPathBFS(graph, startNode, endNode): numVertices = graph.GetVertexCount() if startNode or endNode are out of bounds, return null if startNode == endNode, return [startNode] queue = new Queue() visited...

This C# code provides an `ObjectPoolManager` for Unity, designed to efficiently manage frequently used game objects like projectiles or enemies. It utilizes an `ObjectPool` class to pre-allocate and reuse instances, redu...

The `ObjectPoolManager` acts as a central hub, maintaining a dictionary of `ObjectPool` instances, keyed by their prefabs. Each `ObjectPool` manages a collection of `PooledObject` instances, using a `Stack` for inactive objects and a `List` for active ones. When `GetObject` is called, it either retrieves an inactive object from the stack or creates a new one if the pool is empty. `ReturnObject` deactivates the object and pushes it back onto the inactive stack. The `ClearPool` method ensures all managed objects are destroyed on cleanup. Time complexity for `GetObject` and `ReturnObject` is O(1) on average, assuming stack/list operations are amortized O(1). Space complexity is O(N*S) where N is the number of unique prefabs and S is the initial pool size, plus any dynamically created objects. Edge cases include empty pools, returning null objects, returning objects not managed by the pool, and ensuring proper cleanup via `OnDestroy`.

Class PooledObject (MonoBehaviour): Pool reference Method ReturnToPool(): If Pool is not null, call Pool.ReturnObject(this) Else, destroy GameObject Class ObjectPool: Prefab ActiveObjects list InactiveObjects stack Paren...

This C# code implements the A* pathfinding algorithm, a widely used technique for finding the shortest path between two points in a grid or graph. It utilizes a heuristic function to estimate the cost to the goal, guidin...

The A* algorithm finds the shortest path by exploring nodes based on a cost function `F = G + H`, where `G` is the cost from the start node and `H` is the heuristic estimate to the end node. The `PathfindingGrid` represents the navigable space, and `PathNode` stores information about each grid cell. The `AStarPathfinder` uses an `openSet` (nodes to visit, prioritized by `F_Cost`) and a `closedSet` (nodes already visited). It iteratively selects the node with the lowest `F_Cost` from the `openSet`, adds it to the `closedSet`, and examines its neighbors. If a neighbor can be reached with a lower `G_Cost` than previously known, its parent and costs are updated, and it's added to the `openSet`. The path is reconstructed by backtracking from the goal node using parent pointers. Time complexity is typically O(E log V) or O(E + V log V) with a priority queue, where V is the number of nodes and E is the number of edges. Space complexity is O(V) for storing the open and closed sets. Edge cases include invalid start/end nodes, unreachable destinations, and obstacles, all handled by checking node walkability and the loop termination condition.

Class PathNode: GridPosition IsWalkable G_Cost (float, default infinity) H_Cost (float) F_Cost (calculated: G_Cost + H_Cost) ParentNode Class PathfindingGrid: Grid (2D array of PathNode) Width, Height Constructor(width,...

This C# code implements an advanced state machine with explicit guard conditions for transitions. It allows for controlled movement between defined states, ensuring that transitions only occur when specific criteria are...

The `AdvancedStateMachine` class manages a finite set of states and defines valid transitions between them using guard conditions. The `CanTransition` method acts as the gatekeeper, evaluating the current state and the desired next state against predefined rules. If `CanTransition` returns true, the `TransitionTo` method updates the `currentState` and optionally invokes a callback. The complexity of `CanTransition` is O(N) where N is the number of states, as it might involve a switch statement. However, in practice, with a fixed number of states, it's effectively O(1). The space complexity is O(1) as it only stores the current state and a callback. Edge cases include attempting to transition to the same state, transitioning from a terminal state (like 'Stopped'), or attempting an undefined transition, all of which are handled by `CanTransition` returning false.

Class AdvancedStateMachine: Enum State { Idle, Running, Paused, Stopped } CurrentState OnStateChangedCallback Constructor(initialState, callback): Set CurrentState to initialState Set OnStateChangedCallback to callback M...

This C# code implements a `SequenceNode` for AI Behavior Trees, a hierarchical structure used to define complex AI decision-making. The `SequenceNode` executes its child nodes sequentially, succeeding only if all childre...

The `SequenceNode`'s `Tick` method iterates through its children. It maintains `currentChildIndex` to resume execution from the last point if a child returned `Running`. If a child returns `Failure`, the `SequenceNode` immediately returns `Failure` and resets `currentChildIndex`. If a child returns `Running`, the `SequenceNode` stores the current child's index and returns `Running`. Only if a child returns `Success` does the `SequenceNode` proceed to the next child. If all children are successfully executed, the `SequenceNode` returns `Success` and resets `currentChildIndex`. The time complexity of a `Tick` operation for a `SequenceNode` is O(N) in the worst case, where N is the number of children, as it might need to tick all of them if they all succeed. In cases where a child fails or returns running early, it can be O(1) or O(k) where k is the index of the failing/running child. Space complexity is O(N) to store the children. Edge cases include an empty sequence (which succeeds vacuously) and resuming execution from a `Running` child.

Enum BehaviorTreeStatus { Success, Failure, Running } Abstract Class BehaviorTreeNode: Abstract Method Tick(agent): Returns BehaviorTreeStatus Class SequenceNode (inherits BehaviorTreeNode): Children list (BehaviorTreeNo...

This C# code demonstrates a simplified Entity Component System (ECS) designed for physics simulation within a Unity context. It defines core components like `TransformComponent` and `PhysicsComponent`, and a `PhysicsSyst...

The `PhysicsSystem` iterates through all registered entities, checking for the presence of `TransformComponent` and `PhysicsComponent`. For non-kinematic entities, it applies gravity, updates positions based on velocity, and then performs collision detection. Collision detection involves checking the distance between entity centers against the sum of their radii. If a collision occurs, `ResolveCollision` is called. This method applies a basic impulse-based response for elastic collisions and a simple separation to prevent objects from sticking. The time complexity for `UpdatePhysics` is O(E^2) in the worst case due to the nested loop for collision detection (where E is the number of entities), but can be optimized with spatial partitioning. Space complexity is O(E) to store entities and their components. Edge cases handled include null entities in the list, entities missing required components, and kinematic bodies which are not affected by physics forces.

Class GameObject: Components dictionary AddComponent(component) GetComponent<T>() HasComponent<T>() Class TransformComponent { Position, Rotation, Scale } Class PhysicsComponent { Velocity, Mass, IsKinematic, Radius } Cl...