implement say exercise (exercism#1769) fix exercism#1752

mirkoperillo · web-flow · commit 110501cedc2f · 2020-11-06T14:33:56.000+01:00
diff --git a/config.json b/config.json
@@ -271,6 +271,16 @@
         "strings"
       ]
     },
+    {
+      "slug": "say",
+      "uuid": "3c76a983-e689-4d82-8f1b-6d52f3c5434c",
+      "core": false,
+      "unlocked_by": "difference-of-squares",
+      "difficulty": 3,
+      "topics": [
+        "integers"
+      ]
+    },
     {
       "slug": "micro-blog",
       "uuid": "8295ae71-5c0e-49d0-bbe9-9b43a85bf2dd",
diff --git a/exercises/say/.meta/src/reference/java/Say.java b/exercises/say/.meta/src/reference/java/Say.java
@@ -0,0 +1,127 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Say {
+
+    private static List<Magnitude> supportedMagnitudes = Arrays.asList(
+        Magnitude.BILLIONS, Magnitude.MILLIONS, 
+        Magnitude.THOUSANDS, Magnitude.ONES);
+
+    private enum Magnitude {
+        TRILLIONS(1_000_000_000_000L, "trillion"), 
+        BILLIONS(1_000_000_000, "billion"), 
+        MILLIONS(1_000_000, "million"), 
+        THOUSANDS(1_000, "thousand"), 
+        ONES(1, "one");
+
+        private long number;
+        private String inEnglish;
+
+        private Magnitude(long number, String inEnglish) {
+            this.number = number;
+            this.inEnglish = inEnglish;
+        }
+
+        public long getNumber() {
+            return number;
+        }
+
+        public String inEnglish() {
+            return inEnglish;
+        }
+    }
+
+    public String say(long number) {
+        if (number < 0 || number >= Magnitude.TRILLIONS.getNumber()) {
+            throw new IllegalArgumentException("input out of range");
+        }
+        List<Part> parts = new ArrayList<Say.Part>();
+        for (Magnitude magnitude: supportedMagnitudes) { 
+            double quoziente = Math.floor(number / magnitude.getNumber());
+            Part part = new Part((int) quoziente, magnitude);
+            if (part.getDigits() > 0 || (part.getMagnitude().equals(Magnitude.ONES) && parts.size() == 0)) {
+                parts.add(part);
+            }
+            number =   number % magnitude.getNumber();
+        }
+      
+        return String.join(" ", parts.stream().map(part -> part.say()).collect(Collectors.toList()));
+    }
+
+    private static class Part {
+        private int digits;
+        private Magnitude magnitude;
+
+        public Part(int digits, Magnitude magnitude) {
+            this.digits = digits;
+            this.magnitude = magnitude;
+        }
+
+        private static String[] untilTwenty = { "zero", "one", "two", "three", "four", "five", "six", "seven", "eigth",
+            "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "senventeen", "eithteen",
+            "nineteen" };
+
+        public int getDigits() {
+            return digits;
+        }
+
+        public Magnitude getMagnitude() {
+            return magnitude;
+        }
+        
+        private String convertTens(long digit) {
+            switch ((int) digit) {
+                case 2:
+                    return "twenty";
+                case 3:
+                    return "thirty";
+                case 4:
+                    return "forty";
+                case 5:
+                    return "fifty";
+                case 6:
+                    return "sixty";
+                case 7:
+                    return "seventy";
+                case 8:
+                    return "eighty";
+                case 9:
+                    return "ninety";
+                default:
+                    throw new IllegalArgumentException("not supported value");
+            }
+        }
+
+        private String say() {
+            StringBuffer stringBuffer = new StringBuffer();
+            int hundreds = (int) digits / 100;
+            int tens = (int) digits % 100;
+            if (hundreds > 0) {
+                stringBuffer.append(untilTwenty[hundreds]).append(" hundred");
+            }
+
+            if (stringBuffer.length() > 0) {
+                stringBuffer.append(" ");
+            }
+
+            if (tens >= 20) {
+                stringBuffer.append(convertTens(tens / 10));
+                if (tens % 10 > 0) {
+                    stringBuffer.append("-").append(untilTwenty[tens % 10]);
+                }
+            } else {
+                stringBuffer.append(untilTwenty[tens]);
+            }
+            
+            if (!magnitude.equals(Magnitude.ONES)) {
+                stringBuffer.append(" ").append(magnitude.inEnglish());
+            }
+                 
+            String message = stringBuffer.toString().replace(" zero", "");
+            return message;
+        }
+    }
+}
+
diff --git a/exercises/say/.meta/version b/exercises/say/.meta/version
@@ -0,0 +1 @@
+1.2.0
diff --git a/exercises/say/README.md b/exercises/say/README.md
@@ -0,0 +1,94 @@
+# Say
+
+Given a number from 0 to 999,999,999,999, spell out that number in English.
+
+## Step 1
+
+Handle the basic case of 0 through 99.
+
+If the input to the program is `22`, then the output should be
+`'twenty-two'`.
+
+Your program should complain loudly if given a number outside the
+blessed range.
+
+Some good test cases for this program are:
+
+- 0
+- 14
+- 50
+- 98
+- -1
+- 100
+
+### Extension
+
+If you're on a Mac, shell out to Mac OS X's `say` program to talk out
+loud. If you're on Linux or Windows, eSpeakNG may be available with the command `espeak`.
+
+## Step 2
+
+Implement breaking a number up into chunks of thousands.
+
+So `1234567890` should yield a list like 1, 234, 567, and 890, while the
+far simpler `1000` should yield just 1 and 0.
+
+The program must also report any values that are out of range.
+
+## Step 3
+
+Now handle inserting the appropriate scale word between those chunks.
+
+So `1234567890` should yield `'1 billion 234 million 567 thousand 890'`
+
+The program must also report any values that are out of range.  It's
+fine to stop at "trillion".
+
+## Step 4
+
+Put it all together to get nothing but plain English.
+
+`12345` should give `twelve thousand three hundred forty-five`.
+
+The program must also report any values that are out of range.
+
+### Extensions
+
+Use _and_ (correctly) when spelling out the number in English:
+
+- 14 becomes "fourteen".
+- 100 becomes "one hundred".
+- 120 becomes "one hundred and twenty".
+- 1002 becomes "one thousand and two".
+- 1323 becomes "one thousand three hundred and twenty-three".
+
+## Setup
+
+Go through the setup instructions for Java to install the necessary
+dependencies:
+
+[https://exercism.io/tracks/java/installation](https://exercism.io/tracks/java/installation)
+
+# Running the tests
+
+You can run all the tests for an exercise by entering the following in your
+terminal:
+
+```sh
+$ gradle test
+```
+
+> Use `gradlew.bat` if you're on Windows
+
+In the test suites all tests but the first have been skipped.
+
+Once you get a test passing, you can enable the next one by removing the
+`@Ignore("Remove to run test")` annotation.
+
+## Source
+
+A variation on JavaRanch CattleDrive, exercise 4a [http://www.javaranch.com/say.jsp](http://www.javaranch.com/say.jsp)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have
+completed the exercise.
diff --git a/exercises/say/build.gradle b/exercises/say/build.gradle
@@ -0,0 +1,18 @@
+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  testCompile "junit:junit:4.12"
+}
+
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}
diff --git a/exercises/say/src/main/java/.keep b/exercises/say/src/main/java/.keep
diff --git a/exercises/say/src/test/java/SayTest.java b/exercises/say/src/test/java/SayTest.java
@@ -0,0 +1,99 @@
+import org.junit.Test;
+import org.junit.Ignore;
+
+import static org.junit.Assert.assertEquals;
+
+public class SayTest {
+
+    private Say say = new Say();
+    
+    @Test
+    public void zero() {
+        assertEquals("zero", say.say(0));
+    }
+    
+    @Ignore("Remove to run test")
+    @Test
+    public void one() {
+        assertEquals("one", say.say(1));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void fourteen() {
+        assertEquals("fourteen", say.say(14));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void twenty() {
+        assertEquals("twenty", say.say(20));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void twentyTwo() {
+        assertEquals("twenty-two", say.say(22));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void oneHundred() {
+        assertEquals("one hundred", say.say(100));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void oneHundredTwentyThree() {
+        assertEquals("one hundred twenty-three", say.say(123));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void oneThousand() {
+        assertEquals("one thousand", say.say(1_000));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void oneThousandTwoHundredThirtyFour() {
+        assertEquals("one thousand two hundred thirty-four", say.say(1_234));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void oneMillion() {
+        assertEquals("one million", say.say(1_000_000));
+    }
+    
+    @Ignore("Remove to run test")
+    @Test
+    public void oneMillionTwoThousandThreeHundredFortyFive() {
+        assertEquals("one million two thousand three hundred forty-five", say.say(1_002_345));
+    }
+    
+    @Ignore("Remove to run test")
+    @Test
+    public void oneBillion() {
+        assertEquals("one billion", say.say(1_000_000_000));
+    }
+    
+    @Ignore("Remove to run test")
+    @Test
+    public void nineHundredEightySevenBillionSixHundredFiftyFourThreeHundredTwentyOneThousandOneHundredTwentyThree() {
+        assertEquals("nine hundred eighty-seven billion six hundred fifty-four million" +
+                     " three hundred twenty-one thousand one hundred twenty-three", say.say(987_654_321_123L));
+    }
+    
+    @Ignore("Remove to run test")
+    @Test(expected = IllegalArgumentException.class)
+    public void illegalNegativeNumber() {
+        say.say(-1);
+    }
+
+    @Ignore("Remove to run test")
+    @Test(expected = IllegalArgumentException.class)
+    public void illegalTooBigNumber() {
+        say.say(1_000_000_000_000L);
+    }    
+}
diff --git a/exercises/settings.gradle b/exercises/settings.gradle
@@ -90,6 +90,7 @@ include 'roman-numerals'
 include 'run-length-encoding'
 include 'rotational-cipher'
 include 'saddle-points'
+include 'say'
 include 'satellite'
 include 'scrabble-score'
 include 'secret-handshake'
