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.

1class LongestPalindromeFinder {
2
3/**
4* Finds the longest palindromic substring within a given string.
5* This method uses the 'Expand Around Center' approach.
6*
7* @param s The input string.
8* @return The longest palindromic substring.
9* @throws IllegalArgumentException if the input string is null or empty.
10*/
11public String longestPalindrome(String s) {
12if (s == null || s.length() < 1) {
13throw new IllegalArgumentException("Input string cannot be null or empty.");
14}
15
16int start = 0;
17int end = 0;
18
19// Iterate through each character as a potential center of a palindrome.
20for (int i = 0; i < s.length(); i++) {
21// Case 1: Palindrome centered at a single character (e.g., "aba")
22int len1 = expandAroundCenter(s, i, i);
23// Case 2: Palindrome centered between two characters (e.g., "abba")
24int len2 = expandAroundCenter(s, i, i + 1);
25
26// Get the maximum length from the two cases.
27int len = Math.max(len1, len2);
28
29// If the current palindrome is longer than the longest found so far,
30// update the start and end indices.
31if (len > end - start) {
32// For odd length palindromes (len1), the center is i.
33// For even length palindromes (len2), the center is between i and i+1.
34// The formula (i - (len - 1) / 2) correctly calculates the start index
35// for both odd and even length palindromes.
36start = i - (len - 1) / 2;
37end = i + len / 2;
38}
39}
40
41// Extract the longest palindromic substring using the final start and end indices.
42// The substring method's end index is exclusive, so we add 1.
43return s.substring(start, end + 1);
44}
45
46/**
47* Expands around a given center (or pair of centers) to find the length of the palindrome.
48*
49* @param s     The input string.
50* @param left  The left index of the center.
51* @param right The right index of the center.
52* @return The length of the palindrome found expanding from the center(s).
53*/
54private int expandAroundCenter(String s, int left, int right) {
55int L = left;
56int R = right;
57
58// Expand as long as the characters match and we are within string bounds.
59while (L >= 0 && R < s.length() && s.charAt(L) == s.charAt(R)) {
60L--;
61R++;
62}
63
64// The length of the palindrome is R - L - 1.
65// For example, if L becomes -1 and R becomes 3 for "aba", length is 3 - (-1) - 1 = 3.
66// If L becomes 0 and R becomes 1 for "aa", length is 1 - 0 - 1 = 0 (incorrect, should be 2).
67// The correct calculation is R - L - 1. For "aa", L=-1, R=2, length = 2 - (-1) - 1 = 2.
68// For "aba", L=0, R=2, length = 2 - 0 - 1 = 1 (incorrect, should be 3).
69// Let's re-evaluate. When loop breaks, L is one step too far left, R is one step too far right.
70// The valid palindrome indices are L+1 to R-1.
71// Length = (R-1) - (L+1) + 1 = R - 1 - L - 1 + 1 = R - L - 1.
72// Example "aba", i=1. len1=expand(s,1,1). L=1,R=1. s[1]==s[1]. L=0,R=2. s[0]==s[2]. L=-1,R=3. Loop ends. R-L-1 = 3 - (-1) - 1 = 3.
73// Example "abba", i=1. len2=expand(s,1,2). L=1,R=2. s[1]==s[2]. L=0,R=3. s[0]==s[3]. L=-1,R=4. Loop ends. R-L-1 = 4 - (-1) - 1 = 4.
74return R - L - 1;
75}
76}

Algorithm description viewbox

Longest Palindromic Substring

Algorithm description:

This program finds the longest palindromic substring within a given string using the 'Expand Around Center' approach. A palindrome is a sequence that reads the same backward as forward. This algorithm efficiently checks all possible palindromic substrings by considering each character and the space between characters as potential centers. A practical application is in text processing, search engines, or bioinformatics where identifying palindromic sequences is crucial.

Algorithm explanation:

The 'Expand Around Center' algorithm has a time complexity of O(n^2), where n is the length of the string. This is because there are 2n-1 possible centers (n characters and n-1 spaces between characters), and for each center, we might expand up to n/2 characters in both directions. The space complexity is O(1) as we only use a few variables to store indices and lengths. The algorithm iterates through all possible centers. For each center, it expands outwards as long as the characters match and stay within the string boundaries. It keeps track of the longest palindrome found so far by updating the start and end indices. Edge cases include null or empty input strings, and strings with only one character. The correctness is guaranteed by exhaustively checking all potential palindromic centers and their maximum possible expansions.

Pseudocode:

