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.

1import java.util.ArrayList
2import java.util.HashMap
3import java.util.List
4import java.util.Map
5import java.util.regex.Matcher
6import java.util.regex.Pattern
7
8class DslConfigParser {
9
10private static final Pattern KEY_VALUE_PAIR_PATTERN = Pattern.compile("\s*(\w+)\s*:\s*(.*?)(?:,|\n|$)")
11private static final Pattern BLOCK_START_PATTERN = Pattern.compile("\s*(\w+)\s*\{\s*$")
12private static final Pattern BLOCK_END_PATTERN = Pattern.compile("\s*\}\s*$")
13
14private static final Map<String, Class<?>> VALID_TYPES = [
15"string": String.class,
16"integer": Integer.class,
17"boolean": Boolean.class,
18"list": List.class
19]
20
21/**
22* Parses a DSL configuration string into a structured map.
23* @param dslContent The DSL configuration content.
24* @return A map representing the parsed configuration.
25* @throws IllegalArgumentException if parsing fails or structure is invalid.
26*/
27Map<String, Object> parse(String dslContent) {
28if (dslContent == null || dslContent.trim().isEmpty()) {
29return [:]
30}
31// Basic validation: Ensure balanced braces
32if (countOccurrences(dslContent, '{') != countOccurrences(dslContent, '}')) {
33throw new IllegalArgumentException("Mismatched braces in DSL content.")
34}
35
36// For simplicity, we'll use a simplified recursive descent approach.
37// A real parser might use a lexer/parser generator.
38return parseBlock(dslContent, 0)
39}
40
41/**
42* Recursively parses a block of DSL content.
43* @param content The content to parse.
44* @param startIndex The starting index within the content.
45* @return A map representing the parsed block and the new index.
46* @throws IllegalArgumentException if parsing fails.
47*/
48private Map<String, Object> parseBlock(String content, int startIndex) {
49Map<String, Object> blockData = new HashMap<>()
50int currentIndex = startIndex
51
52while (currentIndex < content.length()) {
53Matcher blockStartMatcher = BLOCK_START_PATTERN.matcher(content)
54blockStartMatcher.region(currentIndex, content.length())
55if (blockStartMatcher.lookingAt()) {
56String blockName = blockStartMatcher.group(1)
57int blockContentStart = blockStartMatcher.end()
58int blockEndIndex = findMatchingBrace(content, blockContentStart)
59if (blockEndIndex == -1) {
60throw new IllegalArgumentException("Unclosed block starting at index ${currentIndex}.")
61}
62String subBlockContent = content.substring(blockContentStart, blockEndIndex)
63blockData.put(blockName, parseBlock(subBlockContent, 0))
64currentIndex = blockEndIndex + 1
65} else {
66Matcher keyValueMatcher = KEY_VALUE_PAIR_PATTERN.matcher(content)
67keyValueMatcher.region(currentIndex, content.length())
68if (keyValueMatcher.lookingAt()) {
69String key = keyValueMatcher.group(1)
70String valueStr = keyValueMatcher.group(2).trim()
71// Attempt to parse value based on context or type inference
72blockData.put(key, parseValue(valueStr))
73currentIndex = keyValueMatcher.end()
74} else if (BLOCK_END_PATTERN.matcher(content).region(currentIndex, content.length()).lookingAt()) {
75// End of current block, return
76break
77} else if (Character.isWhitespace(content.charAt(currentIndex))) {
78// Skip whitespace
79currentIndex++
80} else {
81throw new IllegalArgumentException("Unexpected token at index ${currentIndex}: ${content.substring(currentIndex, Math.min(currentIndex + 10, content.length()))}")
82}
83}
84}
85return blockData
86}
87
88/**
89* Parses a string value into its appropriate type (String, Integer, Boolean).
90* @param valueStr The string representation of the value.
91* @return The parsed value object.
92*/
93private Object parseValue(String valueStr) {
94if (valueStr.equalsIgnoreCase("true")) return Boolean.TRUE
95if (valueStr.equalsIgnoreCase("false")) return Boolean.FALSE
96try {
97return Integer.parseInt(valueStr)
98} catch (NumberFormatException e) {
99// It's a string, remove potential quotes
100if (valueStr.startsWith("'") && valueStr.endsWith("'")) {
101return valueStr.substring(1, valueStr.length() - 1)
102}
103if (valueStr.startsWith("\"") && valueStr.endsWith("\"")) {
104return valueStr.substring(1, valueStr.length() - 1)
105}
106return valueStr // Return as string if no quotes and not a number
107}
108}
109
110/**
111* Finds the index of the matching closing brace for a given opening brace.
112* @param content The string to search within.
113* @param startIndex The index of the opening brace.
114* @return The index of the matching closing brace, or -1 if not found.
115*/
116private int findMatchingBrace(String content, int startIndex) {
117int braceLevel = 1
118for (int i = startIndex; i < content.length(); i++) {
119char c = content.charAt(i)
120if (c == '{') {
121braceLevel++
122} else if (c == '}') {
123braceLevel--
124if (braceLevel == 0) {
125return i
126}
127}
128}
129return -1
130}
131
132/**
133* Counts occurrences of a character in a string.
134* @param text The string to search.
135* @param charToCount The character to count.
136* @return The number of occurrences.
137*/
138private int countOccurrences(String text, char charToCount) {
139int count = 0
140for (int i = 0; i < text.length(); i++) {
141if (text.charAt(i) == charToCount) {
142count++
143}
144}
145return count
146}
147
148/**
149* Validates the parsed configuration against a schema.
150* @param config The parsed configuration map.
151* @param schema The validation schema map.
152* @throws IllegalArgumentException if validation fails.
153*/
154void validate(Map<String, Object> config, Map<String, Object> schema) {
155schema.each {
156schemaName, schemaDefinition ->
157if (schemaDefinition instanceof Map) { // Nested block
158if (!config.containsKey(schemaName)) {
159throw new IllegalArgumentException("Missing required block: ${schemaName}")
160}
161Object configValue = config.get(schemaName)
162if (!(configValue instanceof Map)) {
163throw new IllegalArgumentException("Expected block '${schemaName}' to be a map, but found ${configValue.class.simpleName}.")
164}
165validate(configValue as Map<String, Object>, schemaDefinition as Map<String, Object>)
166} else if (schemaDefinition instanceof String) { // Simple type validation
167if (!config.containsKey(schemaName)) {
168throw new IllegalArgumentException("Missing required field: ${schemaName}")
169}
170Object configValue = config.get(schemaName)
171Class<?> expectedType = VALID_TYPES.get(schemaDefinition)
172if (expectedType == null) {
173throw new IllegalArgumentException("Unknown type in schema: ${schemaDefinition}")
174}
175if (!expectedType.isInstance(configValue)) {
176throw new IllegalArgumentException("Field '${schemaName}' expected type ${schemaDefinition}, but found ${configValue.class.simpleName}.")
177}
178} else {
179throw new IllegalArgumentException("Invalid schema definition for '${schemaName}'. Must be String (type) or Map (nested schema).")
180}
181}
182}
183
184/**
185* Main method for demonstration.
186*/
187static void main(String[] args) {
188DslConfigParser parser = new DslConfigParser()
189
190String dsl1 = """
191server {
192host: 'localhost',
193port: 8080,
194sslEnabled: false
195}
196database {
197type: 'postgresql',
198connectionString: "jdbc:postgresql://db.example.com/mydb",
199poolSize: 10
200}
201"""
202
203Map<String, Object> schema1 = [
204"server": [
205"host": "string",
206"port": "integer",
207"sslEnabled": "boolean"
208],
209"database": [
210"type": "string",
211"connectionString": "string",
212"poolSize": "integer"
213]
214]
215
216try {
217Map<String, Object> parsedConfig1 = parser.parse(dsl1)
218println "Parsed Config 1: ${parsedConfig1}"
219parser.validate(parsedConfig1, schema1)
220println "Validation successful for Config 1."
221} catch (IllegalArgumentException e) {
222println "Error processing Config 1: ${e.getMessage()}"
223}
224
225println "\n---\n\n"
226
227String dsl2 = """
228logging {
229level: 'INFO',
230file: "app.log"
231}
232users: [
233name: 'admin',
234id: 123
235] // This is an invalid structure for a list
236"""
237
238Map<String, Object> schema2 = [
239"logging": [
240"level": "string",
241"file": "string"
242],
243"users": "list" // Expecting a list, but DSL structure is wrong
244]
245
246try {
247Map<String, Object> parsedConfig2 = parser.parse(dsl2)
248println "Parsed Config 2: ${parsedConfig2}"
249parser.validate(parsedConfig2, schema2)
250println "Validation successful for Config 2."
251} catch (IllegalArgumentException e) {
252println "Error processing Config 2: ${e.getMessage()}"
253}
254
255println "\n---\n\n"
256
257String dsl3 = """
258settings {
259timeout: 30
260}
261features {
262featureA: true
263}
264"""
265
266Map<String, Object> schema3 = [
267"settings": [
268"timeout": "integer"
269],
270"features": [
271"featureA": "boolean",
272"featureB": "boolean" // Missing in DSL
273]
274]
275
276try {
277Map<String, Object> parsedConfig3 = parser.parse(dsl3)
278println "Parsed Config 3: ${parsedConfig3}"
279parser.validate(parsedConfig3, schema3)
280println "Validation successful for Config 3."
281} catch (IllegalArgumentException e) {
282println "Error processing Config 3: ${e.getMessage()}"
283}
284}
285}

