Sync

Task/Roman-numerals-Encode/Erlang/roman-numerals-encode-1.erl

@@ -0,0 +1,20 @@
+-module(roman).
+-export([to_roman/1]).
+
+to_roman(0) -> [];
+to_roman(X) when X >= 1000 -> [$M | to_roman(X - 1000)];
+to_roman(X) when X >= 100 ->
+    digit(X div 100, $C, $D, $M) ++ to_roman(X rem 100);
+to_roman(X) when X >= 10 ->
+    digit(X div 10, $X, $L, $C) ++ to_roman(X rem 10);
+to_roman(X) when X >= 1 -> digit(X, $I, $V, $X).
+
+digit(1, X, _, _) -> [X];
+digit(2, X, _, _) -> [X, X];
+digit(3, X, _, _) -> [X, X, X];
+digit(4, X, Y, _) -> [X, Y];
+digit(5, _, Y, _) -> [Y];
+digit(6, X, Y, _) -> [Y, X];
+digit(7, X, Y, _) -> [Y, X, X];
+digit(8, X, Y, _) -> [Y, X, X, X];
+digit(9, X, _, Z) -> [X, Z].

Task/Roman-numerals-Encode/Erlang/roman-numerals-encode-2.erl

@@ -0,0 +1,20 @@
+-module( roman_numerals ).
+
+-export( [encode_from_integer/1]).
+
+-record( encode_acc, {n, romans=""} ).
+
+encode_from_integer( N ) when N > 0 ->
+        #encode_acc{romans=Romans} = lists:foldl( fun encode_from_integer/2, #encode_acc{n=N}, map() ),
+        Romans.
+
+
+encode_from_integer( _Map, #encode_acc{n=0}=Acc ) -> Acc;
+encode_from_integer( {_Roman, Value}, #encode_acc{n=N}=Acc ) when N < Value -> Acc;
+encode_from_integer( {Roman, Value}, #encode_acc{n=N, romans=Romans} ) ->
+        Times = N div Value,
+        New_roman = lists:flatten( lists:duplicate(Times, Roman) ),
+        #encode_acc{n=N - (Times * Value), romans=Romans ++ New_roman}.
+
+map() -> [{"M",1000}, {"CM",900}, {"D",500}, {"CD",400}, {"C",100}, {"XC",90}, {"L",50}, {"XL",40}, {"X",10}, {"IX",9}, {"V",5}, {"IV",4}, {"I\
+",1}].

Task/Roman-numerals-Encode/Excel/roman-numerals-encode-1.excel

@@ -0,0 +1 @@
+=ROMAN(2013,0)

Task/Roman-numerals-Encode/Excel/roman-numerals-encode-2.excel

@@ -0,0 +1 @@
+MMXIII

Task/Roman-numerals-Encode/Java/roman-numerals-encode-1.java

@@ -0,0 +1,41 @@
+public class RN {
+
+    enum Numeral {
+        I(1), IV(4), V(5), IX(9), X(10), XL(40), L(50), XC(90), C(100), CD(400), D(500), CM(900), M(1000);
+        int weight;
+
+        Numeral(int weight) {
+            this.weight = weight;
+        }
+    };
+
+    public static String roman(long n) {
+
+        if( n <= 0) {
+            throw new IllegalArgumentException();
+        }
+
+        StringBuilder buf = new StringBuilder();
+
+        final Numeral[] values = Numeral.values();
+        for (int i = values.length - 1; i >= 0; i--) {
+            while (n >= values[i].weight) {
+                buf.append(values[i]);
+                n -= values[i].weight;
+            }
+        }
+        return buf.toString();
+    }
+
+    public static void test(long n) {
+        System.out.println(n + " = " + roman(n));
+    }
+
+    public static void main(String[] args) {
+        test(1999);
+        test(25);
+        test(944);
+        test(0);
+    }
+
+}

Task/Roman-numerals-Encode/Java/roman-numerals-encode-2.java

@@ -0,0 +1,59 @@
+import java.util.Set;
+import java.util.EnumSet;
+import java.util.Collections;
+import java.util.stream.Collectors;
+import java.util.stream.LongStream;
+
+public interface RomanNumerals {
+  public enum Numeral {
+    M(1000), CM(900), D(500), CD(400), C(100), XC(90), L(50), XL(40), X(10), IX(9), V(5), IV(4), I(1);
+
+    public final long weight;
+
+    private static final Set<Numeral> SET = Collections.unmodifiableSet(EnumSet.allOf(Numeral.class));
+
+    private Numeral(long weight) {
+      this.weight = weight;
+    }
+
+    public static Numeral getLargest(long weight) {
+      return SET.stream()
+        .filter(numeral -> weight >= numeral.weight)
+        .findFirst()
+        .orElse(I)
+      ;
+    }
+  };
+
+  public static String encode(long n) {
+    return LongStream.iterate(n, l -> l - Numeral.getLargest(l).weight)
+      .limit(Numeral.values().length)
+      .filter(l -> l > 0)
+      .mapToObj(Numeral::getLargest)
+      .map(String::valueOf)
+      .collect(Collectors.joining())
+    ;
+  }
+
+  public static long decode(String roman) {
+    long result =  new StringBuilder(roman.toUpperCase()).reverse().chars()
+      .mapToObj(c -> Character.toString((char) c))
+      .map(numeral -> Enum.valueOf(Numeral.class, numeral))
+      .mapToLong(numeral -> numeral.weight)
+      .reduce(0, (a, b) -> a + (a <= b ? b : -b))
+    ;
+    if (roman.charAt(0) == roman.charAt(1)) {
+      result += 2 * Enum.valueOf(Numeral.class, roman.substring(0, 1)).weight;
+    }
+    return result;
+  }
+
+  public static void test(long n) {
+    System.out.println(n + " = " + encode(n));
+    System.out.println(encode(n) + " = " + decode(encode(n)));
+  }
+
+  public static void main(String[] args) {
+    LongStream.of(1999, 25, 944).forEach(RomanNumerals::test);
+  }
+}

Task/Roman-numerals-Encode/Racket/roman-numerals-encode-1.rkt

@@ -0,0 +1,15 @@
+#lang racket
+(define (encode/roman number)
+  (cond ((>= number 1000) (string-append "M" (encode/roman (- number 1000))))
+        ((>= number 900) (string-append "CM" (encode/roman (- number 900))))
+        ((>= number 500) (string-append "D" (encode/roman (- number 500))))
+        ((>= number 400) (string-append "CD" (encode/roman (- number 400))))
+        ((>= number 100) (string-append "C" (encode/roman (- number 100))))
+        ((>= number 90) (string-append "XC" (encode/roman (- number 90))))
+        ((>= number 50) (string-append "L" (encode/roman (- number 50))))
+        ((>= number 40) (string-append "XL" (encode/roman (- number 40))))
+        ((>= number 10) (string-append "X" (encode/roman (- number 10))))
+        ((>= number 5) (string-append "V" (encode/roman (- number 5))))
+        ((>= number 4) (string-append "IV" (encode/roman (- number 4))))
+        ((>= number 1) (string-append "I" (encode/roman (- number 1))))
+        (else "")))

Task/Roman-numerals-Encode/Racket/roman-numerals-encode-2.rkt

@@ -0,0 +1,18 @@
+#lang racket
+(define (number->list n)
+  (for/fold ([result null])
+    ([decimal '(1000 900 500 400 100 90 50 40 10 5 4  1)]
+     [roman   '(M    CM  D   CD  C   XC L  XL X  V IV I)])
+    #:break (= n 0)
+    (let-values ([(q r) (quotient/remainder n decimal)])
+      (set! n r)
+      (append result (make-list q roman)))))
+
+(define (encode/roman number)
+  (string-join (map symbol->string (number->list number)) ""))
+
+(for ([n '(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 25 30 40
+           50 60 69 70 80 90 99 100 200 300 400 500 600 666 700 800 900
+           1000 1009 1444 1666 1945 1997 1999 2000 2008 2010 2011 2500
+           3000 3999)])
+  (printf "~a ~a\n" n (encode/roman n)))

Task/Roman-numerals-Encode/Ruby/roman-numerals-encode.rb

@@ -8,3 +8,7 @@ def roman(num)
     return roman(subtractor) + roman(num + subtractor)  if num >= cutPoint - subtractor and num < cutPoint
   end
 end
+
+[1990, 2008, 1666].each do |i|
+  puts "%4d => %s" % [i, roman(i)]
+end

Task/Roman-numerals-Encode/Scala/roman-numerals-encode-3.scala

@@ -0,0 +1,26 @@
+def toRoman(num: Int): String = {
+  case class RomanUnit(value: Int, token: String)
+  val romanNumerals = List(
+    RomanUnit(1000, "M"),
+    RomanUnit(900, "CM"),
+    RomanUnit(500, "D"),
+    RomanUnit(400, "CD"),
+    RomanUnit(100, "C"),
+    RomanUnit(90, "XC"),
+    RomanUnit(50, "L"),
+    RomanUnit(40, "XL"),
+    RomanUnit(10, "X"),
+    RomanUnit(9, "IX"),
+    RomanUnit(5, "V"),
+    RomanUnit(4, "IV"),
+    RomanUnit(1, "I"))
+
+  var remainingNumber = num
+  romanNumerals.foldLeft("") { (outputStr, romanUnit) =>
+    {
+      val times = remainingNumber / romanUnit.value
+      remainingNumber -= romanUnit.value * times
+      outputStr + (romanUnit.token * times)
+    }
+  }
+}