File: divide-a-string-into-groups-of-size-k/solution.py

Date: 2026-06-06

Time: 16:26

divide-a-string-into-groups-of-size-k/solution.py

Purpose

This file solves LeetCode 2138 — Divide a String Into Groups of Size k. It takes a string, splits it into consecutive chunks of exactly k characters, and pads the final chunk with a fill character if the string length isn't evenly divisible by k.

Key Components

Solution.divideString(s, k, fill) -> List[str] — The sole method. Takes a string s, group size k, and a single padding character fill. Returns a list of strings each of length k.

Flow

The method works in two steps:

1. Pad: s += fill * ((k - len(s) % k) % k) — appends enough copies of fill to make len(s) a multiple of k. The double-mod (k - len(s) % k) % k computes the deficit: if len(s) is already a multiple of k, the inner mod yields k, and the outer mod collapses that to 0 (no padding). Otherwise it yields exactly the number of fill characters needed.

2. Slice: [s[i:i + k] for i in range(0, len(s), k)] — walks through the padded string in steps of k, producing one substring per step.

Patterns

• Pad-then-slice: Rather than special-casing the last group, the code normalizes the input up front so the slicing logic is uniform. This is a common idiom for chunking problems — it eliminates a branch at the cost of a string concatenation.
• Arithmetic mod trick: (k - n % k) % k is the standard formula for "how many units to add to make n a multiple of k." The outer % k handles the already-aligned case.

Dependencies

• Imports: typing.List — used only for the return type annotation.
• Imported by: The test file divide-a-string-into-groups-of-size-k/test_solution.py. The large "Imported By" list in the repo context is an artifact of the test harness structure (all test files import a shared Solution pattern), not actual cross-problem dependencies.

Invariants

• Every returned string has length exactly k.
• The concatenation of all returned strings equals the original s with 0 to k-1 copies of fill appended.
• The number of returned groups is ceil(len(s) / k).

Error Handling

None. The method trusts its inputs match the LeetCode contract (1 <= len(s), 1 <= k, fill is a single lowercase letter). If k is 0, this would raise ZeroDivisionError from the mod, and ValueError from range. No defensive checks are added — standard practice for competitive programming solutions.

Beliefs

• pad-length-is-correct — The expression (k - len(s) % k) % k always produces a value in [0, k-1], ensuring minimal padding.
• all-groups-equal-length-k — Every element in the returned list has exactly k characters, guaranteed by the pad step preceding the slice step.
• no-padding-when-evenly-divisible — When len(s) % k == 0, zero fill characters are appended and the original string is returned as-is (chunked).
• single-pass-slicing — The list comprehension iterates over the padded string exactly once with stride k, producing ceil(len(s)/k) groups.