Source code for submission s820

Go to diff to previous submission

fs.java

  1.  
  2. import java.io.BufferedReader;
  3. import java.io.IOException;
  4. import java.io.InputStreamReader;
  5. import java.util.logging.Level;
  6. import java.util.logging.Logger;
  7.  
  8. public class fs {
  9.  
  10. public static String decodeMorse(String morse) {
  11. if(morse.equals(".-"))
  12. return new String ("A");
  13.  
  14. if(morse.equals("-..."))
  15. return new String ("B");
  16.  
  17. if(morse.equals("-.-."))
  18. return new String ("C");
  19.  
  20. if(morse.equals("-.."))
  21. return new String("D");
  22.  
  23. if(morse.equals("."))
  24. return new String("E");
  25.  
  26. if(morse.equals("..-."))
  27. return new String("F");
  28.  
  29. if(morse.equals("--."))
  30. return new String("G");
  31.  
  32. if(morse.equals("...."))
  33. return new String("H");
  34.  
  35. if(morse.equals(".--."))
  36. return new String("P");
  37.  
  38. if(morse.equals(".."))
  39. return new String("I");
  40.  
  41. if(morse.equals(".---"))
  42. return new String("J");
  43.  
  44. if(morse.equals("-.-"))
  45. return new String("K");
  46.  
  47. if(morse.equals(".-.."))
  48. return new String("L");
  49.  
  50. if(morse.equals("--"))
  51. return new String("M");
  52.  
  53. if(morse.equals("-."))
  54. return new String("N");
  55.  
  56. if(morse.equals("---"))
  57. return new String("O");
  58.  
  59. if(morse.equals("--.-"))
  60. return new String("Q");
  61.  
  62. if(morse.equals(".-."))
  63. return new String("R");
  64.  
  65. if(morse.equals("..."))
  66. return new String("S");
  67.  
  68. if(morse.equals("-"))
  69. return new String("T");
  70.  
  71. if(morse.equals("..-"))
  72. return new String("U");
  73.  
  74. if(morse.equals("...-"))
  75. return new String("V");
  76.  
  77. if(morse.equals(".--"))
  78. return new String("W");
  79.  
  80. if(morse.equals("-..-"))
  81. return new String("X");
  82.  
  83. if(morse.equals("-.--"))
  84. return new String("Y");
  85.  
  86. if(morse.equals("--.."))
  87. return new String("Z");
  88.  
  89. if(morse.equals("..--"))
  90. return new String("_");
  91.  
  92. if(morse.equals(".-.-"))
  93. return new String(",");
  94.  
  95. if(morse.equals("---."))
  96. return new String(".");
  97.  
  98. if(morse.equals("----"))
  99. return new String("?");
  100.  
  101. return new String();
  102. }
  103.  
  104. public static String decode(String morse, String lengths) {
  105. StringBuilder ret = new StringBuilder();
  106. int currLen = 0;
  107.  
  108. for(int i = 0; i < lengths.length(); i++) {
  109. currLen = Integer.parseInt("" + lengths.charAt(i));
  110.  
  111. ret.append(fs.decodeMorse(morse.substring(0, currLen)));
  112. morse = morse.substring(currLen, morse.length());
  113. }
  114.  
  115. return ret.toString();
  116. }
  117.  
  118. public static String encode(char c) {
  119. switch(c) {
  120. case 'A':
  121. return new String(".-");
  122. case 'B':
  123. return new String("-...");
  124. case 'C':
  125. return new String("-.-.");
  126. case 'D':
  127. return new String("-..");
  128. case 'E':
  129. return new String(".");
  130. case 'F':
  131. return new String("..-.");
  132. case 'G':
  133. return new String("--.");
  134. case 'H':
  135. return new String("....");
  136. case 'I':
  137. return new String("..");
  138. case 'J':
  139. return new String(".---");
  140. case 'K':
  141. return new String("-.-");
  142. case 'L':
  143. return new String(".-..");
  144. case 'M':
  145. return new String("--");
  146. case 'N':
  147. return new String("-.");
  148. case 'O':
  149. return new String("---");
  150. case 'P':
  151. return new String(".--.");
  152. case 'Q':
  153. return new String("--.-");
  154. case 'R':
  155. return new String(".-.");
  156. case 'S':
  157. return new String("...");
  158. case 'T':
  159. return new String("-");
  160. case 'U':
  161. return new String("..-");
  162. case 'V':
  163. return new String("...-");
  164. case 'W':
  165. return new String(".--");
  166. case 'X':
  167. return new String("-..-");
  168. case 'Y':
  169. return new String("-.--");
  170. case 'Z':
  171. return new String("--..");
  172. case '_':
  173. return new String("..--");
  174. case ',':
  175. return new String(".-.-");
  176. case '.':
  177. return new String("---.");
  178. case '?':
  179. return new String("----");
  180.  
  181. }
  182.  
  183. return new String();
  184. }
  185.  
  186. public static void main(String[] args) {
  187. String line;
  188. StringBuilder morse = new StringBuilder();
  189. StringBuilder lengths = new StringBuilder();
  190.  
  191. while(true) {
  192. try {
  193. line = br.readLine();
  194.  
  195. if (line == null) {
  196. break;
  197. }
  198.  
  199. for (int i = 0; i < line.length(); i++) {
  200. char c = line.charAt(i);
  201.  
  202. String encoded = fs.encode(c);
  203. morse.append(encoded);
  204. lengths.append(encoded.length());
  205. }
  206.  
  207. lengths = lengths.reverse();
  208.  
  209. System.out.println(fs.decode(morse.toString(), lengths.toString()));
  210.  
  211. } catch (IOException ex) {
  212. Logger.getLogger(fs.class.getName()).log(Level.SEVERE, null, ex);
  213. }
  214. }
  215. }
  216.  
  217. }
  218.  

