Practice Code Typing – SkillsTyping

Choose your language:

ℹ️ Select 'Choose Exercise', or randomize 'Next Random Exercise' in selected language.

Choose Exercise:

Ready

Exercise Algorithm Area

Correct typos to continue.

1#include <stdio.h>
2#include <stdbool.h>
3
4// Helper function to swap two elements
5void swap(int* xp, int* yp) {
6int temp = *xp;
7*xp = *yp;
8*yp = temp;
9}
10
11// Bubble Sort implementation with optimization
12void bubbleSort(int arr[], int n) {
13bool swapped;
14for (int i = 0; i < n - 1; i++) {
15swapped = false;
16// Last i elements are already in place
17for (int j = 0; j < n - 1 - i; j++) {
18if (arr[j] > arr[j + 1]) {
19swap(&arr[j], &arr[j + 1]);
20swapped = true;
21}
22}
23// If no two elements were swapped by inner loop, then break
24if (swapped == false)
25break;
26}
27}
28
29// Function to print an array
30void printArray(int arr[], int size) {
31for (int i = 0; i < size; i++)
32printf("%d ", arr[i]);
33printf("\n");
34}
35
36int main() {
37int arr[] = {64, 34, 25, 12, 22, 11, 90};
38int n = sizeof(arr) / sizeof(arr[0]);
39bubbleSort(arr, n);
40printf("Sorted array: ");
41printArray(arr, n);
42
43int arr2[] = {1, 2, 3, 4, 5};
44int n2 = sizeof(arr2) / sizeof(arr2[0]);
45bubbleSort(arr2, n2);
46printf("Sorted array: ");
47printArray(arr2, n2);
48return 0;
49}

Algorithm description viewbox

Bubble Sort with Optimization

Algorithm description:

This C code implements the Bubble Sort algorithm, a simple sorting algorithm that repeatedly steps through the list, compares adjacent elements and swaps them if they are in the wrong order. The algorithm passes through the list until no swaps are needed, which indicates that the list is sorted. This is a fundamental algorithm for learning sorting concepts and is often used as a pedagogical tool.

Algorithm explanation:

Bubble Sort works by repeatedly comparing adjacent elements and swapping them if they are in the wrong order. In each pass, the largest unsorted element 'bubbles up' to its correct position at the end of the unsorted portion. The outer loop controls the number of passes, and the inner loop performs the comparisons and swaps. An optimization is included: if a pass completes without any swaps, the array is already sorted, and the algorithm terminates early. The worst-case and average-case time complexity is O(n^2), while the best-case (already sorted) is O(n) with the optimization. Space complexity is O(1) as it sorts in-place.

Pseudocode:

function bubbleSort(arr, n):
  for i from 0 to n-2:
    swapped = false
    for j from 0 to n-2-i:
      if arr[j] > arr[j+1]:
        swap(arr[j], arr[j+1])
        swapped = true
    if not swapped:
      break
  return arr

Library

Playable exercises

Choose Exercise

Filter, sort, and preview algorithm before you choose one to play.

Total 58 published items

Pages 8 pages available

Language

Sort by Direction

Browse published coding scenarios with filters, sorting, and pagination.

Published

C General (c)

Binary Search Implementation

Difficulty: writing: 1; length: 6
Popularity: 0
Created: 2026-01-28 14:14 UTC
Published: 2026-01-28 15:18 UTC
Author: Admin

#binary search #sorted array #search algorithm #logarithmic time #C

goal: Find the index of a target element in a sorted array. input: A sorted integer array `arr`, the `low` and `high` indices defining the search range, and the `target` integer. output: The index of the `target` if found, otherwise -1.

Canonical Algorithm Text

#include <stdio.h> // Helper function to perform binary search int binarySearch(int arr[], int low, int high, int target) { // Loop continues as long as the search space is valid while (low <= high) { // Calculate the middle index to avoid potential overflow int mid = low + (high...

Description Algorithm

