Add Modular Arithmetic approach to RaindropConverter (#3144)

Author: habere-et-dispertire

exercises/practice/raindrops/.approaches/config.json

@@ -22,6 +22,15 @@
       "authors": [
         "bobahop"
       ]
+    },
+    {
+      "uuid": "d16d4056-2434-44ff-aae6-2bd57eb53dd7",
+      "slug": "modulus",
+      "title": "Modulus",
+      "blurb": "Use modular arithmetic to generalize.",
+      "authors": [
+        "habere-et-dispertire"
+      ]
     }
   ]
 }

exercises/practice/raindrops/.approaches/introduction.md

@@ -54,6 +54,32 @@ class RaindropConverter {
 
 For more information, check the [`Map` approach][approach-map].
 
+## Approach: `Modulus`
+
+```java
+import java.math.BigInteger;
+import static java.math.BigInteger.valueOf;
+
+class RaindropConverter {
+
+    String convert (int 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 [Modulus approach][approach-modulus].
+
 ## 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-modulus]: https://exercism.org/tracks/java/exercises/raindrops/approaches/modulus
 [jmh]: https://github.com/openjdk/jmh

exercises/practice/raindrops/.approaches/modulus/content.md

@@ -0,0 +1,31 @@
+# Modulus
+
+```java
+import java.math.BigInteger;
+import static java.math.BigInteger.valueOf;
+
+class RaindropConverter {
+
+    String convert (int 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
+        };
+    }
+
+}
+```
+
+We can generalize raindrops to any factors if they are [co-prime][co-prime].
+In raindrops, the factors 3, 5 and 7 are co-prime (all sets of prime numbers are co-prime), so we can use [Euler's totient function][euler-totient] to calculate `n¹² mod 105`, giving us unique values for the various sounds.
+The math behind how we find the right exponent and modulus is explained in an article on the related problem of [Fizz-Buzz][fizz-buzz].
+
+[co-prime]: https://en.wikipedia.org/wiki/Coprime_integers
+[euler-totient]: https://en.wikipedia.org/wiki/Euler's_totient_function
+[fizz-buzz]: https://philcrissman.net/posts/eulers-fizzbuzz/

exercises/practice/raindrops/.approaches/modulus/snippet.txt

@@ -0,0 +1,8 @@
+String convert (int n) {
+    return switch (BigInteger.valueOf(n).modPow(BigInteger.valueOf(12),BigInteger.valueOf(105)).intValue()) {
+        case  0 -> "PlingPlangPlong";
+        case 36 -> "Pling";
+        // other cases
+        default -> String.valueOf(n); // 1
+    };
+}