website·Indexed 32 days ago
https://prashantbarahi.com.np/A collection of algorithm implementations and problem solutions covering topics such as linked lists, stacks, queues, and sorting. Includes code examples in Kotlin, Python, and Java for problems like HeapSort, Palindrome Permutation, and various LeetCode challenges.
/knowledge-graph path is implemented using D3.js. The UI is rendered through DOM manipulations, SCSS, and Docusaurus's Infima framework.--model flag or enter an interactive session to ask follow-up questions about the content using the --ask flag.# Override the model for a single run
summarizer --model claude-opus-4-8 https://example.com/article
# Ask follow-up questions about the summary
summarizer https://example.com/article --askThe RandomizedSet class provides a data structure that supports inserting, removing, and retrieving a random element, all with an average time complexity of O(1).
Supported operations:
insert(val): Adds an integer to the set. Returns true if the element was not already present, false otherwise.remove(val): Removes an integer from the set. Returns true if the element was present, false otherwise.getRandom(): Returns a random element currently stored in the set.--model flag to override the default LLM for a specific run. Use the --ask flag to enter an interactive mode where you can ask follow-up questions about the summarized content.# Override the model for a specific request
summarizer --model claude-opus-4-8 https://example.com/article
# Summarize and enter interactive Q&A mode
summarizer https://example.com/article --askNode class is a fundamental building block for linked list data structures. It stores a value (data) and a reference to the next node in the sequence (next), which defaults to None. It includes string representation methods for easier debugging and printing.class Node:
def __init__(self, data):
self.data = data
self.next = None
def __str__(self):
return f"Node({self.data}, {self.next})"
def __repr__(self):
return str(self)To find the first common ancestor of two nodes in a tree where nodes maintain a reference to their parent, follow these steps:
package graphs;
import graphs.commons.BidirectionalTree;
class FirstCommonAncestor {
// Returns the depth of a node relative to the root
static Integer depth(BidirectionalTree tree) {
BidirectionalTree current = tree;
int count = 0;
while (current.parent != null) {
current = current.parent;
count++;
}
return count;
}
// Moves a node up the tree by a specified number of levels
static BidirectionalTree goUpBy(BidirectionalTree tree, int times) {
BidirectionalTree current = tree;
for (int i = 1; i <= Math.abs(times); i++) {
current = current.parent;
}
return current;
}
// Finds the first common ancestor of two nodes at the same depth
static BidirectionalTree commonAncestor(BidirectionalTree t1, BidirectionalTree t2) {
BidirectionalTree current1 = t1;
BidirectionalTree current2 = t2;
while (current1 != current2) {
current1 = current1.parent;
current2 = current2.parent;
}
return current1;
}
public static void main(final String[] args) {
// Example setup: BidirectionalTree(parent, data)
final BidirectionalTree tree = new BidirectionalTree(null, 10);
tree.left = new BidirectionalTree(tree, 20);
tree.right = new BidirectionalTree(tree, 80);
// ... tree construction ...
BidirectionalTree p = // node 1
BidirectionalTree q = // node 2
int delta = depth(p) - depth(q);
BidirectionalTree t1 = p;
BidirectionalTree t2 = q;
if (delta < 0) {
t2 = goUpBy(q, delta);
} else if (delta > 0) {
t1 = goUpBy(p, delta);
}
BidirectionalTree lca = commonAncestor(t1, t2);
System.out.println("Common Ancestor: " + lca.data);
}
}private fun LinkedListNode.getMiddleNode(): LinkedListNode {
var slowPointer: LinkedListNode = this
var fastPointer: LinkedListNode? = this
while (fastPointer?.next != null) {
slowPointer = slowPointer.next!!
fastPointer = fastPointer.next?.next
}
return slowPointer
}