From 80ccb9219d019b47c43acef0ae7dea7c6f85ac9c Mon Sep 17 00:00:00 2001
From: habere-et-dispertire
 <18032974+habere-et-dispertire@users.noreply.github.com>
Date: Mon, 22 Jun 2026 20:12:46 +0100
Subject: [PATCH 1/3] Add Modular Arithmetic approach to RaindropConverter

---
 .../raindrops/.approaches/introduction.md     | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/exercises/practice/raindrops/.approaches/introduction.md b/exercises/practice/raindrops/.approaches/introduction.md
index 48b7d6b07..a860542d5 100644
--- a/exercises/practice/raindrops/.approaches/introduction.md
+++ b/exercises/practice/raindrops/.approaches/introduction.md
@@ -54,6 +54,32 @@ class RaindropConverter {
 
 For more information, check the [`Map` approach][approach-map].
 
+## Approach: `Modular Arithmetic`
+
+```java
+import        java.math.BigInteger;
+import static java.math.BigInteger.valueOf;
+
+class RaindropConverter {
+
+    String convert (int n) {
+        switch ( valueOf(n).modPow( valueOf(12), valueOf(105) ).intValue() ) {
+            case ( 1): { return String.valueOf(n); }
+            case (36): { return "Pling";           }
+            case (85): { return "Plang";           }
+            case (91): { return "Plong";           }
+            case (15): { return "PlingPlang";      }
+            case (21): { return "PlingPlong";      }
+            case (70): { return "PlangPlong";      }
+            default  : { return "PlingPlangPlong"; } // 0
+        }
+    }
+
+}
+```
+
+For more information, check the [`Modular arithmetic` approach][approach-modular].
+
 ## Which approach to use?
 
 Benchmarking with the [Java Microbenchmark Harness][jmh] is currently outside the scope of this document,
@@ -64,4 +90,5 @@ and no other code would need to be added.
 [remainder-operator]: https://www.geeksforgeeks.org/modulo-or-remainder-operator-in-java/
 [approach-if-statements]: https://exercism.org/tracks/java/exercises/raindrops/approaches/if-statements
 [approach-map]: https://exercism.org/tracks/java/exercises/raindrops/approaches/map
+[approach-modular]: https://philcrissman.net/posts/eulers-fizzbuzz/
 [jmh]: https://github.com/openjdk/jmh

From c5802d2d3780a164461e3d3f86fa582e51f15ee0 Mon Sep 17 00:00:00 2001
From: habere-et-dispertire
 <18032974+habere-et-dispertire@users.noreply.github.com>
Date: Tue, 23 Jun 2026 09:01:46 +0100
Subject: [PATCH 2/3] Refactor RaindropConverter default case

---
 exercises/practice/raindrops/.approaches/introduction.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/exercises/practice/raindrops/.approaches/introduction.md b/exercises/practice/raindrops/.approaches/introduction.md
index a860542d5..ade18fe66 100644
--- a/exercises/practice/raindrops/.approaches/introduction.md
+++ b/exercises/practice/raindrops/.approaches/introduction.md
@@ -64,14 +64,14 @@ class RaindropConverter {
 
     String convert (int n) {
         switch ( valueOf(n).modPow( valueOf(12), valueOf(105) ).intValue() ) {
-            case ( 1): { return String.valueOf(n); }
             case (36): { return "Pling";           }
             case (85): { return "Plang";           }
             case (91): { return "Plong";           }
             case (15): { return "PlingPlang";      }
             case (21): { return "PlingPlong";      }
             case (70): { return "PlangPlong";      }
-            default  : { return "PlingPlangPlong"; } // 0
+            case ( 0): { return "PlingPlangPlong"; }
+            default  : { return String.valueOf(n); }
         }
     }
 

From 28466a0aa2983485ef957589293d141c4b480bd3 Mon Sep 17 00:00:00 2001
From: habere-et-dispertire
 <18032974+habere-et-dispertire@users.noreply.github.com>
Date: Wed, 24 Jun 2026 09:01:32 +0100
Subject: [PATCH 3/3] Refactor with suggestions

Refactor switch statement to use enhanced switch expression syntax. Note similarity to Fizz Buzz.
---
 .../raindrops/.approaches/introduction.md     | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/exercises/practice/raindrops/.approaches/introduction.md b/exercises/practice/raindrops/.approaches/introduction.md
index ade18fe66..278785921 100644
--- a/exercises/practice/raindrops/.approaches/introduction.md
+++ b/exercises/practice/raindrops/.approaches/introduction.md
@@ -57,28 +57,28 @@ For more information, check the [`Map` approach][approach-map].
 ## Approach: `Modular Arithmetic`
 
 ```java
-import        java.math.BigInteger;
+import java.math.BigInteger;
 import static java.math.BigInteger.valueOf;
 
 class RaindropConverter {
 
     String convert (int n) {
-        switch ( valueOf(n).modPow( valueOf(12), valueOf(105) ).intValue() ) {
-            case (36): { return "Pling";           }
-            case (85): { return "Plang";           }
-            case (91): { return "Plong";           }
-            case (15): { return "PlingPlang";      }
-            case (21): { return "PlingPlong";      }
-            case (70): { return "PlangPlong";      }
-            case ( 0): { return "PlingPlangPlong"; }
-            default  : { return String.valueOf(n); }
-        }
+        return switch ( valueOf(n).modPow( valueOf(12), valueOf(105) ).intValue() ) {
+            case 36 -> "Pling";
+            case 85 -> "Plang";
+            case 91 -> "Plong";
+            case 15 -> "PlingPlang";
+            case 21 -> "PlingPlong";
+            case 70 -> "PlangPlong";
+            case  0 -> "PlingPlangPlong";
+            default -> String.valueOf(n); // 1
+        };
     }
 
 }
 ```
 
-For more information, check the [`Modular arithmetic` approach][approach-modular].
+Fizz-Buzz is a related problem to raindrops. Both can be solved in the general case using Euler's totient theorem as long as all the sounds/factors are co-prime. For more information, check this article on a [`modular arithmetic` approach][approach-modular].
 
 ## Which approach to use?