This C code implements the binary search algorithm, a highly efficient method for finding an element within a sorted array. It works by repeatedly dividing the search interval in half. If the value of the search key is l...

Explanation

The `binarySearch` function takes a sorted integer array, the lower and upper bounds of the search interval (`low` and `high`), and the `target` value to find. The `while (low <= high)` loop ensures the search continues as long as there's a valid interval. The `mid` index is calculated carefully as `low + (high - low) / 2` to prevent integer overflow that could occur with `(low + high) / 2` if `low` and `high` are very large. If `arr[mid]` matches the `target`, its index is returned. If `arr[mid]` is less than `target`, the search continues in the right half by setting `low = mid + 1`. Otherwise, it searches the left half by setting `high = mid - 1`. If the loop finishes without finding the target, -1 is returned. The time complexity is O(log n) because the search space is halved in each step. The space complexity is O(1) as it uses a constant amount of extra space. Edge cases include an empty array (where `high` will be -1 initially, making `low <= high` false), and the target being smaller than the smallest element or larger than the largest element.

Pseudocode

function binarySearch(array, low, high, target): while low <= high: mid = low + (high - low) / 2 if array[mid] == target: return mid else if array[mid] < target: low = mid + 1 else: high = mid - 1 return -1 // Target not...

Published

C General (c)

Find Peak Element

Difficulty: writing: 3; length: 6
Popularity: 0
Created: 2026-01-28 14:14 UTC
Published: 2026-01-28 15:18 UTC
Author: Admin

#array #peak finding #linear scan #edge cases #C

goal: Find any peak element in an array. input: An integer array `arr` and its size `n`. output: An integer representing a peak element.

Canonical Algorithm Text

#include <stdio.h> #include <stdlib.h> // Helper function to check if an element is a peak int isPeak(int arr[], int n, int index) { // Check if the element is greater than its left neighbor if (index > 0 && arr[index] <= arr[index - 1]) { return 0; // Not a peak } // Check if th...

Description Algorithm

This program finds a peak element in an array. A peak element is defined as an element that is strictly greater than its adjacent neighbors. The function handles arrays of various sizes, including single-element arrays a...

Explanation

The `findPeakElement` function iterates through the array to locate an element that is greater than both its left and right neighbors. It first checks the boundary conditions: if the array has only one element, that element is the peak. If the first element is greater than the second, it's a peak. Similarly, if the last element is greater than the second-to-last, it's a peak. For elements in the middle, it checks if `arr[i]` is greater than `arr[i-1]` and `arr[i+1]`. The time complexity is O(n) because in the worst case, we might iterate through the entire array. The space complexity is O(1) as we only use a few variables for storage. The correctness relies on the guarantee that at least one peak exists, ensuring the loop or boundary checks will eventually find one.

Pseudocode

function findPeakElement(array, size): if size is 1: return array[0] if array[0] > array[1]: return array[0] if array[size-1] > array[size-2]: return array[size-1] for i from 1 to size-2: if array[i] > array[i-1] AND arr...

Published

C General (c)

Implement Trie (Prefix Tree)

Difficulty: writing: 6; length: 9
Popularity: 0
Created: 2026-01-28 14:14 UTC
Published: 2026-01-28 15:18 UTC
Author: Admin

#trie #prefix tree #data structure #string algorithms #memory management #C

goal: Implement a Trie data structure for efficient word storage and retrieval. input: A Trie root node and a string (word). output: For `insert`, void. For `search`, a boolean indicating if the word exists.

Canonical Algorithm Text

#include <stdio.h> #include <stdlib.h> #include <stdbool.h> #include <string.h> #define ALPHABET_SIZE 26 // Trie node structure typedef struct TrieNode { struct TrieNode *children[ALPHABET_SIZE]; bool isEndOfWord; } TrieNode; // Function to create a new Trie node TrieNode* create...

Description Algorithm

This C code implements a Trie (prefix tree) data structure. It allows for efficient insertion and searching of words. Each node in the Trie represents a character, and paths from the root to a node represent prefixes. A...