Algorithm description viewbox

DSL Configuration Parser with Validation

Algorithm description:

This Groovy code implements a parser for a custom configuration DSL. It takes a string representing the DSL configuration, which can include nested blocks and key-value pairs, and transforms it into a nested map structure. Crucially, it also includes a validation step that checks the parsed structure against a predefined schema, ensuring that required fields are present and have the correct data types. This is essential for robust configuration management in applications.

Algorithm explanation:

The `DslConfigParser` class uses regular expressions to identify key-value pairs and block structures (`{}`) within the DSL content. The `parse` method acts as the entry point, performing a basic check for balanced braces and then calling `parseBlock` to handle the recursive parsing. `parseBlock` iterates through the content, identifying and recursively parsing nested blocks or parsing key-value pairs. `parseValue` attempts to infer the type of a value (boolean, integer, or string). The `findMatchingBrace` helper is critical for correctly identifying the boundaries of nested blocks. After parsing, the `validate` method takes the parsed map and a schema map. It recursively traverses both structures, checking for the presence of required keys and verifying that the data types of the parsed values match the types specified in the schema. Error handling is done via `IllegalArgumentException`. The time complexity is roughly O(N) where N is the length of the DSL content, as each character is processed a constant number of times. Space complexity is O(D) where D is the depth of nesting, due to recursion stack and map storage.

