CodingBat Response Learning Journal

 

Warming up to Java the CodingBat way

Going into this assignment I was pretty comfortable reading Java but still a bit rusty with writing it from scratch, so I treated the three required tracks as a quick practice game simulation. My goal was to knock out the two-star minimum in each area first, then circle back for some personal extra practice.At first I’d dive straight in and “just code it,” hammering out the quickest solution that came to mind to see what stuck. That rapid-fire approach worked for the simpler cases, but the moment I hit a wall on the more harder problems, I forced myself to pause, sketch out the logic on paper, and break the problem into smaller, testable steps. Switching gears from trial-and-error to deliberate planning kept me from spiraling into endless tweaks—each time I stepped back, the next solution compiled cleaner and usually passed on the  next run or couple of runs with some minor adjustemnts.

String-2 — remembering that indexes start at 0

For the String-2 problems I sketched a tiny “toolbox” on paper:

• concat with +
  
  

• length() for boundary checks
  
  

• substring(start, end) for slices
  
  

Having that cheat-sheet kept me from bouncing back to the docs every ten seconds. Most solutions boiled down to identifying the right slice boundaries. The biggest snag was an off-by-one error when I forgot that substring(endIndex) stops before endIndex, not on it. It took three submissions to catch that, so I started printing test strings locally before pasting code into the browser. Lesson learned: quick local prints are faster than guessing.

Functional-1 — the “wow, that’s one line?” moment

The Functional-1 set felt almost like playing with a new superpower. Writing nums.replaceAll(n -> n * 2); after years of old-school for loops was oddly satisfying. I still jotted a flowchart for each problem.. The only hiccup came when I tried to sneak in a side effect (incrementing a counter inside the lambda). CodingBat’s checker rejected that attempt, reminding me that lambdas should stay pure for clarity.

Map-1 — fast lookups, slower thinking

Map-1 forced me to slow down and reason about state. I set up a mental checklist:

1. Do I already have this key? (containsKey)
   
   

2. What value do I need to insert or overwrite? (put)
   
   

3. Should I remove anything to maintain the required invariant? (remove)
   
   

The hard part was reading the prompt carefully enough to handle edge cases like empty strings as keys or null values. My first pass usually worked for the obvious happy path, but about half the problems failed a hidden test until I re-read the spec and tightened my if/else logic. On average each Map-1 challenge took 2-4  submissions; the trick was resisting the urge to over-complicate things.

Process retrospective

• Planning vs. “just code it” – I experimented both ways. A 60-second sketch saved five minutes of bug-chasing every time, so planning wins.
  
  

• What worked – Small helper variables for clarity (firstChar, lastTwo), pure lambdas, and writing the simplest possible map mutation before optimizing.
  
  

• What didn’t – Copy-pasting code between problems (inevitably missed a variable rename), and assuming CodingBat’s hidden tests were lenient.
  
  

• Attempts – String-2 averaged 1-2 runs per problem, Functional-1 was mostly one-and-done, Map-1 averaged 2-3 when edge cases surprised me.
  
  

Takeaways

CodingBat is deceptively short practice, but the immediate feedback loop made gaps in my Java muscle memory obvious. I’m walking away with sharper instincts for string boundaries, a newfound appreciation for Java’s functional helpers, and a reminder that maps are unbeatable when you need O(1) lookups. Next week I’ll aim to refactor some old project code with these patterns in mind—and maybe chase those extra-credit stars.