Explanation

The Trie is a tree-like data structure where each node represents a character. The `createNode` function initializes a new node with its children pointers set to NULL and `isEndOfWord` to false. The `insert` function traverses the Trie, creating new nodes as needed for characters in the word, and marks the final node as `isEndOfWord = true`. The `search` function follows the path for the given word; if the path exists and the final node is marked as `isEndOfWord`, the word is found. The `freeTrie` function recursively deallocates memory to prevent leaks. The time complexity for both insert and search is O(L), where L is the length of the word, as we traverse at most L nodes. The space complexity depends on the number of nodes, which is related to the total number of characters in all inserted words and the branching factor (ALPHABET_SIZE). Edge cases include empty strings, words that are prefixes of other words, and invalid characters.

Pseudocode

struct TrieNode: children[ALPHABET_SIZE] of TrieNode pointers isEndOfWord: boolean function createNode(): allocate memory for a new TrieNode initialize all children to NULL set isEndOfWord to false return the new node fu...

Published

C General (c)

Implement Stack using Linked List

Difficulty: writing: 7; length: 7
Popularity: 0
Created: 2026-01-28 14:14 UTC
Published: 2026-01-28 15:18 UTC
Author: Admin

#stack #linked list #data structure #LIFO #memory management #C

goal: Implement a stack using a singly linked list. input: A `Stack` pointer and data for `push`, or just a `Stack` pointer for `pop`, `peek`, `isEmpty`, `getSize`. output: For `push`, void. For `pop` and `peek`, the integer data. For `isEmpty`, boolean. For `getSize`, integer.

Canonical Algorithm Text

#include <stdio.h> #include <stdlib.h> #include <stdbool.h> // Node structure for the linked list typedef struct Node { int data; struct Node* next; } Node; // Stack structure typedef struct Stack { Node* top; int size; } Stack; // Function to create a new node Node* createNode(i...

Description Algorithm

This C code implements a stack data structure using a singly linked list. A stack follows the Last-In, First-Out (LIFO) principle. The implementation includes functions for pushing elements onto the stack, popping elemen...

Explanation

The stack is implemented using a linked list where each `Node` contains data and a pointer to the next node. The `Stack` structure itself holds a pointer to the `top` node and the current `size`. The `createNode` and `createStack` functions handle memory allocation for nodes and the stack structure, respectively, with error checking. The `push` operation creates a new node, sets its `next` pointer to the current `top`, and updates `stack->top` to the new node, incrementing the size. The `pop` operation checks for an empty stack (underflow), then removes the `top` node, frees its memory, updates `stack->top` to the next node, and decrements the size. The `peek` operation returns the data of the `top` node without removing it, also checking for an empty stack. `isEmpty` and `getSize` provide utility functions. The `freeStack` function iterates through the list, freeing each node and then the stack structure itself. The time complexity for `push`, `pop`, and `peek` is O(1) because these operations only involve manipulating the `top` of the stack. The space complexity is O(n), where n is the number of elements in the stack, due to the linked list nodes.

Pseudocode

struct Node: data: integer next: pointer to Node struct Stack: top: pointer to Node size: integer function createNode(data): allocate memory for a new Node set node.data = data set node.next = NULL return node function c...

Published

C General (c)

Implement Queue using Linked List

Difficulty: writing: 7; length: 9
Popularity: 0
Created: 2026-01-28 14:14 UTC
Published: 2026-01-28 15:18 UTC
Author: Admin

#queue #linked list #data structure #FIFO #memory management #C

goal: Implement a queue using a singly linked list. input: A `Queue` pointer and data for `enqueue`, or just a `Queue` pointer for `dequeue`, `front`, `isEmpty`, `getSize`. output: For `enqueue`, void. For `dequeue` and `front`, the integer data. For `isEmpty`, boolean. For `getSize`, integer.

Canonical Algorithm Text

