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 groovy.lang.GroovyShell
2import groovy.lang.Binding
3import java.util.Map
4import java.util.HashMap
5
6class DynamicScriptExecutor {
7
8private GroovyShell shell
9private Binding binding
10
11/**
12* Initializes the executor with a set of global variables.
13* @param globalVariables A map of variable names to their values.
14*/
15DynamicScriptExecutor(Map<String, Object> globalVariables = [:]) {
16binding = new Binding()
17globalVariables.each {
18key, value -> binding.setVariable(key, value)
19}
20shell = new GroovyShell(binding)
21}
22
23/**
24* Executes a given Groovy script string.
25* @param script The Groovy script to execute.
26* @return A map containing 'output' (stdout) and 'result' (return value of the script).
27*         Returns null if the script is null or empty.
28*/
29Map<String, Object> executeScript(String script) {
30if (script == null || script.trim().isEmpty()) {
31println "Warning: Script is null or empty."
32return null
33}
34
35// Capture stdout
36ByteArrayOutputStream baos = new ByteArrayOutputStream()
37PrintStream ps = new PrintStream(baos)
38PrintStream originalOut = System.out
39System.setOut(ps)
40
41Object result = null
42try {
43result = shell.evaluate(script)
44} catch (Exception e) {
45println "Error executing script: ${e.getMessage()}"
46e.printStackTrace(ps) // Print stack trace to our stream
47} finally {
48// Restore stdout
49System.out = originalOut
50ps.close()
51}
52
53String output = baos.toString()
54Map<String, Object> executionResult = new HashMap<>()
55executionResult.put("output", output)
56executionResult.put("result", result)
57
58return executionResult
59}
60
61/**
62* Adds or updates a variable in the script's binding.
63* @param name The name of the variable.
64* @param value The value of the variable.
65*/
66void setVariable(String name, Object value) {
67binding.setVariable(name, value)
68}
69
70/**
71* Gets the current value of a variable from the binding.
72* @param name The name of the variable.
73* @return The value of the variable, or null if not found.
74*/
75Object getVariable(String name) {
76return binding.getVariable(name)
77}
78
79/**
80* Main method for demonstration.
81*/
82static void main(String[] args) {
83// Initialize with some global variables
84Map<String, Object> initialGlobals = [
85"appName": "MyDynamicApp",
86"version": 1.5
87]
88DynamicScriptExecutor executor = new DynamicScriptExecutor(initialGlobals)
89
90// Script 1: Simple script with print statements
91String script1 = """
92println "Running script 1 for app: ${appName}"
93def message = "Hello from dynamic script!"
94println message
95message
96"""
97Map<String, Object> result1 = executor.executeScript(script1)
98println "--- Script 1 Results ---"
99println "Output:\n${result1.output}"
100println "Result: ${result1.result}"
101println "------------------------\n"
102
103// Script 2: Script with an error
104String script2 = """
105println "Running script 2 with an error..."
106def x = 10 / 0 // Division by zero
107x
108"""
109Map<String, Object> result2 = executor.executeScript(script2)
110println "--- Script 2 Results ---"
111println "Output:\n${result2.output}"
112println "Result: ${result2.result}"
113println "------------------------\n"
114
115// Script 3: Script that uses a dynamically set variable
116executor.setVariable("dynamicVar", "This is dynamic!")
117String script3 = """
118println "Script 3 using dynamicVar: ${dynamicVar}"
119dynamicVar.length()
120"""
121Map<String, Object> result3 = executor.executeScript(script3)
122println "--- Script 3 Results ---"
123println "Output:\n${result3.output}"
124println "Result: ${result3.result}"
125println "------------------------\n"
126
127// Script 4: Empty script test
128String script4 = ""
129Map<String, Object> result4 = executor.executeScript(script4)
130println "--- Script 4 Results ---"
131println "Output:\n${result4?.output ?: 'N/A'}"
132println "Result: ${result4?.result ?: 'N/A'}"
133println "------------------------\n"
134}
135}

Algorithm description viewbox

Dynamic Groovy Script Executor

Algorithm description:

This Groovy class, `DynamicScriptExecutor`, allows for the execution of arbitrary Groovy code provided as strings. It leverages Groovy's `GroovyShell` and `Binding` classes to manage the execution environment and variables. The system captures standard output from the executed scripts and also returns the script's final evaluated result. It includes robust error handling for exceptions during script execution and handles null or empty script inputs gracefully.

Algorithm explanation:

The `DynamicScriptExecutor` class initializes a `GroovyShell` with a `Binding` object. This `Binding` can be pre-populated with global variables accessible to any script executed. The `executeScript` method takes a script string, redirects `System.out` to a `ByteArrayOutputStream` to capture printed output, and then uses `shell.evaluate(script)` to run the code. Any exceptions thrown during evaluation are caught, their messages and stack traces are printed to the captured output stream, and `System.out` is restored. The method returns a map containing the captured `output` and the script's `result`. The `setVariable` and `getVariable` methods allow for dynamic manipulation of the script's execution context. The time complexity depends heavily on the complexity of the executed script, but the overhead of the executor itself is minimal. Space complexity is primarily determined by the size of the captured output and the complexity of the script's internal state.

Pseudocode:

CLASS DynamicScriptExecutor:
  shell = GroovyShell instance
  binding = Binding instance

  CONSTRUCTOR(globalVariables):
    binding = new Binding()
    FOR EACH key, value IN globalVariables:
      binding.setVariable(key, value)
    END FOR
    shell = new GroovyShell(binding)
  END CONSTRUCTOR

  FUNCTION executeScript(script):
    IF script is null OR empty THEN
      PRINT "Warning: Script is null or empty."
      RETURN null
    END IF

    // Capture stdout
    baos = new ByteArrayOutputStream()
    ps = new PrintStream(baos)
    originalOut = System.out
    System.setOut(ps)

    result = null
    TRY:
      result = shell.evaluate(script)
    CATCH Exception e:
      PRINT "Error executing script: ${e.getMessage()}"
      e.printStackTrace(ps)
    FINALLY:
      System.out = originalOut
      ps.close()
    END TRY

    output = baos.toString()
    executionResult = new map
    executionResult["output"] = output
    executionResult["result"] = result

    RETURN executionResult
  END FUNCTION

  FUNCTION setVariable(name, value):
    binding.setVariable(name, value)
  END FUNCTION

  FUNCTION getVariable(name):
    RETURN binding.getVariable(name)
  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)