BombDefuser exemplar solution and tests

[adauguet]

I am trying a to mentor a student on the BombDefuser exercise.

It states:

For each bit in the ID number, starting with the leftmost bit, you will apply the flipper closure to the wires tuple if the bit is a 0 and you will apply the rotator closure if it is a 1 giving the new state of the wires.

To my understanding, this means that I should process the leftmost bit, which the left most 1 or 0.
If my number is 253 (like in the tests), its binary representation is 1111 1101 and I should process bits in the following order: 1, 1, 1, 1, 1, 1, 0 and 1.

In the exemplar solution, the implementation performs: if bits.isMultiple(of: 2). But that is checking the rightmost bit, not the leftmost.

What am I missing? Is this an error in the implementation? Or in the instructions?

Fun fact, the 113 number (used in tests) is working in both directions... leading to some confusion debugging all this.

[ErikSchierboom]

What am I missing? Is this an error in the implementation? Or in the instructions?

It can be what we choose it to be. Do we want to update the instructions or the implementation? The right-to-left implementation is a bit easier I think, right? If so, it might be best to update the instructions as we don't want to have students implement a very complex solution.

Fun fact, the 113 number (used in tests) is working in both directions... leading to some confusion debugging all this.

Aha, this must be why the exemplar solution's implementation still passes the tests. We should add a new test that would fail with an invalid implementation.

Would you be willing to submit a PR to fix this?

[adauguet]

The right-to-left implementation is indeed a bit easier, using % and / operators. But instructions mention bits, and they would not be used nor manipulated through bitwise operators in the exemplar solution. Which could be confusing.

In both cases, instructions should mention to encode on eight bits, just to be sure students do not forget some 0s.

Note : the String(_:radix:uppercase:) can also be useful here, and allow students to visualise bits.

I am open to submit a PR as soon as we decided where to go 🙂

[adauguet]

Also, sorry for creating this issue in the wrong repo. Could you please transfer it to exercism/swift? Thanks!

[ErikSchierboom]

These are the exercise's prerequisites:

• "functions", "higher-order-functions", "loops"

With just those prerequisites (and their transitive prerequisites), I don't think we can expect the user to know how to do bitwise manipulation. Similarly, the exercise uses the UInt8 type, which also is not known to the student. I would suggest one of the following:

Option 1:

• Add arrays as a prerequisite
• Change the UInt8 parameter to an array of Int values, effectively replacing the single byte with an array of 0 and 1s

Option 2:

• Add characters as a prerequisite
• Change the UInt8 parameter to a String that contains 0 and 1 characters.

[adauguet]

You are right, bitwise operators are too complicated for a beginner. Actually there are only explained in one the last chapter of the Apple Swift book.

Are you suggesting to completely replace Int by an array Int, or a String?

[ErikSchierboom]

I am.

[adauguet]

OK great. Will work on the PR then.

[mkalmes]

I've just completed the exercise myself and was confused by the description to start with the leftmost bit. Checking the bits in Calculator.app gave me the clue to my misunderstanding. If you visualize the binary representation as an array, the first bit starts at position 0 and grows to the right. However the string representation shows the Least Significant Bit (LSB) on the rightmost side.

@paiv mentioned the same observation in #493. I just wanted to +1 this conversation. 😄

[blynx]

I think it would be nice to treat the issue as a typo als long as the exercise isn't thorougly reworked. That would certainly prevent some confusion - as I just had, too ^^

[quixoticraindrp]

Just coming to this exercise in May of 2025, and none of the suggested fixes have been implemented. This exercise is, as written, too complicated for the beginner (such as myself). I don't have a solution, outside of pointing out there are suggestions above that are still not done, which might actually make this appropriately "easy" (which is what it's marked as now).

[meatball133]

Hello, yes this hasn't been worked on, this is partly due to this exercise being a bit low priority.

The Swift track had no maintainer between 2021-2023. I took over maintainership in mid 2023, I started working on more urgent work like updating the test runner to Swift 5.8 (from 5.3) and making it more stable. I also announced the rework of the syllabus: https://forum.exercism.org/t/swift-syllabus-rework-searching-feedback/6114. Phase one of the rework was released in late 2023, which included the beginning of the syllabus (which is the most important, since that has the highest usage). 2024, I was generally quite busy and same has been for 2025. I decided in 2024 to cancel the Swift syllabus rework since I realized I wouldn't have enough time/motivation to finish it. I launched that project since I personally feel there was quite a bit of issues with the syllabus.

My plan at the moment is to actually step down as a maintainer during the Summer. But a big issue is that the test runner still runs Swift 5.8 (released in 2023). So I have since November been working on porting the track to the new test framework, Swift-Testing and Swift 6.1. The work is more or less done, but this has included updates to ALL of the exercises on the track. I meanwhile decided to do a kind of phase 2 of the syllabus rework, for the proper rework, is it currently from layers of lasagna to Cal's custom sign shop (on the list I sent to the forum), but will not go from lasagna to Sanats Swift Helper. Everything further down on the list has received mid-small changes. This includes a lot of fixes but also other changes. But also Windowing system exercise has also received complaints (even more than bomb defuser), so that exercise is getting some tweaks to make the exercise more intuitive.

The changes for the Swift 6 update (which wont change at this point) is included here: https://github.com/exercism/swift/pull/838/files#diff-2643b7fc8c69983e0efcda48952db287953237012852180071e3fc615b93bfc5

But mostly includes things to make the exercise runable with Swift 6 and some fixes, but as a whole the Swift 6 update will update the syllabus tree and move some concept, but for this exercise, that wont matter to much since it's more or less already at the bottom.

TL;DR: I have been working on other stuff, so I haven't had time for this and there is a big update which will be released very soon so updating the exercise at the moment is not possible.

I think the current problem is that the author of the exercise takes for granted that you are/have studying/studied computer science (where you would cover bit manipulation). What I can do is make a post Swift-6 update with updates to task 3, where I would do either option 1 or 2 of Eriks proposal (I will have to decide that later). I have an exam period coming up and I have a vacation planned in June so it won likely be ready before mid-end of next month