#include <stdio.h> #include <stdlib.h> #include <stdbool.h> // Node structure for the linked list typedef struct QNode { int data; struct QNode* next; } QNode; // Queue structure typedef struct Queue { QNode* front; QNode* rear; int size; } Queue; // Function to create a new queu...

Description Algorithm

This C code implements a queue data structure using a singly linked list. A queue follows the First-In, First-Out (FIFO) principle. The implementation includes functions for adding elements to the rear (enqueue), removin...

Explanation

The queue is implemented with a linked list where each `QNode` stores data and a pointer to the next node. The `Queue` structure maintains pointers to both the `front` and `rear` nodes, along with the `size`. `createQNode` and `createQueue` handle memory allocation and initialization. `enqueue` creates a new node and appends it to the `rear` of the queue. If the queue is empty, the new node becomes both `front` and `rear`. `dequeue` removes the node from the `front`, frees its memory, and updates `front`. It handles the special case where the queue becomes empty after dequeueing, setting both `front` and `rear` to `NULL`. `front` returns the data of the `front` node without removing it, checking for an empty queue. `isEmpty` and `getSize` are utility functions. `freeQueue` iterates through all nodes, freeing their memory, and then frees the queue structure. The time complexity for `enqueue`, `dequeue`, and `front` is O(1) because these operations only involve manipulating the `front` and `rear` pointers. The space complexity is O(n), where n is the number of elements in the queue, due to the linked list nodes.

Pseudocode

struct QNode: data: integer next: pointer to QNode struct Queue: front: pointer to QNode rear: pointer to QNode size: integer function createQNode(data): allocate memory for a new QNode set node.data = data set node.next...

Published

C General (c)

Reverse a Linked List

Difficulty: writing: 9; length: 7
Popularity: 0
Created: 2026-01-26 16:29 UTC
Published: 2026-01-26 16:41 UTC
Author: Admin

#Linked List #Reverse #Iterative #Pointers #Data Structures #C

goal: Reverse a singly linked list. input: A pointer to the head of the linked list. output: A pointer to the head of the reversed linked list.

Canonical Algorithm Text

#include <stdio.h> #include <stdlib.h> // Definition for singly-linked list. struct ListNode { int val; struct ListNode *next; }; // Helper function to create a new node struct ListNode* createNode(int val) { struct ListNode* newNode = (struct ListNode*)malloc(sizeof(struct ListN...

Description Algorithm

This C code implements an iterative function to reverse a singly linked list. It traverses the list, changing the `next` pointer of each node to point to its previous node. This is a fundamental operation for manipulatin...

Explanation

The `reverseList` function reverses a singly linked list iteratively. It uses three pointers: `prev` (initially `NULL`), `current` (initially `head`), and `next_node` (to temporarily store the next node). In each iteration of the `while` loop, it first saves the `current->next` pointer into `next_node`. Then, it reverses the `current` node's `next` pointer to point to `prev`. Finally, it advances `prev` to `current` and `current` to `next_node`. This process continues until `current` becomes `NULL`, at which point `prev` points to the new head of the reversed list. Edge cases, such as an empty list (`head == NULL`) or a list with a single node (`head->next == NULL`), are handled by returning the `head` directly, as no reversal is needed. The time complexity is O(n) because each node is visited and processed once. The space complexity is O(1) as only a constant number of extra pointers are used.

Pseudocode

function reverseList(head): prev = null current = head while current is not null: next_node = current.next current.next = prev prev = current current = next_node return prev

Published

C General (c)

