Practice Code Typing – SkillsTyping

Choose your language:

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

Choose Exercise:

Ready

Exercise Algorithm Area

Correct typos to continue.

1#!/bin/bash
2
3# Function to generate permutations recursively
4# Args: current_permutation, remaining_chars, used_indices_map
5permute_recursive() {
6local current_permutation="$1"
7local remaining_chars="$2"
8local used_indices_map="$3"
9local original_string="$4"
10local result_array_ref="$5"
11
12# Base case: if no characters are remaining, we have a complete permutation
13if [[ -z "$remaining_chars" ]]; then
14# Add the permutation to the result array
15eval "$result_array_ref+=('$current_permutation')"
16return
17fi
18
19# Iterate through each character in the remaining characters
20local i
21for ((i=0; i<${#remaining_chars}; i++)); do
22local char_to_add="${remaining_chars:$i:1}"
23local next_remaining_chars="${remaining_chars:0:$i}${remaining_chars:$((i+1))}"
24
25# Check if this character has already been used at this level of recursion
26# This is crucial for handling duplicate characters efficiently
27local already_used_at_level=0
28local j
29for ((j=0; j<i; j++)); do
30if [[ "${remaining_chars:$j:1}" == "$char_to_add" ]]; then
31already_used_at_level=1
32break
33fi
34done
35
36if [[ $already_used_at_level -eq 0 ]]; then
37# Recursively call permute_recursive with the updated permutation and remaining characters
38permute_recursive "$current_permutation$char_to_add" "$next_remaining_chars" "$used_indices_map" "$original_string" "$result_array_ref"
39fi
40done
41}
42
43# Helper function to sort a string alphabetically
44sort_string() {
45local str="$1"
46echo "$str" | grep -o . | sort | tr -d '\n'
47}
48
49# Main function to initiate permutation generation
50# Args: input_string
51main() {
52local input_string="$1"
53local permutations=()
54
55# Handle empty string edge case
56if [[ -z "$input_string" ]]; then
57echo ""
58return
59fi
60
61# Sort the input string to handle duplicates easily in the recursive step
62local sorted_input="$(sort_string "$input_string")"
63
64# Call the recursive permutation function
65permute_recursive "" "$sorted_input" "" "$sorted_input" "permutations[@]"
66
67# Remove duplicates from the generated permutations (though the logic should prevent them)
68# and print each unique permutation
69local unique_permutations=$(printf "%s\n" "${permutations[@]}" | sort -u)
70echo "$unique_permutations"
71}
72
73# Example usage:
74# main "abc"
75# main "aab"
76# main ""
77# main "abcd"

Algorithm description viewbox

Bash Script: Advanced String Permutation Generator

Algorithm description:

This Bash script generates all unique permutations of a given input string using a recursive backtracking algorithm. It efficiently handles strings with duplicate characters by sorting the input and skipping redundant recursive calls. This is useful in scenarios like generating all possible orderings for tasks, password cracking simulations, or combinatorial problem-solving where exploring all arrangements is necessary.

Algorithm explanation:

The script employs a recursive backtracking approach to generate permutations. The `permute_recursive` function takes the current partial permutation, the remaining characters to be used, and a map of used indices. The base case is when `remaining_chars` is empty, signifying a complete permutation. In the recursive step, it iterates through each character in `remaining_chars`. To handle duplicates, it checks if a character has already been considered at the current recursion level. If not, it appends the character to `current_permutation`, removes it from `remaining_chars`, and makes a recursive call. The `sort_string` helper ensures that identical characters are adjacent, simplifying the duplicate check. The time complexity is roughly O(N! * N) due to generating N! permutations, each taking O(N) to construct and process. Space complexity is O(N!) to store the permutations and O(N) for the recursion depth. Edge cases like empty strings are handled. The invariant is that `current_permutation` always represents a valid prefix of a permutation, and `remaining_chars` contains the characters yet to be placed.

Pseudocode:

function permute_recursive(current_permutation, remaining_chars):
  if remaining_chars is empty:
    add current_permutation to results
    return

  for each character `char` at index `i` in remaining_chars:
    if `char` has not been used at this level (check against previous chars in remaining_chars):
      next_remaining_chars = remaining_chars without `char` at index `i`
      permute_recursive(current_permutation + `char`, next_remaining_chars)

function main(input_string):
  if input_string is empty:
    return empty list

  sorted_input = sort(input_string) alphabetically
  call permute_recursive("", sorted_input)
  return unique elements from results

Library

Playable exercises

Choose Exercise

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

Total 28 published items

Pages 4 pages available

Language

Sort by Direction

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

Published

Bash DevOps (bash)

Bash Factorial Calculation

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

#math #bash scripting #loops #factorial

goal: Calculate the factorial of a non-negative integer. input: A non-negative integer. output: The factorial of the input integer.

Canonical Algorithm Text

#!/bin/bash # Function to calculate factorial calculate_factorial() { local n="$1" local result=1 # Base case: factorial of 0 is 1 if [ "$n" -eq 0 ]; then echo "1" return fi # Calculate factorial using a loop for (( i=1; i<=n; i++ )); do result=$((result * i)) done echo "$result"...

Description Algorithm

This Bash script defines a function `calculate_factorial` that computes the factorial of a given non-negative integer. The factorial of a non-negative integer n is the product of all positive integers less than or equal...

Explanation

The `calculate_factorial` function computes n! (n factorial). It initializes `result` to 1. The base case, where `n` is 0, is handled by returning 1, as 0! is defined as 1. For positive integers, a `for` loop iterates from 1 up to `n`. In each iteration, `result` is multiplied by the current loop variable `i`. This process accumulates the product of all numbers from 1 to `n`. The time complexity is O(n) because the loop runs `n` times. The space complexity is O(1) as it uses a constant amount of extra space for variables. The loop boundaries are essential for correct calculation, ensuring all numbers from 1 to `n` are included in the product.

Pseudocode

function calculate_factorial(n): if n is 0: return 1 result = 1 for i from 1 to n: result = result * i return result

Published

Bash DevOps (bash)

Bash Array Element Search

Difficulty: writing: 5; length: 2
Popularity: 0
Created: 2026-01-28 14:56 UTC
Published: 2026-01-28 15:17 UTC
Author: Damian

#array search #bash scripting #linear search #indexing

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

Canonical Algorithm Text

#!/bin/bash # Function to find the index of an element in an array find_element_index() { local target_element="$1" shift # Remove the target element from arguments local array=($@) # Remaining arguments form the array local len=${#array[@]} local found_index=-1 # Handle empty ar...

Description Algorithm

This Bash script provides a function `find_element_index` that searches for a given element within an array and returns its first occurrence's index. If the element is not present in the array, it returns -1. This is a c...

Explanation

The `find_element_index` function searches for a `target_element` within a Bash array. It first captures the `target_element` and then uses `shift` to make the remaining arguments available as the `array`. It handles the edge case of an empty array by returning -1. The function iterates through the array using a `for` loop from index 0 up to `len-1`. Inside the loop, it compares the current array element `${array[$i]}` with the `target_element`. If a match is found, `found_index` is set to the current index `i`, and the loop is terminated using `break`. If the loop completes without finding the element, `found_index` remains -1. The time complexity is O(n) in the worst case (element not found or at the end), where n is the number of elements in the array, as it may need to check every element. The space complexity is O(1) as it only uses a few variables to store state. The loop boundaries are critical to ensure all elements are checked.

Pseudocode

function find_element_index(target_element, array): if array is empty: return -1 found_index = -1 for i from 0 to length of array - 1: if array[i] equals target_element: found_index = i break return found_index

Published

Bash DevOps (bash)

Bash Binary Search on Sorted Array

Difficulty: writing: 9; length: 3
Popularity: 0
Created: 2026-01-28 14:56 UTC
Published: 2026-01-28 15:17 UTC
Author: Damian

#search algorithms #bash scripting #divide and conquer #sorted arrays #logarithmic time

goal: Perform binary search on a sorted array. input: A target integer and a sorted array of integers. output: The index of the target integer, or -1 if not found.

Canonical Algorithm Text

#!/bin/bash # Function to perform binary search on a sorted array binary_search() { local target="$1" shift local sorted_array=($@) local n=${#sorted_array[@]} local low=0 local high=$((n - 1)) local mid # Edge case: empty array if [ "$n" -eq 0 ]; then echo "-1" return fi # Loop...

Description Algorithm

This Bash script implements the binary search algorithm to efficiently find the index of a target integer within a sorted array. It repeatedly divides the search interval in half. If the value of the search key is less t...

Explanation

The `binary_search` function finds the index of a `target` integer in a `sorted_array`. It initializes `low` to 0 and `high` to the last index of the array. The primary loop invariant is that if the `target` exists in the array, it must be located within the subarray `sorted_array[low..high]`. The loop continues as long as `low` is less than or equal to `high`. In each iteration, `mid` is calculated to avoid potential integer overflow. The element at `mid` is compared to the `target`. If they match, `mid` 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), where n is the number of elements in the array, due to the halving of the search space in each step. The space complexity is O(1) as it uses a fixed number of variables. Edge cases like an empty array and the target being at the boundaries are handled by the loop conditions and pointer updates.

Pseudocode

function binary_search(target, sorted_array): low = 0 high = length of sorted_array - 1 while low <= high: mid = low + (high - low) / 2 if sorted_array[mid] == target: return mid else if sorted_array[mid] < target: low =...

Published

Bash DevOps (bash)

Bash String Reversal

Difficulty: writing: 3; length: 1
Popularity: 0
Created: 2026-01-28 14:56 UTC
Published: 2026-01-28 15:17 UTC
Author: Damian

#string manipulation #bash scripting #looping #algorithms

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

Canonical Algorithm Text

#!/bin/bash # Function to reverse a string reverse_string() { local input_string="$1" local reversed_string="" local len=${#input_string} # Handle empty string edge case if [ "$len" -eq 0 ]; then echo "" return fi # Iterate from the last character to the first for (( i=$len-1; i>...

Description Algorithm

This Bash script defines a function `reverse_string` that takes a single string argument and returns its reversed version. It iterates through the input string from the last character to the first, appending each charact...

Explanation

The `reverse_string` function reverses a given string. It initializes an empty `reversed_string` and gets the length of the `input_string`. An edge case for an empty string is handled by returning an empty string immediately. The core logic uses a `for` loop that iterates backward from the last index (`len-1`) down to 0. In each iteration, it extracts a single character from the `input_string` at the current index `i` using substring expansion `${input_string:$i:1}` and appends it to `reversed_string`. 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) to store the reversed string. The loop boundaries are crucial for correctness, ensuring all characters are included and in the correct order.

Pseudocode

function reverse_string(input_string): if input_string is empty: return empty string reversed_string = "" length = length of input_string for i from length - 1 down to 0: append character at index i of input_string to re...

Published

Bash DevOps (bash)

Bash Array Element Count

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

#array processing #bash scripting #counting #data structures #element search

goal: Count occurrences of an element in a Bash array. input: An element to count and a Bash array. output: The number of times the element appears in the array.

Canonical Algorithm Text

function count_element_in_array() { local -a arr=() # Declare arr as an array local element_to_count="$1" shift # Remove the first argument (element_to_count) from $@ arr=($@) # Assign remaining arguments to the array local count=0 local arr_len=${#arr[@]} # Handle empty array ed...

Description Algorithm

This Bash script provides a function to count how many times a specific element appears within an array. It iterates through each element of the provided array and increments a counter if the element matches the target....

Explanation

The `count_element_in_array` function accepts the element to count as the first argument, followed by the array elements themselves. It first creates a local array `arr` from the subsequent arguments. A counter `count` is initialized to zero. An edge case for an empty array is handled by returning 0. The script then iterates through each `element` in the `arr`. Inside the loop, it compares the current `element` with `element_to_count`. If they match, the `count` is incremented. Finally, the total `count` is echoed. The time complexity is O(n), where n is the number of elements in the array, as each element is examined once. The space complexity is O(1) (excluding the input array storage) as only a few variables are used. The correctness relies on the exhaustive iteration and accurate comparison of each array element.

Pseudocode

function count_element_in_array(element_to_find, array): initialize count to 0 if array is empty: return 0 for each element in array: if element equals element_to_find: increment count return count

Published

Bash DevOps (bash)

Bash Fibonacci Sequence Generator

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

#sequences #bash scripting #loops #dynamic programming #iterative algorithms

goal: Generate the first N Fibonacci numbers. input: A positive integer N. output: The first N Fibonacci numbers, space-separated.

Canonical Algorithm Text

function generate_fibonacci() { local n=$1 local a=0 local b=1 local temp # Handle invalid input (non-positive N) if [ "$n" -le 0 ]; then echo "Please provide a positive integer for N." return 1 fi # Handle the first few cases explicitly if [ "$n" -ge 1 ]; then echo -n "$a " fi i...

Description Algorithm

This Bash script generates the first N numbers of the Fibonacci sequence. The Fibonacci sequence starts with 0 and 1, and each subsequent number is the sum of the two preceding ones (e.g., 0, 1, 1, 2, 3, 5, 8...). This s...

Explanation

The `generate_fibonacci` function takes an integer `n` representing the number of Fibonacci terms to generate. It initializes two variables, `a` to 0 and `b` to 1, which are the first two numbers in the sequence. An edge case for `n` less than or equal to 0 is handled by printing an error. The first two terms (0 and 1) are printed if `n` is at least 1 and 2, respectively. A `for` loop then iterates from the 3rd term up to `n`. In each iteration, the next Fibonacci number `temp` is calculated as the sum of `a` and `b`. `temp` is printed, and then `a` and `b` are updated for the next iteration (`a` becomes the old `b`, and `b` becomes `temp`). The time complexity is O(n) because the loop runs `n-2` times. The space complexity is O(1) as it only uses a few variables to store the current and previous numbers. The invariant is that `a` and `b` always hold the two most recent Fibonacci numbers needed to compute the next one.

Pseudocode

function generate_fibonacci(n): if n <= 0: print error message return initialize a = 0, b = 1 if n >= 1: print a if n >= 2: print b loop from i = 3 to n: calculate temp = a + b print temp update a = b update b = temp

Published

Bash DevOps (bash)

Bash String Reversal

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

#string manipulation #bash scripting #loops #algorithms #text processing

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

Canonical Algorithm Text

function reverse_string() { local input_string="$1" local reversed_string="" local len=${#input_string} # Handle empty string edge case if [ "$len" -eq 0 ]; then echo "" return fi # Iterate from the last character to the first for (( i=$len-1; i>=0; i-- )); do reversed_string+="$...

Description Algorithm

This Bash script defines a function to reverse a given string. It iterates through the input string from the last character to the first, appending each character to a new string. This is a common string manipulation tas...

Explanation

The `reverse_string` function takes a single argument, the string to be reversed. It initializes an empty string `reversed_string` and determines the length of the input string. An edge case for an empty input string is handled by returning an empty string immediately. The core logic uses a `for` loop that starts from the index of the last character (`len-1`) and decrements down to 0. In each iteration, it extracts a single character from the input string using substring expansion (`${input_string:$i:1}`) and appends it to `reversed_string`. 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 reversed string. The invariant maintained is that `reversed_string` always holds the reversed portion of the string processed so far.

Pseudocode

function reverse_string(input): initialize reversed_string as empty string get length of input if length is 0: return empty string loop from index length-1 down to 0: append character at current index from input to rever...

Published

Bash DevOps (bash)

Bash Factorial Calculation

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

#mathematics #bash scripting #loops #recursion #integer arithmetic

goal: Calculate the factorial of a non-negative integer. input: A non-negative integer. output: The factorial of the input integer.

Canonical Algorithm Text

function factorial() { local n=$1 local result=1 # Handle negative input edge case if [ "$n" -lt 0 ]; then echo "Factorial is not defined for negative numbers." return 1 fi # Handle base case for 0! if [ "$n" -eq 0 ]; then echo 1 return 0 fi # Calculate factorial using a loop for...

Description Algorithm

This Bash script calculates the factorial of a non-negative integer. The factorial of a number n (denoted as n!) is the product of all positive integers less than or equal to n. This is a fundamental mathematical operati...

Explanation

The `factorial` function takes an integer `n` as input. It initializes `result` to 1. It first checks for invalid input: if `n` is negative, it prints an error message and returns 1. If `n` is 0, it returns 1, as 0! is defined as 1. For positive `n`, it uses a `for` loop that iterates from 1 up to `n`. In each iteration, `result` is multiplied by the current loop variable `i`. The time complexity is O(n) because the loop runs `n` times. The space complexity is O(1) as it only uses a few variables. The correctness is ensured by the iterative multiplication of all integers from 1 to `n`.

Pseudocode

function factorial(n): if n < 0: print error message return 1 if n == 0: return 1 initialize result to 1 loop from i = 1 to n: result = result * i return result

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)