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# N-Queens problem solver using backtracking
4# Goal: Place N queens on an NxN chessboard such that no two queens threaten each other.
5
6# Global variable to store the board configuration
7# board[row]=col means a queen is at (row, col)
8board=()
9
10# Function to check if placing a queen at (row, col) is safe
11# Args: row, col
12# Returns: 0 if safe, 1 if not safe
13is_safe() {
14local row=$1
15local col=$2
16
17# Check this row on left side (not needed as we place one queen per row)
18# Check upper diagonal on left side
19for (( i=0, j=col; i<row && j>=0; i++, j-- )); do
20if [[ ${board[i]} -eq $j ]]; then
21return 1 # Conflict
22fi
23done
24
25# Check lower diagonal on left side
26for (( i=0, j=col; i<row && j<N; i++, j++ )); do
27if [[ ${board[i]} -eq $j ]]; then
28return 1 # Conflict
29fi
30done
31
32# Check this column on upper side
33for (( i=0; i<row; i++ )); do
34if [[ ${board[i]} -eq $col ]]; then
35return 1 # Conflict
36fi
37done
38
39return 0 # Safe
40}
41
42# Recursive function to solve N-Queens problem
43# Args: current row to place a queen
44# Returns: 0 if a solution is found, 1 otherwise
45solve_nqueens_util() {
46local row=$1
47
48# Base case: If all queens are placed, print the solution
49if [[ $row -eq N ]]; then
50print_solution
51return 0 # Found a solution
52fi
53
54# Consider this row and try placing this queen in all columns one by one
55for (( col=0; col<N; col++ )); do
56# Check if the queen can be placed on board[row][col]
57if is_safe $row $col;
58then
59# Place this queen in board[row][col]
60board[$row]=$col
61
62# Recur to place rest of the queens
63if [[ $(solve_nqueens_util $((row + 1))) -eq 0 ]]; then
64return 0 # Solution found
65fi
66
67# If placing queen in board[row][col] doesn't lead to a solution,
68# then remove queen from board[row][col] (backtrack)
69# No explicit removal needed as board[$row] will be overwritten in next iteration or call
70fi
71done
72
73# If the queen cannot be placed in any column in this row, return false
74return 1
75}
76
77# Function to print the board configuration
78print_solution() {
79echo "Solution found:"
80for (( i=0; i<N; i++ )); do
81local line=""
82for (( j=0; j<N; j++ )); do
83if [[ ${board[i]} -eq $j ]]; then
84line+="Q "
85else
86line+=". "
87fi
88done
89echo "$line"
90done
91echo ""
92}
93
94# Main function to solve N-Queens
95# Args: N (size of the board)
96main_nqueens() {
97N=$1
98
99# Initialize board
100for (( i=0; i<N; i++ )); do
101board[$i]=-1 # -1 indicates no queen placed yet
102done
103
104# Call the recursive helper function to solve the problem
105if [[ $(solve_nqueens_util 0) -eq 0 ]]; then
106echo "Successfully found all solutions for N=$N."
107else
108echo "No solution exists for N=$N."
109fi
110}
111
112# Example usage:
113# main_nqueens 4

Algorithm description viewbox

Bash N-Queens Solver (Backtracking)

Algorithm description:

This Bash script implements a backtracking algorithm to solve the N-Queens problem. The goal is to place N chess queens on an NxN chessboard such that no two queens threaten each other. The script uses a recursive function `solve_nqueens_util` to explore possible placements, and `is_safe` to check for conflicts. This is a classic example of a combinatorial problem solved efficiently with recursion and backtracking, applicable in areas like constraint satisfaction and puzzle solving.

Algorithm explanation:

The N-Queens problem is solved using a recursive backtracking approach. The `solve_nqueens_util` function attempts to place a queen in each row, starting from row 0. For each row, it iterates through all columns. Before placing a queen, `is_safe` is called to check if the proposed position `(row, col)` is under attack by any previously placed queens. `is_safe` checks for conflicts in the same column and both diagonals. If a position is safe, the queen is placed (by storing the column index in the `board` array for that row), and the function recursively calls itself for the next row. If the recursive call returns successfully (meaning a solution was found down that path), the current function also returns success. If placing a queen in a column doesn't lead to a solution, the algorithm backtracks by implicitly undoing the placement (the `board` entry will be overwritten in the next iteration or recursive call) and trying the next column. The base case for the recursion is when all N queens have been successfully placed (i.e., `row == N`). The time complexity is roughly O(N!), as in the worst case, it explores many branches of the search tree. The space complexity is O(N) for the recursion stack and the board representation. The invariant is that at any point, the queens placed in rows `0` to `row-1` are in a valid, non-attacking configuration.

Pseudocode:

function solve_nqueens(N):
  initialize empty board of size NxN
  call solve_nqueens_util(0)

function solve_nqueens_util(row):
  if row == N:
    print solution
    return success
  
  for col from 0 to N-1:
    if is_safe(row, col):
      place queen at (row, col)
      if solve_nqueens_util(row + 1) is success:
        return success
      remove queen from (row, col) (backtrack)
  
  return failure

function is_safe(row, col):
  check column for conflicts
  check upper-left diagonal for conflicts
  check lower-left diagonal for conflicts
  return true if safe, false otherwise

function print_solution():
  display the board with queens

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)