Find Max Subarray Sum (Kadane's Algorithm)

Difficulty: writing: 8; length: 9
Popularity: 0
Created: 2026-01-26 16:29 UTC
Published: 2026-01-26 16:41 UTC
Author: Admin

#Kadane's Algorithm #Array #Max Sum #Dynamic Programming #Linear Time

goal: Find the maximum sum of a contiguous subarray. input: An array of integers. output: The maximum sum found.

Canonical Algorithm Text

#include <stdio.h> #include <limits.h> // Helper function to find the maximum of two integers int max(int a, int b) { return (a > b) ? a : b; } // Function to find the maximum sum of a contiguous subarray int maxSubArraySum(int arr[], int size) { // Handle empty array edge case i...

Description Algorithm

This C code implements Kadane's algorithm to find the maximum sum of a contiguous subarray within a given array of integers. It iterates through the array, maintaining a `current_max` sum and a `max_so_far` sum. This alg...

Explanation

Kadane's algorithm efficiently solves the maximum subarray sum problem in linear time. The core idea is to iterate through the array, keeping track of the maximum sum ending at the current position (`current_max`) and the overall maximum sum found so far (`max_so_far`). If `current_max` becomes negative, it's reset to zero, as a negative sum would only decrease the potential maximum sum of any subsequent subarray. The algorithm handles arrays with all negative numbers by initializing `max_so_far` to the smallest possible integer, ensuring that the largest negative number is correctly identified as the maximum sum. The time complexity is O(n) because we traverse the array once. The space complexity is O(1) as we only use a few variables to store intermediate sums. The invariant maintained is that `max_so_far` always holds the maximum subarray sum found up to the current element.

Pseudocode

function maxSubArraySum(array): if array is empty: return 0 max_so_far = negative infinity current_max = 0 for each element in array: current_max = current_max + element if current_max > max_so_far: max_so_far = current_...

Published

C General (c)

Find First Non-Repeating Character

Difficulty: writing: 10; length: 6
Popularity: 0
Created: 2026-01-26 16:29 UTC
Published: 2026-01-26 16:41 UTC
Author: Admin

#String #Frequency Map #Array #First Unique #Linear Scan #C

goal: Find the index of the first non-repeating character in a string. input: A constant character pointer (string). output: The index of the first non-repeating character, or -1 if none exists.

Canonical Algorithm Text

#include <stdio.h> #include <string.h> #include <stdlib.h> #define ALPHABET_SIZE 26 // Assuming lowercase English letters // Helper function to find the index of the first non-repeating character int firstUniqChar(const char* s) { // Handle null or empty string edge cases if (s =...

Description Algorithm

This C code finds the index of the first non-repeating character in a given string. It uses a frequency array to count occurrences of each character and then iterates through the string again to find the first character...

Explanation

The `firstUniqChar` function efficiently finds the index of the first non-repeating character in a string. It employs a two-pass approach. In the first pass, it iterates through the input string `s` and populates a frequency array `charCount` of size 26 (assuming lowercase English letters). Each index in `charCount` corresponds to a letter ('a' to 'z'), and its value stores the number of times that letter appears in the string. The second pass iterates through the string again. For each character, it checks its count in the `charCount` array. If the count is exactly 1, it means this is the first non-repeating character encountered, and its index `i` is returned. If the loop completes without finding any character with a count of 1, it signifies that all characters repeat or the string was empty, and -1 is returned. Edge cases like null or empty strings are handled at the beginning. The time complexity is O(n), where n is the length of the string, because we perform two linear passes. The space complexity is O(1) because the size of the frequency array is constant (26), regardless of the input string's length.

Pseudocode

function firstUniqChar(string s): if s is null or empty: return -1 create frequency_map (array of size 26, initialized to 0) for each character c in s: increment count for c in frequency_map for each character c at index...

Language (required)

Paste your code (required)

Max 20,000 characters. (Dangerous HTML/script fragments will be blocked)

Normalized preview:

I agree to Publish this, after admin approval (queued for review). (Not required) I confirm this submission is anonymous and does not contain personal data. I grant SkillsTyping a free, non-exclusive, worldwide, and irrevocable license to store, modify, adapt, and publish this content after review. I understand that publication is not guaranteed, that I retain no ownership or usage claims over published versions, and that no compensation will be provided. See Privacy Policy

Publish details

Shown only if you opt to submit for review. Required when consent is checked.

Title (required with consent)

Short description / summary (required with consent)

Algorithm explanation (required with consent)

Pseudocode (required with consent)