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.json.JsonSlurper
2import groovy.json.JsonOutput
3import java.util.Map
4import java.util.List
5import java.util.HashMap
6import java.util.ArrayList
7
8class JsonTransformer {
9
10/**
11* Transforms a source JSON object into a target JSON object based on a mapping configuration.
12* Handles nested objects, arrays, conditional mapping, and type conversions.
13*
14* @param sourceJson The source JSON object (as a Map).
15* @param mappingConfig The configuration defining how to transform the source to the target.
16*                      Format: Map<String, Object> where values can be:
17*                      - String: Target field name, value is copied directly.
18*                      - Map: Nested mapping configuration for nested objects.
19*                      - List: Defines transformation for array elements.
20*                      - Closure: Custom transformation logic.
21* @return The transformed JSON object (as a Map).
22*/
23public Map<String, Object> transform(Map<String, Object> sourceJson, Map<String, Object> mappingConfig) {
24if (sourceJson == null || mappingConfig == null) {
25throw new IllegalArgumentException("Source JSON and mapping configuration cannot be null.")
26}
27return transformRecursive(sourceJson, mappingConfig)
28}
29
30private Map<String, Object> transformRecursive(Map<String, Object> source, Map<String, Object> config) {
31Map<String, Object> target = new HashMap<>()
32
33for (Map.Entry<String, Object> entry : config.entrySet()) {
34String targetKey = entry.getKey()
35Object configValue = entry.getValue()
36
37if (configValue instanceof String) { // Direct mapping or renaming
38String sourceKey = (String) configValue
39if (source.containsKey(sourceKey)) {
40target.put(targetKey, source.get(sourceKey))
41} else {
42// Handle missing source field - could log a warning or throw error
43println "Warning: Source field '${sourceKey}' not found for target key '${targetKey}'."
44}
45} else if (configValue instanceof Map) { // Nested object mapping
46Map<String, Object> nestedSource = (Map<String, Object>) source.get(targetKey) // Assume source key matches target key for nested
47if (nestedSource == null) {
48// If nested source is missing, create an empty target nested object or skip
49println "Warning: Nested source object for key '${targetKey}' not found. Creating empty target object."
50target.put(targetKey, new HashMap<String, Object>()) // Or skip if preferred
51} else {
52target.put(targetKey, transformRecursive(nestedSource, (Map<String, Object>) configValue))
53}
54} else if (configValue instanceof List) { // Array mapping
55// Assumes the list in config defines how to transform each element of a source array.
56// The source key is assumed to be the targetKey.
57Object sourceArrayObj = source.get(targetKey)
58if (sourceArrayObj instanceof List) {
59List<Object> sourceArray = (List<Object>) sourceArrayObj
60List<Object> transformedArray = new ArrayList<>()
61Map<String, Object> elementConfig = configValue.get(0) instanceof Map ? (Map<String, Object>) configValue.get(0) : null // Assuming first element defines element transformation
62
63if (elementConfig != null) {
64for (Object item : sourceArray) {
65if (item instanceof Map) {
66transformedArray.add(transformRecursive((Map<String, Object>) item, elementConfig))
67} else {
68// Handle non-map items in source array if needed
69transformedArray.add(item) // Copy as-is or handle error
70}
71}
72target.put(targetKey, transformedArray)
73} else {
74// If config list doesn't define element transformation, copy array as-is or error
75println "Warning: Array transformation config missing for key '${targetKey}'. Copying array as-is."
76target.put(targetKey, sourceArray)
77}
78} else {
79// Source is not an array where an array was expected
80println "Warning: Expected an array for key '${targetKey}' in source, but found: ${sourceArrayObj.getClass().getName()}."
81}
82} else if (configValue instanceof Closure) { // Custom transformation using Closure
83Closure customTransform = (Closure) configValue
84// The closure receives the source JSON and the target JSON being built
85// It can modify the target directly or return a value to be put into the target
86Object result = customTransform.call(source, target)
87if (result != null) {
88// If closure returns a value, it might be for a specific field or the whole target
89// This simple example assumes it might return a value for the current targetKey
90// A more complex system would define how closures interact with target keys.
91// For now, we'll assume the closure modifies 'target' directly or returns a value for 'targetKey'
92// If the closure returns a Map, it could be assigned to targetKey
93if (result instanceof Map) {
94target.put(targetKey, result)
95} else {
96// If closure returns a primitive or other object, and targetKey is specified
97// This part is tricky and depends on closure design.
98// For simplicity, if closure returns a non-Map, we might ignore it or assign it if targetKey is explicit.
99// Let's assume for now the closure modifies 'target' directly.
100}
101}
102} else {
103// Handle other types or unsupported configurations
104println "Warning: Unsupported configuration type for key '${targetKey}': ${configValue.getClass().getName()}"
105}
106}
107return target
108}
109
110public static void main(String[] args) {
111JsonTransformer transformer = new JsonTransformer()
112
113// --- Example 1: Basic field mapping and renaming ---
114Map<String, Object> source1 = [
115'userId': 123,
116'userName': 'Alice',
117'emailAddress': 'alice@example.com'
118]
119Map<String, Object> config1 = [
120'id': 'userId',
121'name': 'userName',
122'contactEmail': 'emailAddress'
123]
124Map<String, Object> transformed1 = transformer.transform(source1, config1)
125println "Transformed 1: ${JsonOutput.toJson(transformed1)}"
126// Expected: {"id":123,"name":"Alice","contactEmail":"alice@example.com"}
127
128// --- Example 2: Nested objects and array transformation ---
129Map<String, Object> source2 = [
130'orderId': 'ORD789',
131'customerInfo': [
132'firstName': 'Bob',
133'lastName': 'Smith',
134'address': [
135'street': '123 Main St',
136'city': 'Anytown'
137]
138],
139'items': [
140[
141'productId': 'P101',
142'productName': 'Gadget',
143'quantity': 2,
144'price': 19.99
145],
146[
147'productId': 'P102',
148'productName': 'Widget',
149'quantity': 1,
150'price': 29.99
151]
152]
153]
154Map<String, Object> config2 = [
155'orderReference': 'orderId',
156'customer': [
157'firstName': 'firstName',
158'lastName': 'lastName',
159'location': [
160'street': 'street',
161'city': 'city'
162]
163],
164'products': [ [
165'sku': 'productId',
166'name': 'productName',
167'qty': 'quantity',
168'unitPrice': 'price'
169] ]
170]
171Map<String, Object> transformed2 = transformer.transform(source2, config2)
172println "Transformed 2: ${JsonOutput.toJson(transformed2)}"
173// Expected: {"orderReference":"ORD789","customer":{"firstName":"Bob","lastName":"Smith","location":{"street":"123 Main St","city":"Anytown"}},"products":[{"sku":"P101","name":"Gadget","qty":2,"unitPrice":19.99},{"sku":"P102","name":"Widget","qty":1,"unitPrice":29.99}]}
174
175// --- Example 3: Conditional mapping using Closure ---
176Map<String, Object> source3 = [
177'status': 'ACTIVE',
178'isActive': true,
179'value': 100,
180'secondaryValue': 50
181]
182Map<String, Object> config3 = [
183'currentStatus': 'status',
184'displayValue': { source, target ->
185// Custom logic: if status is ACTIVE, use 'value', otherwise use 'secondaryValue'
186if (source.get('status') == 'ACTIVE' && source.get('isActive')) {
187target.put('displayValue', source.get('value'))
188} else {
189target.put('displayValue', source.get('secondaryValue'))
190}
191}
192]
193Map<String, Object> transformed3 = transformer.transform(source3, config3)
194println "Transformed 3: ${JsonOutput.toJson(transformed3)}"
195// Expected: {"currentStatus":"ACTIVE","displayValue":100}
196
197// --- Example 4: Handling missing source fields and arrays ---
198Map<String, Object> source4 = [
199'id': 'XYZ',
200'details': [
201'tags': ['A', 'B'] // Missing 'name' for tags
202]
203]
204Map<String, Object> config4 = [
205'reference': 'id',
206'nested': [
207'tags': [ [
208'name': 'tag',
209'value': 'value'
210] ]
211]
212]
213Map<String, Object> transformed4 = transformer.transform(source4, config4)
214println "Transformed 4: ${JsonOutput.toJson(transformed4)}"
215// Expected: {"reference":"XYZ","nested":{"tags":[{},{}]}} (with warnings about missing fields)
216
217// --- Example 5: Empty source and config ---
218try {
219transformer.transform(null, config1)
220} catch (e) {
221println "Exception 5a: ${e.getMessage()}" // Expected: Source JSON and mapping configuration cannot be null.
222}
223try {
224transformer.transform(source1, null)
225} catch (e) {
226println "Exception 5b: ${e.getMessage()}" // Expected: Source JSON and mapping configuration cannot be null.
227}
228Map<String, Object> emptySource = [:]
229Map<String, Object> emptyConfig = [:]
230Map<String, Object> transformed5 = transformer.transform(emptySource, emptyConfig)
231println "Transformed 5 (empty): ${JsonOutput.toJson(transformed5)}" // Expected: {}
232}
233}