function longestPalindrome(string s):
  if s is null or empty:
    throw error

  start = 0
  end = 0

  for i from 0 to length(s) - 1:
    // Expand around single character center
    len1 = expandAroundCenter(s, i, i)
    // Expand around center between two characters
    len2 = expandAroundCenter(s, i, i + 1)

    maxLength = max(len1, len2)

    // If current palindrome is longer than the longest found so far
    if maxLength > (end - start):
      start = i - (maxLength - 1) / 2
      end = i + maxLength / 2

  return substring of s from start to end (inclusive)

function expandAroundCenter(string s, left, right):
  L = left
  R = right
  while L >= 0 and R < length(s) and s[L] == s[R]:
    L = L - 1
    R = R + 1
  // Length is R - L - 1
  return R - L - 1

Library

Playable exercises

Choose Exercise

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

Total 23 published items

Pages 3 pages available

Language

Sort by Direction

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

Published

Groovy Backend (groovy)

Groovy String Reversal

Difficulty: writing: 2; length: 1
Popularity: 0
Created: 2026-01-28 14:59 UTC
Published: 2026-01-28 15:16 UTC
Author: Damian

#string #recursion #basic #language feature

goal: Reverse a string. input: A string. output: The reversed string.

Canonical Algorithm Text

class StringReverser { String reverseString(String input) { if (input == null || input.length() <= 1) { return input; } return reverseHelper(input, input.length() - 1); } private String reverseHelper(String str, int index) { if (index < 0) { return ""; } return str.charAt(index)...

Description Algorithm

This Groovy code defines a class `StringReverser` with a method to reverse a given string. It uses a recursive helper function to build the reversed string character by character. This is a fundamental string manipulatio...

Explanation

The `reverseString` method handles null or short strings as base cases. The `reverseHelper` function recursively appends the character at the current index to the result of reversing the rest of the string. The time complexity is O(n) because each character is processed once. The space complexity is also O(n) due to the recursive call stack. Edge cases like empty strings and single-character strings are explicitly handled, ensuring correctness.

Pseudocode

function reverseString(input): if input is null or length of input is 0 or 1: return input return reverseHelper(input, length of input - 1) function reverseHelper(str, index): if index is less than 0: return empty string...

Published

Groovy Backend (groovy)

Groovy Advanced Graph Traversal (Dijkstra)

Difficulty: writing: 10; length: 8
Popularity: 0
Created: 2026-01-28 14:59 UTC
Published: 2026-01-28 15:16 UTC
Author: Damian

#graph #dijkstra #shortest path #priority queue #algorithms

goal: Find shortest paths from a source node in a weighted graph. input: A graph represented by an adjacency list and a starting node. output: A map of nodes to their shortest distances from the start node.

Canonical Algorithm Text

import java.util.PriorityQueue import java.util.HashMap import java.util.Map import java.util.List import java.util.ArrayList import java.util.Collections class Graph { private Map<String, List<Edge>> adjacencyList Graph() { adjacencyList = new HashMap<>() } void addNode(String n...

Description Algorithm

This Groovy code implements Dijkstra's algorithm to find the shortest paths from a single source node to all other nodes in a weighted graph. It uses a priority queue to efficiently select the next node to visit. This al...

Explanation

Dijkstra's algorithm finds the shortest paths in a graph with non-negative edge weights. It maintains a set of visited nodes and a priority queue of nodes to visit, ordered by their current shortest distance from the source. The algorithm iteratively extracts the node with the smallest distance from the priority queue and relaxes its outgoing edges. Relaxation involves checking if a shorter path to a neighbor can be found through the current node. The time complexity is typically O(E log V) or O(E + V log V) depending on the priority queue implementation, where V is the number of vertices and E is the number of edges. Space complexity is O(V + E) for storing the graph and distances. Edge cases include disconnected graphs (handled by `Integer.MAX_VALUE` distances) and invalid start nodes.

Pseudocode

function dijkstra(graph, startNode): distances = map of all nodes to infinity previousNodes = empty map priorityQueue = empty priority queue distances[startNode] = 0 add startNode with distance 0 to priorityQueue while p...

Published

Groovy Backend (groovy)

Groovy Array Summation

Difficulty: writing: 8; length: 1
Popularity: 0
Created: 2026-01-28 14:59 UTC
Published: 2026-01-28 15:16 UTC
Author: Damian

#array #summation #basic #iteration

goal: Calculate the sum of elements in an integer array. input: An array of integers. output: The sum of the integers in the array.

Canonical Algorithm Text

class ArraySummer { int sumArray(int[] numbers) { if (numbers == null || numbers.length == 0) { return 0; } int total = 0; for (int number : numbers) { total += number; } return total; } }

Description Algorithm

This Groovy code provides a simple utility to sum all the elements within an integer array. It iterates through the array, accumulating the sum of its elements. This is a foundational operation used in data analysis, sta...

Explanation

The `sumArray` method initializes a `total` variable to 0. It then iterates through each `number` in the input `numbers` array and adds it to `total`. The method handles null or empty arrays by returning 0. The time complexity is O(n), where n is the number of elements in the array, as each element is visited once. The space complexity is O(1) as it only uses a constant amount of extra space for the `total` variable. The algorithm correctly sums positive, negative, and zero values.

Pseudocode

function sumArray(numbers): if numbers is null or numbers is empty: return 0 total = 0 for each number in numbers: total = total + number return total

Published

Groovy Backend (groovy)

Groovy Binary Search Implementation

Difficulty: writing: 7; length: 4
Popularity: 0
Created: 2026-01-28 14:59 UTC
Published: 2026-01-28 15:16 UTC
Author: Damian

#binary search #array #search #logarithmic time #algorithms

goal: Find the index of a target value in a sorted array. input: A sorted array of integers and an integer target value. output: The index of the target value if found, otherwise -1.

Canonical Algorithm Text

class BinarySearcher { /** * Performs binary search on a sorted array of integers. * * @param sortedArray The array to search within. Must be sorted in ascending order. * @param target The value to search for. * @return The index of the target value if found, otherwise -1. */ int...

Description Algorithm

This Groovy code implements the binary search algorithm to efficiently find a target value within a sorted array of integers. It repeatedly divides the search interval in half. This algorithm is fundamental for searching...

Explanation

Binary search works by repeatedly dividing the search interval in half. It starts with an interval covering the whole array. If the value of the search key is less than the item in the middle of the interval, the search narrows to the lower half. Otherwise, it narrows to the upper half. This process continues until the value is found or the interval is empty. The time complexity is O(log n) because the search space is halved in each step. The space complexity is O(1) for the iterative version. Edge cases include an empty or null array, and the target being smaller than the smallest element or larger than the largest element, all of which are handled by the loop termination and return value of -1.

Pseudocode

function binarySearch(sortedArray, target): if sortedArray is null or empty: return -1 low = 0 high = length of sortedArray - 1 while low <= high: mid = low + (high - low) / 2 if sortedArray[mid] == target: return mid el...

Published

Groovy Backend (groovy)

Groovy Binary Search Implementation

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

#binary search #search #algorithm #sorted array #groovy

goal: Find the index of a target element in a sorted array. input: A sorted integer array and an integer target. output: The index of the target element, or -1 if not found.

Canonical Algorithm Text

class BinarySearch { /** * Performs an iterative binary search on a sorted array. * Assumes the input array is sorted in ascending order. * * @param sortedArray The array to search within. * @param target The value to search for. * @return The index of the target element if found...

Description Algorithm

This Groovy code provides an iterative implementation of the binary search algorithm. Binary search is an efficient algorithm for finding an item from a sorted list of items. It works by repeatedly dividing in half the p...

Explanation

The `search` method takes a sorted integer array and a target integer. It initializes `low` to 0 and `high` to the last index of the array. The `while` loop continues as long as `low` is less than or equal to `high`. Inside the loop, the `mid` index is calculated to prevent potential integer overflow. If the element at `mid` matches the `target`, its index is returned. If the element at `mid` is less than the `target`, the search continues in the right half by setting `low` to `mid + 1`. Otherwise, the search continues in the left half by setting `high` to `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 iteration. The space complexity is O(1) as it uses a constant amount of extra space.

Pseudocode

FUNCTION search(sortedArray, target): IF sortedArray IS NULL OR length of sortedArray IS 0 THEN RETURN -1 END IF low = 0 high = length of sortedArray - 1 WHILE low <= high: mid = low + (high - low) / 2 IF sortedArray[mid...

Published

Groovy Backend (groovy)

Groovy String Reversal

Difficulty: writing: 3; length: 4
Popularity: 0
Created: 2026-01-28 14:19 UTC
Published: 2026-01-28 15:17 UTC
Author: Admin

#string #reversal #basic #algorithm #groovy

goal: Reverse a string. input: A string. output: The reversed string.

Canonical Algorithm Text

class StringReverser { /** * Reverses a given string. * Handles null, empty, and single-character strings gracefully. * * @param input The string to reverse. * @return The reversed string, or null if the input was null. */ String reverseString(String input) { if (input == null) {...

Description Algorithm

This Groovy code implements a function to reverse a given string. It handles null, empty, and single-character strings as edge cases. The core logic iterates through the input string and builds a new string with characte...

Explanation

The `reverseString` method takes a string as input and returns its reversed version. It first checks for null input, returning null if found. Then, it handles strings of length 0 or 1 by returning them directly, as they are already reversed. For longer strings, it creates a character array of the same length and populates it by picking characters from the input string starting from the last character and moving towards the first. Finally, it constructs and returns a new string from this character array. The time complexity is O(n), where n is the length of the string, because each character is processed once. The space complexity is also O(n) due to the creation of the new character array to store the reversed string.

Pseudocode

FUNCTION reverseString(input): IF input IS NULL THEN RETURN NULL END IF length = length of input IF length IS LESS THAN OR EQUAL TO 1 THEN RETURN input END IF CREATE charArray of size length FOR i FROM 0 TO length - 1: c...

Published

Groovy Backend (groovy)

Groovy Graph BFS Traversal

Difficulty: writing: 1; length: 10
Popularity: 0
Created: 2026-01-28 14:19 UTC
Published: 2026-01-28 15:17 UTC
Author: Admin

#graph #bfs #traversal #algorithm #groovy #data structures

goal: Perform Breadth-First Search on a graph. input: An adjacency list representation of a graph and a starting node. output: A list of nodes visited in BFS order.

Canonical Algorithm Text

import java.util.LinkedList import java.util.Queue import java.util.Set import java.util.HashSet import java.util.Map import java.util.HashMap import java.util.List import java.util.ArrayList class GraphBFS { private Map<Integer, List<Integer>> adjacencyList private Set<Integer>...

Description Algorithm

This Groovy code implements the Breadth-First Search (BFS) algorithm for a graph represented using an adjacency list. BFS explores a graph level by level, starting from a specified source node. It's commonly used for fin...

Explanation

The `GraphBFS` class utilizes an adjacency list to represent the graph. The `bfs` method performs the traversal. It initializes a queue and a set to keep track of visited nodes. Starting with the `startNode`, it adds it to the queue and marks it as visited. The algorithm then iteratively dequeues a node, adds it to the result list, and enqueues all its unvisited neighbors, marking them as visited. This process continues until the queue is empty. To handle disconnected components, the code iterates through all nodes in the adjacency list and initiates a new BFS if a node hasn't been visited yet. The time complexity is O(V + E), where V is the number of vertices and E is the number of edges, as each vertex and edge is visited at most once. The space complexity is O(V) for storing the visited set and the queue.

Pseudocode

CLASS GraphBFS: ATTRIBUTES: adjacencyList: Map<Integer, List<Integer>> visited: Set<Integer> CONSTRUCTOR(adjList): INITIALIZE adjacencyList FROM adjList INITIALIZE visited AS empty Set METHOD bfs(startNode): result = emp...

Published

Groovy Backend (groovy)

Groovy Bubble Sort Algorithm

Difficulty: writing: 1; length: 5
Popularity: 0
Created: 2026-01-28 14:19 UTC
Published: 2026-01-28 15:17 UTC
Author: Admin

#bubble sort #sorting #algorithm #groovy #arrays

goal: Sort an array of integers using Bubble Sort. input: An array of integers. output: The input array sorted in ascending order.

Canonical Algorithm Text

class BubbleSort { /** * Sorts an array of integers using the Bubble Sort algorithm. * Includes an optimization to terminate early if the array becomes sorted. * * @param arr The array of integers to sort. */ void sort(int[] arr) { if (arr == null || arr.length <= 1) { return //...

Description Algorithm

This Groovy 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 pass through the lis...

Explanation

The `sort` method implements Bubble Sort. It uses two nested loops. The outer loop iterates `n-1` times, where `n` is the length of the array, ensuring that each element has a chance to 'bubble up' to its correct position. The inner loop compares adjacent elements (`arr[j]` and `arr[j+1]`). If `arr[j]` is greater than `arr[j+1]`, they are swapped. A boolean flag `swapped` tracks if any swaps occurred in a pass. If a pass completes without any swaps, it means the array is sorted, and the outer loop breaks early. The time complexity in the worst and average cases is O(n^2), where n is the number of elements. In the best case (already sorted array with the optimization), it's O(n). The space complexity is O(1) as it only uses a constant amount of extra space for the temporary variable during swaps.

Pseudocode

FUNCTION sort(arr): n = length of arr IF n IS LESS THAN OR EQUAL TO 1 THEN RETURN END IF swapped = TRUE i = 0 WHILE i < n - 1 AND swapped IS TRUE: swapped = FALSE FOR j FROM 0 TO n - 2 - i: IF arr[j] > arr[j + 1] THEN SW...

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)