Kindergarten Garden in Bash: Complete Solution & Deep Dive Guide

The Complete Guide to Solving the Kindergarten Garden Problem in Bash

Solving the Kindergarten Garden problem in Bash is a fantastic exercise in string manipulation and data mapping. It involves parsing a two-row plant diagram, mapping its sections to a sorted list of children, and translating plant codes (like G, C, R, V) into their full names using associative arrays for efficient lookups.

Have you ever stared at a raw string of text data, like a server log or a configuration file, and felt overwhelmed by the task of extracting meaningful, structured information? It's a common challenge for developers and system administrators. Bash, the default shell on most Linux and macOS systems, is an incredibly powerful tool for this, but its syntax for string and array manipulation can seem cryptic at first. This is where mastering practical examples becomes crucial.

This guide will walk you through a complete solution to the Kindergarten Garden problem, a classic challenge from the kodikra.com exclusive curriculum. We won't just give you the code; we'll dissect it line by line. You will emerge with a deep understanding of Bash arrays, associative arrays (hash maps), string slicing, and robust script structure—skills that are directly applicable to your daily automation and data processing tasks.

What is the Kindergarten Garden Problem?

At its core, the Kindergarten Garden problem is a data mapping challenge disguised as a charming story. The goal is to write a script that can determine which plants belong to a specific child based on a simple text-based diagram.

The Core Components

The problem provides three key pieces of information:

• A List of Children: There is a fixed, alphabetically sorted list of 12 children: Alice, Bob, Charlie, David, Eve, Fred, Ginny, Harriet, Ileana, Joseph, Kincaid, and Larry.
• A Set of Plants: There are four types of plants, each represented by a single character code:
  • G for Grass
  • C for Clover
  • R for Radishes
  • V for Violets
• The Garden Diagram: This is a two-line string representing two rows of window sill cups. Each child is responsible for two cups in the top row and two cups in the bottom row.

The Mapping Logic

The children are assigned plots in alphabetical order. Alice, being the first child, gets the first two cups in each row (at indices 0 and 1). Bob gets the next two cups in each row (indices 2 and 3), and so on. Each child is responsible for a total of four plants.

Consider this example diagram:

VRCGVVRVCGG
RVCCGCRVVCV

Let's break down the assignment for the first two children:

• Alice: She is the first child (index 0). She gets the cups at indices 0 and 1 from both rows.
  • Top row: VR (Violets, Radishes)
  • Bottom row: RV (Radishes, Violets)
  So, Alice's plants are Violets, Radishes, Radishes, and Violets.
• Bob: He is the second child (index 1). He gets the cups at indices 2 and 3 from both rows.
  • Top row: CG (Clover, Grass)
  • Bottom row: CC (Clover, Clover)
  So, Bob's plants are Clover, Grass, Clover, and Clover.

The script's job is to take the full diagram and a child's name as input and output the list of that child's four plants by their full names.

Why This Problem is a Perfect Bash Learning Tool

This seemingly simple problem is a trojan horse for learning fundamental Bash concepts that are essential for any serious scripter. It forces you to move beyond one-liners and think about data structures and program flow.

Here’s why it’s so effective:

• String Manipulation: You must parse the input diagram, which involves splitting a multi-line string and then slicing specific substrings based on calculated indices. This is a core skill for parsing log files or API responses.
• Indexed Arrays: The fixed list of students is perfectly represented by a standard indexed array. You'll learn how to declare, populate, and iterate over these arrays to get both values and their indices.
• Associative Arrays: Mapping plant codes ('V') to full names ("Violets") is the ideal use case for an associative array, which acts like a dictionary or hash map. Mastering these is key to creating efficient lookups in Bash.
• Function Design: A good solution will break the logic into smaller, reusable functions. This promotes clean, maintainable code—a best practice that is just as important in scripting as it is in application development.
• Handling Script Arguments: The script needs to accept the diagram and a student's name as command-line arguments ($1, $2), a fundamental aspect of creating flexible and reusable command-line tools.

By solving this, you build a mental model for tackling any task that involves transforming structured text data from one format to another, a cornerstone of automation and DevOps.

How to Solve the Kindergarten Garden Problem: A Step-by-Step Breakdown

We will now dissect a complete, well-structured Bash solution from the kodikra learning path. We will analyze the overall logic first, then dive deep into a line-by-line explanation of the code, and finally, explore potential optimizations.

The Overall Logic Flow