Algorithm description viewbox

REST Client Layer: JSON Payload Transformation

Algorithm description:

This Groovy code provides a flexible JSON transformation utility for REST client layers. It allows mapping fields from a source JSON to a target JSON based on a configuration map. The transformer supports direct field renaming, nested object mapping, array element transformation, and custom transformations using Groovy closures. It also includes basic error handling for missing fields and invalid inputs, making it robust for preparing data for API requests.

Algorithm explanation:

The `JsonTransformer` class uses a recursive approach to map JSON structures. The `transform` method initializes the process, and `transformRecursive` handles the core logic. It iterates through the `mappingConfig`. If a value is a string, it's treated as a source key to copy. If it's a map, it recursively calls `transformRecursive` for nested objects. If it's a list, it assumes the first element defines the transformation for array items and iterates through the source array. If it's a closure, it executes the custom logic. The algorithm handles missing source fields by issuing warnings. The time complexity is roughly O(N * M), where N is the number of elements in the source JSON and M is the complexity of the mapping configuration, as each relevant field and structure is visited. Space complexity is O(D), where D is the depth of the nested JSON structures and mapping configuration, due to recursion and the creation of the new target map. Edge cases include null inputs, missing source fields, non-array types where arrays are expected, and unsupported configuration types.

Pseudocode:

function transform(sourceJson, mappingConfig):
  if sourceJson is null or mappingConfig is null:
    throw IllegalArgumentException
  return transformRecursive(sourceJson, mappingConfig)

function transformRecursive(source, config):
  target = new empty map
  for each targetKey, configValue in config:
    if configValue is a string (sourceKey):
      if source contains sourceKey:
        target[targetKey] = source[sourceKey]
      else:
        print warning 'Missing source field'
    else if configValue is a map (nestedConfig):
      nestedSource = source[targetKey] // Assume source key matches target key
      if nestedSource is null or not a map:
        print warning 'Missing or invalid nested source'
        target[targetKey] = new empty map // or skip
      else:
        target[targetKey] = transformRecursive(nestedSource, nestedConfig)
    else if configValue is a list (arrayConfig):
      sourceArrayObj = source[targetKey]
      if sourceArrayObj is a list:
        sourceArray = sourceArrayObj
        transformedArray = new empty list
        elementConfig = arrayConfig[0] // Assuming first element defines element transformation
        if elementConfig is a map:
          for each item in sourceArray:
            if item is a map:
              transformedArray.add(transformRecursive(item, elementConfig))
            else:
              transformedArray.add(item) // copy as-is
          target[targetKey] = transformedArray
        else:
          print warning 'Array config missing'
          target[targetKey] = sourceArray // copy as-is
      else:
        print warning 'Expected array, found different type'
    else if configValue is a closure:
      // Execute closure, assuming it modifies 'target' or returns a value for targetKey
      result = closure.call(source, target)
      if result is a map and targetKey is defined:
        target[targetKey] = result
    else:
      print warning 'Unsupported config type'
  return target

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)