Parihsz

export type SnapshotData<T> = {
	t: number,
	value: T,
}

export type CircularSnapshot<T> = {
	cache: { SnapshotData<T> },
	pivotIndex: number?, -- to make math easier, this is stored as 0 indexed, then 1 is added whenever it's used for indexing
	lerp: (T, T, number) -> T,

Parihsz

Summary

This RFC proposes the adoption of Backpack instances in place of traditional Folder instances for container organization.

Motivation

As a roblox game scales, developers continually seek new paradigms for organizing code, modularity, and runtime clarity. Traditional Folder usage, while functional, lacks semantic weight and provides no affordance beyond being a generic instance container. Backpacks are specialized containers with actual implicit utility. Although they are deisgned to hold tools, it can be recontextualized as a general purpose container for scripts, services and components. Notably:

• better developer ergonomics: a "Backpack" intuitively implies it "holds useful things", making it easier to conceptualize its contents as essential runtime modules.
• visual distinction: differentiating functional containers from traditional folders make critical components much easier to prof

Parihsz

Array:

• Fixed size
• Contiguous memory block
• Constant time access

Efficiency

• Modifying: O(1)
• Find (using iterator or index): O(1)

Can't insert in middle since the size is fixed.

Parihsz

Some Standard Approaches for Competitive Programming

• Brute force
  • Will earn partial marks, as it is usually too slow
  • Do it if
    • The solution space is easy to define (easy to code)
    • You are out of time
    • You might as well do it to earn some quick marks before thinking of a more optimal solution
  • In a brute force solution, there is one level of nested loop for each solution space dimension
  • You may also want to check out itertools

Parihsz

to be done

Parihsz

# question can be easily framed into graph pathfinding
# parse inputs
def generated_nexts(current, rules): # has to return rule_id, index and result
    for rule_index in range(len(rules)):
        a, b = rules[rule_index]
        a_length = len(a)
        for i in range(len(current) - a_length + 1): # we add one because a is the from
            if a == current[i:i + a_length]: # this is a match, we found a position to apply the rule
                result = current[:i] + b + current[i + a_length:]
                yield rule_index + 1, i + 1, result # very special, but ugly syntax (sorry D:)

Parihsz

Adjacency matrix implementations

2d list implementation

class adjacency_matrix_1:
    def __init__(self, N):
        self.matrix = [[False for _ in range(N)] * N]
    def connect(self, a, b, bidirectional=True):
        self.matrix[a][b] = True
 if bidirectional:

Parihsz

General forms of graph traversal

Unweighted edges

• 1, path existence
• 2, shortest path
• 3, number of paths
• 4, shortest path to every other location

Weighted edges

• 5, shortest path (a little different)

Parihsz

function find_pivot_positions(matrix)
	local m, n = #matrix, #matrix[1]
	local pivot_positions = {}
	for i = 1, m do
		for j = 1, n do
			if matrix[i][j] == 1 then
				table.insert(pivot_positions, {i, j})
				break
			end
		end

Parihsz

type R6Character = Model & {
    BodyColors: BodyColors,
    
    Humanoid: Humanoid & {
        HumanoidDescription: HumanoidDescription,
        Status: Status,
        Animator: Animator
    },
    
    Animate: LocalScript & {