All public logs

Combined display of all available logs of Wiki. You can narrow down the view by selecting a log type, the username (case-sensitive), or the affected page (also case-sensitive).

• 05:08, 30 May 2023 Admin talk contribs created page Category:String (Created blank page)
• 06:21, 28 May 2023 Admin talk contribs created page Category:Bipartite Graph Check (Created blank page)
• 06:21, 28 May 2023 Admin talk contribs created page Category:Depth First Search (Created blank page)
• 06:21, 28 May 2023 Admin talk contribs created page Category:Sets (Created blank page)
• 02:27, 27 May 2023 Admin talk contribs created page Category:Breadth First Search (Created blank page)
• 02:17, 27 May 2023 Admin talk contribs created page Category:Sliding Window (Created blank page)
• 02:17, 27 May 2023 Admin talk contribs created page Category:Dynamic Programming (Created blank page)
• 02:15, 27 May 2023 Admin talk contribs created page Category:Two Pointer (Created blank page)
• 02:15, 27 May 2023 Admin talk contribs created page Category:Greedy (Created blank page)
• 17:17, 13 May 2023 Admin talk contribs created page Category:Brute Force (Created blank page)
• 17:16, 13 May 2023 Admin talk contribs created page Category:Simulation (Created blank page)
• 05:48, 12 May 2023 Admin talk contribs created page Heap Sort (Created page with "Heap Sort is a comparison-based sorting algorithm that works by utilizing a binary heap data structure. It was introduced by J. W. J. Williams in 1964. Heap Sort has a time complexity of O(n log n) for both the average and worst-case scenarios, making it an efficient sorting algorithm for large datasets. Heap Sort is performed in-place, but it is not a stable sort, which means that the relative order of equal elements might not be preserved. == Algorithm == The Heap So...")
• 05:44, 12 May 2023 Admin talk contribs created page Quick Sort (Created page with "== Quick Sort == Quick Sort is an efficient sorting algorithm that works on the divide and conquer principle. It was developed by British computer scientist Tony Hoare in 1959 and published in 1961. The algorithm is well-suited for sorting large datasets, as it has an average-case time complexity of O(n log n), where n is the number of items being sorted. However, the worst-case time complexity is O(n^2), which occurs when the input array is already sorted or reverse so...")
• 05:42, 12 May 2023 Admin talk contribs created page Merge Sort (Created page with "Merge Sort is a comparison-based sorting algorithm that uses a divide-and-conquer approach to sort a list of elements. It is an efficient and stable sorting algorithm with a time complexity of O(n log n), making it suitable for large datasets. == Algorithm == The Merge Sort algorithm works as follows: If the list has only one element, it is already sorted, so return the list. Divide the list into two equal halves. Recursively sort each half using Merge Sor...")
• 05:38, 12 May 2023 Admin talk contribs created page Insertion Sort (Created page with "Insertion Sort is a simple comparison-based sorting algorithm that works by building a sorted sequence one element at a time. It is suitable for small datasets or when the input is partially sorted. However, its time complexity increases rapidly as the size of the dataset grows, making it inefficient for large datasets. == Algorithm == The Insertion Sort algorithm works as follows: Consider the first element of the list as sorted. Insert the second element in...")
• 05:36, 12 May 2023 Admin talk contribs created page Selection Sort (Created page with "Selection Sort is a simple comparison-based sorting algorithm that works by repeatedly finding the minimum (or maximum) element from the unsorted part of the list and moving it to the beginning (or end) of the sorted part. It is an elementary sorting algorithm that is not suitable for large datasets due to its high time complexity. == Algorithm == The Selection Sort algorithm works as follows: * Find the minimum (or maximum) element in the unsorted part of the list an...")
• 05:33, 12 May 2023 Admin talk contribs created page Bubble Sort (Created page with "Bubble Sort is a simple sorting algorithm that works by repeatedly swapping adjacent elements if they are in the wrong order. It is an elementary sorting algorithm that is not suitable for large datasets due to its high time complexity. The algorithm is named "Bubble Sort" because the smaller elements "bubble" to the beginning of the list, while the larger elements "sink" to the end. == Algorithm == The Bubble Sort algorithm works as follows: Start at the beginnin...")
• 05:26, 12 May 2023 Admin talk contribs created page Binary Search Trees (Created page with "A binary search tree (BST) is a binary tree data structure that maintains the property that the value of each node is greater than or equal to the values of all nodes in its left subtree and less than or equal to the values of all nodes in its right subtree. This property ensures that an inorder traversal of the tree will result in the sorted order of the elements. == Operations == The main operations on a binary search tree are insertion, deletion, and search. === In...")
• 05:21, 12 May 2023 Admin talk contribs created page Binary Trees (Created page with "A '''binary tree''' is a data structure in which each node has at most two children, which are referred to as the left child and the right child. Binary trees are used to implement various data structures, including binary search trees, heaps, and syntax trees. == Structure == A binary tree is defined recursively as a structure consisting of a node, which contains a value and two references to its left and right children. The children themselves are also binary trees. A...")
• 05:15, 12 May 2023 Admin talk contribs created page Trees (Created page with "== Introduction == A '''tree''' is a hierarchical data structure that consists of nodes connected by edges. It is a non-linear data structure with a unique root node, and each node in the tree can have zero or more child nodes. The tree data structure is commonly used for representing hierarchies and searching efficiently in databases, file systems, and more. == Terminology == Here are some common terms used in the context of trees: * '''Node''': A basic unit in a tree...")
• 05:10, 12 May 2023 Admin talk contribs created page Queues (Created page with "== Introduction == A '''queue''' is a linear data structure that follows the First In First Out (FIFO) principle, meaning the first element added to the queue is the first one to be removed. Queues can be implemented using arrays, linked lists, or circular buffers. == Basic Operations == The main operations associated with a queue are: '''Enqueue''': Adding an element to the rear of the queue. '''Dequeue''': Removing the front element from the queue. '''Fro...")
• 05:08, 12 May 2023 Admin talk contribs created page Stacks (Created page with "== Introduction == A '''stack''' is a linear data structure that follows the Last In First Out (LIFO) principle, meaning the last element added to the stack is the first one to be removed. Stacks can be implemented using arrays or linked lists. == Basic Operations == The main operations associated with a stack are: * '''Push''': Adding an element to the top of the stack. * '''Pop''': Removing the top element from the stack. * '''Top''': Accessing the top element of the...")
• 05:05, 12 May 2023 Admin talk contribs created page Linked Lists (Created page with "== Introduction == A '''linked list''' is a linear data structure, where elements are stored in nodes, and each node points to the next node in the list. It is a dynamic data structure, meaning its size can change during the execution of a program. Linked lists are useful when efficient insertion and deletion of elements are required. == Types of Linked Lists == There are several types of linked lists: * '''Singly Linked List''': Each node has a pointer to the next nod...")
• 05:01, 12 May 2023 Admin talk contribs created page Arrays (Created page with "'''Array''' is a fundamental data structure in computer programming that stores a fixed-size, ordered sequence of elements of the same type. Arrays provide a simple and efficient way to store, access, and manipulate data. == Characteristics == - '''Fixed size:''' Arrays have a fixed size, determined at the time of their creation. The size cannot be changed after creation. - '''Homogeneous elements:''' All elements in an array must be of the same type. - '''Contiguous m...")
• 04:56, 12 May 2023 Admin talk contribs created page Heaps (Created page with " '''Heap''' is a specialized tree-based data structure that satisfies the heap property, which is a partial ordering of elements in a tree. It is used to efficiently access the highest- or lowest-ranked elements within a dataset. Heaps are commonly implemented as binary trees and can be visualized as almost complete trees with nodes filled from top to bottom and left to right. == Types of Heaps == There are two main types of heaps: - '''Max-heap:''' In a max-heap, the...")
• 04:53, 12 May 2023 Admin talk contribs created page Hash Tables (Created page with "''Hash table''' is a data structure that allows for efficient insertion, deletion, and retrieval of items based on their keys. It uses a hash function to map each key to an index in an array, where the corresponding value is stored. Hash tables offer average-case constant-time complexity for operations such as insertions, deletions, and lookups. == Components of a Hash Table == === Hash Function === A hash function takes a key as input and returns an integer, which cor...")
• 04:46, 12 May 2023 Admin talk contribs created page Category:Yearly 2014 2015 (Created blank page)
• 04:44, 12 May 2023 Admin talk contribs created page Backtracking (Created page with "'''Backtracking''' is an algorithmic technique for solving problems that incrementally builds candidates to the solution(s) and abandons a candidate ("backtracks") as soon as it determines that the candidate cannot be extended to a valid solution. The concept of backtracking is based on the idea of exploring all possible solutions until a valid solution is found. Backtracking is commonly used in problems involving decision trees or state space trees, such as searching t...")
• 23:25, 6 May 2023 Admin talk contribs created page Category:Union Find (Created blank page)
• 23:25, 6 May 2023 Admin talk contribs created page Category:Flood Fill (Created blank page)
• 23:22, 6 May 2023 Admin talk contribs created page Category:Data Structure (Created blank page)
• 22:50, 6 May 2023 Admin talk contribs created page Union Find (Created page with "The disjoint-set data structure, also known as the union-find data structure, is used to keep track of a collection of non-overlapping sets or elements that are partitioned into disjoint subsets. The primary operations associated with this data structure are: * Find: Determine which subset an element belongs to. This is typically used to check if two elements are in the same subset. * Union: Join two subsets together, combining them into a single subset. The disjoint-...")
• 22:50, 6 May 2023 Admin talk contribs created page Disjoint Set (Redirected page to Union Find) Tag: New redirect
• 22:32, 6 May 2023 Admin talk contribs created page Flood Fill (Created page with "Flood fill is a simple algorithm used to explore and fill connected regions in a 2D grid or matrix. It is often used in image processing to fill areas with a specified color, but it can also be used in solving graph problems such as finding connected components or traversing a maze. The algorithm starts from a given cell (row, col) and recursively explores its neighbors (usually up, down, left, and right) to fill the region with a new value or to mark it as visited. The...")
• 05:08, 6 May 2023 Admin talk contribs created page Category:Breadth-First Search (Created blank page)
• 05:08, 6 May 2023 Admin talk contribs created page Category:Search (Created blank page)
• 05:07, 6 May 2023 Admin talk contribs created page Category:Depth-First Search (Created blank page)
• 05:07, 6 May 2023 Admin talk contribs created page Category:Graph (Created blank page)
• 05:05, 6 May 2023 Admin talk contribs created page Category:Algorithms (Created blank page)
• 05:04, 6 May 2023 Admin talk contribs created page Category:Binary Search (Created blank page)
• 04:59, 6 May 2023 Admin talk contribs created page Binary Search (Created page with "== Binary Search == Binary Search is an efficient algorithm for finding a specific element (target) in a sorted array or list. The algorithm works by repeatedly dividing the search interval in half. At each step, the algorithm compares the middle element of the interval with the target value. If the middle element is equal to the target, the search is successful. If the target is less than the middle element, the search continues in the left half of the interval. If the...")
• 04:00, 6 May 2023 Admin talk contribs created page Depth-First Search (Created page with "== Depth-First Search == Depth-First Search (DFS) is a graph traversal algorithm that explores all the vertices of a graph by visiting nodes as deep as possible before backtracking. DFS can be implemented using recursion or an explicit stack data structure. === Algorithm === Start at the source node and mark it as visited. For each adjacent node of the source node, if it is not visited, perform a recursive DFS from the adjacent node. === Time Complexity ===...")
• 03:51, 6 May 2023 Admin talk contribs created page Breadth-First Search (Created page with "= Breadth-First Search (BFS) = Breadth-First Search (BFS) is an algorithm for searching a tree or graph data structure for a node that meets a set of criteria. It starts at the tree’s root or graph and searches/visits all nodes at the current depth level before moving on to the nodes at the next depth level. <ref name=“geeksforgeeks”>https://www.geeksforgeeks.org/breadth-first-search-or-bfs-for-a-graph/</ref> == How it works == BFS uses a queue data structure to...")
• 05:39, 5 May 2023 Admin talk contribs created page Category:Yearly 2013 2014 (Created blank page)
• 05:38, 5 May 2023 Admin talk contribs created page 2014 Jan Silver Problem 2 Cross Country Skiing (Created page with "== Problem == == Solution == == Code == Category:Yearly_2013_2014 Category:Silver")
• 02:36, 5 May 2023 Admin talk contribs created page Trie (Created page with "== Trie == thumb|right|350px|A simple trie for keys "A", "to", "tea", "ted", "ten", "i", "in", and "inn". A '''trie''' (pronounced "try"), also known as a '''prefix tree''' or '''digital tree''', is a tree-like data structure used to store an associative array where the keys are usually strings. Each node in the trie represents a single character in the key, and the root node represents an em...")
• 02:14, 5 May 2023 Admin talk contribs created page Path to Platinum (Created page with "== Topics == * Advanced Data Structures ** Range Minimum Query (RMQ) ** Sparse Table ** Heavy-Light Decomposition ** Treap ** Suffix Automaton ** K-Dimensional Tree * Advanced Algorithms ** Advanced Dynamic Programming *** Tree DP *** State Compression DP *** Matrix Exponentiation ** Graph Algorithms *** Minimum Arborescence *** Biconnected Components *** Aho-Corasick Algorithm *** 2-SAT *** Maximal In...")
• 02:11, 5 May 2023 Admin talk contribs created page Path to Gold (Created page with "== Topics == * Advanced Data Structures ** Binary Indexed Trees (Fenwick Trees) ** Segment Trees ** Persistent Data Structures ** Trie ** Suffix Array ** Suffix Tree * Advanced Algorithms ** Dynamic Programming *** Convex Hull Optimization *** Digit DP *** Knapsack Problem ** Graph Algorithms *** Shortest Paths **** Dijkstra's Algorithm **** Bellman-Ford Algorithm **** Floyd-Warshall Algorithm *** Mini...")
• 02:08, 5 May 2023 Admin talk contribs created page Path to Silver (Created page with "== Topics == * Variables and Data Types * Input and Output * Control Structures (if, else, switch) * Loops (for, while, do-while) * Functions * Arrays * Strings * Basic Sorting Algorithms (Bubble Sort, Selection Sort, Insertion Sort) * Basic Searching Algorithms (Linear Search, Binary Search) * Basic Data Structures (Stacks, Queues) * Basic Graph Algorithms (Breadth-First Search, Depth-First Search) == Bronze to Silver Practice Questions == * Question 1: [https://www.us...")
• 19:10, 4 May 2023 Admin talk contribs created page Algorithms (Created page with "== Algorithms == === Sorting === * Bubble Sort * Selection Sort * Insertion Sort * Merge Sort * Quick Sort * Heap Sort === Searching === * Linear Search * Binary Search === Graph Algorithms === * Breadth-First Search * Depth-First Search * Dijkstra's Algorithm * Floyd-Warshall Algorithm * Kruskal's Algorithm * Prim's Algorithm * Topological Sort * Bellman-Ford Algorithm === Dynamic Programming...")