The power of this approach is that you see your actual thinking process through the code evolution. You learn that getting it wrong initially is part of the process, and that optimization comes after getting a working solution.
Let me should you my approach:
Section 1: Understanding the Problem First
Show the original problem with examples, then explain lexicographical order with your simple analogies (dictionary ordering, etc.).
Section 2: First Experimentation – Getting it Wrong
Show your very first attempt where you had the logic backwards:
// My first attempt - this was WRONG but important for learning!
const a1 = ["arp", "live", "strong"];
const a2 = ["lively", "alive", "harp", "sharp", "armstrong"];
a1.forEach(function (elementA1, indexA1) {
a2.forEach(function(elementA2, indexA2) {
// This was backwards - checking if short string contains long string!
console.log(elementA1.includes(elementA2)); // Always false!
});
});
Explain why this failed and what you learned from the mistake.
Section 3: The Breakthrough – Fixing the Logic
Show your corrected version:
// The "aha moment" - flipping the logic around
const matchedArr = new Set<string>();
a1.forEach(function (elementA1) {
a2.forEach(function(elementA2) {
// Now checking: Does the BIG string contain the SMALL string?
if (elementA2.includes(elementA1)) {
matchedArr.add(elementA1);
}
});
});
console.log("Matched Array", matchedArr);
Section 4: Building the Clean Solution
Show your two-function approach:
// Clean, working solution with separation of concerns
function matchedWords(a1: string[], a2: string[]): Set<string> {
const matchedArr = new Set<string>();
a1.forEach(function (elementA1) {
a2.forEach(function(elementA2) {
// Check if elementA1 is a substring of elementA2
if (elementA2.includes(elementA1)) {
matchedArr.add(elementA1);
}
});
});
return matchedArr;
}
function lexOrderSorted(setArr: Set<string>): string[] {
// Convert Set to array and sort lexicographically
return Array.from(setArr).sort();
}
// Using the functions together
const matchedWordsArr = matchedWords(a1, a2);
const sortedLexOrderArr = lexOrderSorted(matchedWordsArr);
console.log(sortedLexOrderArr); // ["arp", "live", "strong"]
Section 5: Optimization Journey
First, show the performance analysis discussion, then the optimized code:
// Optimized version with early termination and edge case handling
function matchedWords(a1: string[], a2: string[]): Set<string> {
// Handle edge cases first
if (a1.length <= 0 || a2.length <= 0) return new Set<string>();
const matchedArr = new Set<string>();
for (let elementA1 of a1) {
// Once we find a match, break out of inner loop (optimization!)
for (let elementA2 of a2) {
if (elementA2.includes(elementA1)) {
matchedArr.add(elementA1);
break; // Stop checking remaining strings in a2
}
}
}
return matchedArr;
}
Conclusion
The real lesson from this coding journey isn’t about mastering lexicographical ordering or substring matching – it’s about developing the problem-solving mindset that separates confident developers from those who get stuck.
Notice how we started by understanding the problem deeply, experimented fearlessly with our first (wrong) attempt, built a working solution through iteration, and only then optimized for performance.
This systematic approach of breaking down complexity, embracing mistakes as learning opportunities, and improving incrementally is exactly how professional developers tackle every challenge they encounter.
The next time you face a coding problem that seems overwhelming, remember this process: understand first, experiment boldly, make it work, then make it better.
This mindset will carry you through interview questions, personal projects, and your entire programming career because every expert developer still follows these same fundamental steps, no matter how complex the problem becomes.