Pseudocode:

CLASS DslConfigParser:
  // Regex patterns for key-value, block start/end
  // Map of valid type names to Class objects

  FUNCTION parse(dslContent):
    IF dslContent is null OR empty THEN RETURN empty map
    IF count('{') != count('}') THEN THROW error "Mismatched braces"
    RETURN parseBlock(dslContent, 0)
  END FUNCTION

  FUNCTION parseBlock(content, startIndex):
    blockData = new map
    currentIndex = startIndex

    WHILE currentIndex < length(content):
      IF content matches BLOCK_START_PATTERN at currentIndex:
        blockName = captured group 1
        blockContentStart = matcher.end()
        blockEndIndex = findMatchingBrace(content, blockContentStart)
        IF blockEndIndex == -1 THEN THROW error "Unclosed block"
        subBlockContent = substring(content, blockContentStart, blockEndIndex)
        blockData[blockName] = parseBlock(subBlockContent, 0)
        currentIndex = blockEndIndex + 1
      ELSE IF content matches KEY_VALUE_PAIR_PATTERN at currentIndex:
        key = captured group 1
        valueStr = captured group 2.trim()
        blockData[key] = parseValue(valueStr)
        currentIndex = matcher.end()
      ELSE IF content matches BLOCK_END_PATTERN at currentIndex:
        BREAK // End of current block
      ELSE IF isWhitespace(content[currentIndex]):
        currentIndex++
      ELSE:
        THROW error "Unexpected token"
      END IF
    END WHILE
    RETURN blockData
  END FUNCTION

  FUNCTION parseValue(valueStr):
    IF valueStr is "true" (case-insensitive) THEN RETURN true
    IF valueStr is "false" (case-insensitive) THEN RETURN false
    TRY:
      RETURN Integer.parseInt(valueStr)
    CATCH NumberFormatException:
      // Remove quotes if present, otherwise return as string
      RETURN valueStr without surrounding quotes
    END TRY
  END FUNCTION

  FUNCTION findMatchingBrace(content, startIndex):
    // Logic to find matching brace, handling nested braces
    // ... returns index or -1 ...
  END FUNCTION

  FUNCTION countOccurrences(text, charToCount):
    // Counts character occurrences
    // ... returns count ...
  END FUNCTION

  FUNCTION validate(config, schema):
    FOR EACH schemaName, schemaDefinition IN schema:
      IF schemaDefinition is a Map:
        IF config does not contain schemaName THEN THROW error "Missing block"
        configValue = config[schemaName]
        IF configValue is not a Map THEN THROW error "Expected map"
        validate(configValue, schemaDefinition)
      ELSE IF schemaDefinition is a String:
        IF config does not contain schemaName THEN THROW error "Missing field"
        configValue = config[schemaName]
        expectedType = VALID_TYPES[schemaDefinition]
        IF expectedType is null THEN THROW error "Unknown schema type"
        IF configValue is not an instance of expectedType THEN THROW error "Type mismatch"
      ELSE:
        THROW error "Invalid schema definition"
      END IF
    END FOR
  END FUNCTION

  FUNCTION main(args):
    // ... (demonstration code) ...
  END FUNCTION
END CLASS

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)