Diff to submission s809

fs.java

--- c5.s809.cteam005.fs.java.0.fs.java
+++ c5.s820.cteam005.fs.java.0.fs.java
@@ -8,98 +8,96 @@
 public class fs {
     
-    public static String decodeMorse(String morse) {
-        String ret = new String();
-        
+    public static String decodeMorse(String morse) {        
         if(morse.equals(".-"))
-            ret = "A";
-        
+            return new String ("A");
+
         if(morse.equals("-..."))
-            ret = "B";
+            return new String ("B");
         
         if(morse.equals("-.-."))
-            ret = "C";
+            return new String ("C");
         
         if(morse.equals("-.."))
-            ret = "D";
+            return new String("D");
         
         if(morse.equals("."))
-            ret = "E";
+            return new String("E");
         
         if(morse.equals("..-."))
-            ret = "F";
+            return new String("F");
         
         if(morse.equals("--."))
-            ret = "G";
+            return new String("G");
         
         if(morse.equals("...."))
-            ret = "H";
+            return new String("H");
         
         if(morse.equals(".--."))
-            ret = "P";
+            return new String("P");
         
         if(morse.equals(".."))
-            ret = "I";
+            return new String("I");
         
         if(morse.equals(".---"))
-            ret = "J";
+            return new String("J");
         
         if(morse.equals("-.-"))
-            ret = "K";
+            return new String("K");
         
         if(morse.equals(".-.."))
-            ret = "L";
+            return new String("L");
         
         if(morse.equals("--"))
-            ret = "M";
+            return new String("M");
         
         if(morse.equals("-."))
-            ret = "N";
+            return new String("N");
         
         if(morse.equals("---"))
-            ret = "O";
+            return new String("O");
         
         if(morse.equals("--.-"))
-            ret = "Q";
+            return new String("Q");
         
         if(morse.equals(".-."))
-            ret = "R";
+            return new String("R");
         
         if(morse.equals("..."))
-            ret = "S";
+            return new String("S");
         
         if(morse.equals("-"))
-            ret = "T";
+            return new String("T");
         
         if(morse.equals("..-"))
-            ret = "U";
+            return new String("U");
         
         if(morse.equals("...-"))
-            ret = "V";
+            return new String("V");
         
         if(morse.equals(".--"))
-            ret = "W";
+            return new String("W");
         
         if(morse.equals("-..-"))
-            ret = "X";
+            return new String("X");
         
         if(morse.equals("-.--"))
-            ret = "Y";
+            return new String("Y");
         
         if(morse.equals("--.."))
-            ret = "Z";
+            return new String("Z");
         
         if(morse.equals("..--"))
-            ret = "_";
+            return new String("_");
         
         if(morse.equals(".-.-"))
-            ret = ",";
+            return new String(",");
         
         if(morse.equals("---."))
-            ret = ".";
+            return new String(".");
         
         if(morse.equals("----"))
-            ret = "?";
+            return new String("?");
         
-        return ret;
+        return new String();
     }