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 find the longest common prefix among an array of strings.
4# Arguments: $@ - An array of strings.
5# Returns: The longest common prefix string.
6find_longest_common_prefix() {
7local strings=($@)
8local num_strings=${#strings[@]}
9
10# Edge case: If the array is empty, return an empty string.
11if [ "$num_strings" -eq 0 ]; then
12echo ""
13return
14fi
15
16# Edge case: If there's only one string, it's the prefix.
17if [ "$num_strings" -eq 1 ]; then
18echo "${strings[0]}"
19return
20fi
21
22# Initialize the prefix with the first string.
23local prefix="${strings[0]}"
24
25# Iterate through the rest of the strings.
26for ((i = 1; i < num_strings; i++)); do
27local current_string="${strings[$i]}"
28local current_prefix_len=${#prefix}
29local current_string_len=${#current_string}
30local j=0
31
32# Compare characters of the current prefix and the current string.
33while [ "$j" -lt "$current_prefix_len" ] && [ "$j" -lt "$current_string_len" ] && [ "${prefix:$j:1}" = "${current_string:$j:1}" ]; do
34j=$((j + 1))
35done
36
37# Update the prefix to the common part found.
38prefix="${prefix:0:$j}"
39
40# If the prefix becomes empty, we can stop early.
41if [ -z "$prefix" ]; then
42break
43fi
44done
45
46echo "$prefix"
47}
48
49# Example Usage:
50# declare -a my_strings=("flower" "flow" "flight")
51# echo "Longest common prefix: $(find_longest_common_prefix "${my_strings[@]}")"
52
53# declare -a another_set=("dog" "racecar" "car")
54# echo "Longest common prefix: $(find_longest_common_prefix "${another_set[@]}")"
55
56# declare -a single_string=("apple")
57# echo "Longest common prefix: $(find_longest_common_prefix "${single_string[@]}")"
58
59# declare -a empty_set=()
60# echo "Longest common prefix: $(find_longest_common_prefix "${empty_set[@]}")"

Algorithm description viewbox

Bash Script: Find Longest Common Prefix

Algorithm description:

This Bash script defines a function `find_longest_common_prefix` that takes an array of strings as input and returns the longest common prefix among them. It handles edge cases such as an empty input array or an array containing only one string. This is useful for tasks like organizing files with similar naming conventions or processing data where common prefixes indicate related entries.

Algorithm explanation:

The `find_longest_common_prefix` function works by initializing the potential prefix with the first string in the input array. It then iterates through the remaining strings, comparing each character of the current prefix with the corresponding character in the current string. The prefix is truncated whenever a mismatch is found or when the end of either string is reached. This process continues until all strings have been compared. If at any point the prefix becomes an empty string, the function terminates early, as no further common prefix can exist. The time complexity is O(S), where S is the sum of all characters in all strings, as each character might be compared at most once. The space complexity is O(1) because only a few variables are used to store intermediate results.

Pseudocode:

function find_longest_common_prefix(strings):
  if strings is empty:
    return ""
  if strings has one element:
    return the element

  prefix = first string in strings

  for each string from the second string onwards in strings:
    common_length = 0
    while common_length < length(prefix) AND common_length < length(current_string) AND prefix[common_length] == current_string[common_length]:
      increment common_length
    prefix = substring of prefix from start to common_length
    if prefix is empty:
      break

  return prefix

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)