Before looking at the code, let's visualize the high-level plan our script will follow. The process can be broken down into a clear sequence of steps from input to output.

    ● Start Script
    │
    ▼
  ┌───────────────────────┐
  │ Receive Diagram & Name│
  │ (as command-line args)│
  └──────────┬────────────┘
             │
             ▼
  ┌───────────────────────┐
  │ Parse Diagram into    │
  │ two separate rows     │
  └──────────┬────────────┘
             │
             ▼
    ◆ Find Student's Index
   ╱ (e.g., Alice -> 0)
  │
  ▼
  ┌───────────────────────┐
  │ Calculate Plot Offset │
  │ (index * 2)           │
  └──────────┬────────────┘
             │
             ▼
  ┌───────────────────────┐
  │ Extract 4 Plant Codes │
  │ (2 from each row)     │
  └──────────┬────────────┘
             │
             ▼
  ┌───────────────────────┐
  │ Map Codes to Full Names│
  │ (e.g., 'V' -> "Violets")│
  └──────────┬────────────┘
             │
             ▼
    ● Output Plant List

This flow diagram illustrates a clear separation of concerns. We first handle inputs, then perform calculations and data extraction, and finally, format the output. This modular approach makes the code easier to write, debug, and understand.

The Complete Solution Code

Here is the full script we will be analyzing. It effectively implements the logic described above using functions and appropriate data structures.

#!/usr/bin/env bash

# This script is part of the exclusive kodikra.com learning curriculum.
# It solves the Kindergarten Garden problem by mapping a diagram to children's plants.

# Using shellcheck disable=SC2034 as 'plants' is used indirectly in the expand function.
# shellcheck disable=SC2034
declare -A plants=([G]=grass [C]=clover [R]=radishes [V]=violets)

# A fixed, indexed array of student names in alphabetical order.
students=(Alice Bob Charlie David Eve Fred Ginny Harriet Ileana Joseph Kincaid Larry)

# Create an associative array to map student names to their index for O(1) lookup.
declare -A studentIdx
for i in "${!students[@]}"; do
    studentIdx[${students[i]}]=$i
done

# Main function: orchestrates the script's execution.
# $1: The garden diagram (two lines separated by a newline).
# $2: The name of the student.
main() {
    # Using local -i ensures sidx is treated as an integer.
    local -i sidx
    sidx=${studentIdx[$2]}

    # The 'plots' array will hold the four plant codes for the student.
    local -a plots
    parse "$1" plots

    # The 'expand' function will print the full plant names.
    expand "${plots[sidx]}"
}

