Prithvi its-prithvi-raj

WSL2 settings

[wsl2]
firewall = true

[wsl2]

int a = 100;
int* ptr = &a;

// Value of a.
std::cout << "(Value of) a: " << a << "\n";

// Pointer to a OR value of a.

$$ O(1) < O(\log n) < O(n) < O(n \log n) < O(n^2) < O(n^3) < O(2^n) < O(n!) $$

Constant Time $$O(1)$$: The algorithm's execution time remains constant regardless of the input size. This is the most efficient time complexity. Example: accessing an element in an array by index.
Logarithmic Time $$O(\log n)$$: The algorithm's execution time increases logarithmically with the input size. This is often associated with algorithms that divide the input in half at each step, like binary search. Example: binary search in a sorted array.
Linear Time $$O(n)$$: The algorithm's execution time increases linearly with the input size. This is common for algorithms that need to process each element of the input once, like searching for a specific element in an unsorted array. Example: iterating through an array.
Linearithmic Time $$O(n \log n)$$: The algorithm's execution time grows slightly faster than linear time. This complexity is typically associated with efficient sorting algorithms like m

Picking the right architecture = Picking the right battles + Managing trade-offs

User cases (description of sequences of events that, taken together, lead to a system doing something useful)
- Who is going to use it?
- How are they going to use it?

	{
	// "cmake.pinnedCommands": [
	// "workbench.action.tasks.configureTaskRunner",
	// "workbench.action.tasks.runTask"
	// ],
	// "C_Cpp.intelliSenseEngine": "disabled",
	// "C_Cpp.formatting": "clangFormat",
	// "C_Cpp.autocompleteAddParentheses": true,
	// "C_Cpp.inlayHints.autoDeclarationTypes.enabled": true,
	// "C_Cpp.inlayHints.autoDeclarationTypes.showOnLeft": true,