# Parses the full diagram string into an array of 4-character strings,
# one for each student.
# $1: The full diagram string.
# $2: The name of the array to populate (passed by reference).
parse() {
    local diagram=$1
    local -n plots_ref=$2 # Using nameref for pass-by-reference

    # Split the diagram into two rows using a newline delimiter.
    local row1=${diagram%$'\n'*}
    local row2=${diagram#*$'\n'}

    # Iterate through the students to build their plot strings.
    for i in "${!students[@]}"; do
        local -i offset=i*2
        # Extract 2 chars from row1 and 2 from row2.
        plots_ref[i]="${row1:offset:2}${row2:offset:2}"
    done
}

# Expands a 4-character plot string into a space-separated list of full plant names.
# $1: The 4-character string of plant codes (e.g., "VRCG").
expand() {
    local plot_codes=$1
    local result=() # An array to hold the full plant names.

    for (( i=0; i<${#plot_codes}; i++ )); do
        local code="${plot_codes:i:1}"
        result+=("${plants[$code]}")
    done
    
    # Print the array elements joined by spaces.
    echo "${result[*]}"
}

# Execute the main function with the script's command-line arguments.
main "$@"

Detailed Code Walkthrough

Let's break down this script piece by piece to understand the role of every line.

Section 1: Setup and Data Initialization

#!/usr/bin/env bash

# shellcheck disable=SC2034
declare -A plants=([G]=grass [C]=clover [R]=radishes [V]=violets)

students=(Alice Bob Charlie David Eve Fred Ginny Harriet Ileana Joseph Kincaid Larry)

• #!/usr/bin/env bash: This is the "shebang". It tells the operating system to execute this file using the bash interpreter found in the user's environment path. It's more portable than the hardcoded #!/bin/bash. You can learn more in our comprehensive Bash language guide.
• declare -A plants=(...): This command declares an associative array named plants. The -A flag is crucial. This array maps single-character keys (G, C, etc.) to string values (grass, clover, etc.), providing a fast and readable way to translate codes to names.
• students=(...): This creates a standard indexed array. Alice is at index 0, Bob at index 1, and so on. The order is critical as it determines which plot belongs to which child.

Section 2: The Student Index Map

declare -A studentIdx
for i in "${!students[@]}"; do
    studentIdx[${students[i]}]=$i
done

• declare -A studentIdx: We declare another associative array. This one will store a reverse mapping: from a student's name to their numerical index.
• for i in "${!students[@]}": This is a powerful Bash loop construct. The ! prefix before the array name causes the expansion to produce a list of the array's indices (0, 1, 2, ...) rather than its values.
• studentIdx[${students[i]}]=$i: Inside the loop, for each index i, we do two things:
  1. ${students[i]}: We get the student's name at that index (e.g., when i is 0, this is "Alice").
  2. We use that name as the key in our studentIdx map and assign the index i as its value. The result is a map like [Alice]=0, [Bob]=1, ....

This pre-computation is a smart optimization. Instead of searching the students array every time we need an index, we can now get it in constant time (O(1)) with a simple lookup like ${studentIdx["Alice"]}.

Section 3: The `main` Function

main() {
    local -i sidx
    sidx=${studentIdx[$2]}

    local -a plots
    parse "$1" plots

    expand "${plots[sidx]}"
}

• main() { ... }: Defines the main entry point of our script, promoting good structure.
• local -i sidx: Declares a local variable sidx. The -i flag ensures it's treated as an integer, which can prevent subtle bugs and improve performance for arithmetic operations.
• sidx=${studentIdx[$2]}: Here's our lookup in action! $2 is the second command-line argument (the student's name). We use it as a key to get the student's index from our pre-computed map and store it in sidx.
• local -a plots: Declares a local indexed array named plots. The -a flag is for indexed arrays.
• parse "$1" plots: This calls the parse function. We pass it the full diagram ($1) and the name of our local array, plots. The parse function will populate this array for us.
• expand "${plots[sidx]}": After parse has run, the plots array is filled. We use the student's index (sidx) to select the correct element from plots (which contains the four plant codes for that student) and pass it to the expand function for the final output.

Section 4: The `parse` Function

parse() {
    local diagram=$1
    local -n plots_ref=$2

    local row1=${diagram%$'\n'*}
    local row2=${diagram#*$'\n'}

    for i in "${!students[@]}"; do
        local -i offset=i*2
        plots_ref[i]="${row1:offset:2}${row2:offset:2}"
    done
}

• local -n plots_ref=$2: This is a modern Bash feature (version 4.3+) called a "nameref". It allows us to pass an array by reference. plots_ref becomes an alias for the variable whose name was passed as the second argument (in our case, plots from the main function). Any changes made to plots_ref inside this function will directly affect the original plots array in main.
• local row1=${diagram%$'\n'*}: This is a parameter expansion trick to split the string. %$'\n'* removes the longest suffix starting with a newline, effectively giving us everything before the newline (the first row).
• local row2=${diagram#*$'\n'}: This is the counterpart. #*$'\n' removes the shortest prefix ending with a newline, giving us everything after the newline (the second row).
• for i in "${!students[@]}": We loop through all student indices again.
• local -i offset=i*2: For each student, we calculate their starting position in the rows. Alice (index 0) has an offset of 0. Bob (index 1) has an offset of 2, and so on.
• plots_ref[i]="${row1:offset:2}${row2:offset:2}": This is the core data extraction logic.
  • ${row1:offset:2}: This performs substring extraction. It takes a slice of length 2 from row1, starting at offset.
  • ${row2:offset:2}: It does the same for the second row.
  • The two 2-character strings are concatenated and stored in our referenced array at the student's index. For Alice (i=0), this builds a 4-character string like "VCRV".

Section 5: The `expand` Function

expand() {
    local plot_codes=$1
    local result=()

    for (( i=0; i<${#plot_codes}; i++ )); do
        local code="${plot_codes:i:1}"
        result+=("${plants[$code]}")
    done
    
    echo "${result[*]}"
}

• local plot_codes=$1: Captures the 4-character plot string (e.g., "VCRV") passed from main.
• local result=(): Initializes an empty array to store the full plant names.
• for (( i=0; i<${#plot_codes}; i++ )): A C-style for loop that iterates from 0 to the length of the plot_codes string minus one.
• local code="${plot_codes:i:1}": Inside the loop, we extract one character at a time.
• result+=("${plants[$code]}"): We use the extracted single-character code as a key to look up the full name in our global plants associative array. The result (e.g., "Violets") is then appended to the result array.
• echo "${result[*]}": Finally, this prints the output. ${result[*]} expands to all elements of the array, separated by the first character of the IFS (Internal Field Separator) variable, which is a space by default. This produces the desired output format like "violets radishes clover radishes".

Section 6: Script Execution

main "$@"

• "$@": This is a special Bash variable that expands to all command-line arguments passed to the script, with each argument quoted individually. This correctly handles arguments that might contain spaces or special characters.
• main "$@": This line kicks off the entire process by calling the main function and passing all script arguments to it.

Visualizing the Data Transformation

Let's trace the data for a single student, say Charlie (index 2), to make the process crystal clear.

    ● Input: Name="Charlie"
    │
    ▼
  ┌────────────────────────┐
  │ sidx = studentIdx["Charlie"] │
  │ Result: sidx = 2       │
  └───────────┬────────────┘
              │
              ▼
  ┌────────────────────────┐
  │ parse() calculates all plots │
  │ plots[2] is what we need │
  └───────────┬────────────┘
              │
              ├──> offset = 2 * 2 = 4
              │
              ├──> row1 slice = ${row1:4:2} -> "VV"
              │
              ├──> row2 slice = ${row2:4:2} -> "GC"
              │
              ▼
  ┌────────────────────────┐
  │ plots[2] = "VVGC"      │
  └───────────┬────────────┘
              │
              ▼
  ┌────────────────────────┐
  │ expand("VVGC") is called │
  └───────────┬────────────┘
              │
              ├──> 'V' -> "violets"
              │
              ├──> 'V' -> "violets"
              │
              ├──> 'G' -> "grass"
              │
              └──> 'C' -> "clover"
              │
              ▼
    ● Output: "violets violets grass clover"

Analysis and Potential Optimizations

The provided solution is robust, readable, and efficient. However, like any code, it represents a set of trade-offs. Let's analyze its strengths and weaknesses.

Pros and Cons of the Current Approach

An Alternative, More Direct Approach

We can write a slightly more compact version that avoids creating the intermediate plots array for all students and calculates the required plot string on the fly. This version is less modular but more direct for this specific problem.

#!/usr/bin/env bash

# An alternative, more direct solution from kodikra.com.

declare -A plants=([G]=grass [C]=clover [R]=radishes [V]=violets)
students=(Alice Bob Charlie David Eve Fred Ginny Harriet Ileana Joseph Kincaid Larry)

declare -A studentIdx
for i in "${!students[@]}"; do
    studentIdx[${students[i]}]=$i
done

main() {
    local diagram=$1
    local student_name=$2

    # Basic error handling for invalid student name
    if [[ -z "${studentIdx[$student_name]}" ]]; then
        echo "Error: Student '$student_name' not found." >&2
        exit 1
    fi

    local -i sidx=${studentIdx[$student_name]}
    local -i offset=sidx*2

    local row1=${diagram%$'\n'*}
    local row2=${diagram#*$'\n'}

    local plot_codes="${row1:offset:2}${row2:offset:2}"
    
    local result=()
    for (( i=0; i<${#plot_codes}; i++ )); do
        result+=("${plants[${plot_codes:i:1}]}")
    done

    echo "${result[*]}"
}

main "$@"

This refactored version consolidates the logic into the main function. It directly calculates the offset and extracts the plant codes for only the requested student, which is slightly more memory-efficient. It also includes a basic error-checking block, making it more robust.

Choosing between these two styles is a matter of preference and context. The first (multi-function) approach is better for larger, more complex scripts where modularity is key. The second (direct) approach is fine for smaller, single-purpose utilities. Both are valid and demonstrate a solid understanding of Bash scripting. To continue building these skills, you can explore our complete Bash Learning Roadmap.

Frequently Asked Questions (FAQ)

if [[ -z "${studentIdx[$student_name]}" ]]; then
    echo "Error: Student '$student_name' not found." >&2
    exit 1
fi

Conclusion: From Garden Diagrams to Real-World Mastery

We have journeyed from a simple garden diagram to a deep understanding of powerful Bash scripting techniques. By dissecting the Kindergarten Garden problem from the kodikra.com curriculum, you've gained hands-on experience with the tools necessary for sophisticated text processing and automation: associative arrays for efficient data mapping, parameter expansion for precise string slicing, and function design for creating clean, maintainable scripts.

The skills you've honed here are not just for solving puzzles. They are the building blocks for writing robust DevOps automation, parsing complex log files to diagnose system issues, and creating powerful command-line utilities that will save you and your team countless hours. The logic of mapping, parsing, and transforming data is universal, and Bash provides a direct and powerful way to implement it right from your terminal.

Disclaimer: The code and explanations in this guide are based on modern Bash features available in version 4.0 and higher. For optimal compatibility and access to features like associative arrays and namerefs, ensure your shell environment is up-to-date by running bash --version.

Published by Kodikra — Your trusted Bash learning resource.