Source code for submission s884

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.     static String[] vagner = new String[100]; 
  11.  
  12.     public static void fillVagner(){
  13.  
  14.       fs.vagner[65]=new String(".-");
  15.  
  16.                 fs.vagner[66]= new String("-...");
  17.  
  18.                 fs.vagner[67]= new String("-.-.");
  19.  
  20.                 fs.vagner[68]= new String("-..");
  21.  
  22.                 fs.vagner[69]= new String(".");
  23.  
  24.                 fs.vagner[70]= new String("..-.");
  25.  
  26.                 fs.vagner[71]= new String("--.");
  27.  
  28.                 fs.vagner[72]= new String("....");
  29.  
  30.                 fs.vagner[73]= new String("..");
  31.  
  32.                 fs.vagner[74]= new String(".---");
  33.  
  34.                 fs.vagner[75]= new String("-.-");
  35.  
  36.                 fs.vagner[76]= new String(".-..");
  37.  
  38.                 fs.vagner[77]= new String("--");
  39.  
  40.                 fs.vagner[78]= new String("-.");
  41.  
  42.                 fs.vagner[79]= new String("---");
  43.  
  44.                 fs.vagner[80]= new String(".--.");
  45.  
  46.                 fs.vagner[81]= new String("--.-");
  47.  
  48.                 fs.vagner[82]= new String(".-.");
  49.  
  50.                 fs.vagner[83]= new String("...");
  51.  
  52.                 fs.vagner[84]= new String("-");
  53.  
  54.                 fs.vagner[85]= new String("..-");
  55.  
  56.                 fs.vagner[86]= new String("...-");
  57.  
  58.                 fs.vagner[87]= new String(".--");
  59.  
  60.                 fs.vagner[88]= new String("-..-");
  61.  
  62.                 fs.vagner[89]= new String("-.--");
  63.  
  64.                 fs.vagner[90]= new String("--..");
  65.  
  66.                 fs.vagner[95]= new String("..--");
  67.  
  68.                 fs.vagner[44]= new String(".-.-");
  69.  
  70.                 fs.vagner[46]= new String("---.");
  71.  
  72.                 fs.vagner[63]= new String("----");
  73.  
  74.  
  75.     }
  76.  
  77.     public static String decodeMorse(String morse) {
  78.  
  79.         if (morse.charAt(0) == '.') {
  80.             if (morse.length() == 1) {
  81.                 return "E";
  82.             }
  83.  
  84.             if (morse.charAt(1) == '.') {
  85.                 if (morse.length() == 2) {
  86.                     return "I";
  87.                 }
  88.  
  89.                 if (morse.charAt(2) == '.') {
  90.                     if (morse.length() == 3) {
  91.                         return "S";
  92.                     }
  93.  
  94.                     if (morse.charAt(3) == '.') {
  95.                         return "H";
  96.                     } else {
  97.                         return "V";
  98.                     }
  99.                 } else {
  100.                     if (morse.length() == 3) {
  101.                         return "U";
  102.                     }
  103.  
  104.                     if (morse.charAt(3) == '.') {
  105.                         return "F";
  106.                     } else {
  107.                         return "_";
  108.                     } 
  109.                 }
  110.             } else {
  111.                 if (morse.length() == 2) {
  112.                     return "A";
  113.                 }
  114.  
  115.                 if (morse.charAt(2) == '.') {
  116.                     if (morse.length() == 3) {
  117.                         return "R";
  118.                     }
  119.  
  120.                     if (morse.charAt(3) == '.') {
  121.                         return "L";
  122.                     } else {
  123.                         return ",";
  124.                     }
  125.                 } else {
  126.                     if (morse.length() == 3) {
  127.                         return "W";
  128.                     }
  129.  
  130.                     if (morse.charAt(3) == '.') {
  131.                         return "P";
  132.                     } else {
  133.                         return "J";
  134.                     } 
  135.                 }
  136.             }
  137.         } else {
  138.             if (morse.length() == 1) {
  139.                 return "T";
  140.             }
  141.  
  142.             if (morse.charAt(1) == '.') {
  143.                 if (morse.length() == 2) {
  144.                     return "N";
  145.                 }
  146.  
  147.                 if (morse.charAt(2) == '.') {
  148.                     if (morse.length() == 3) {
  149.                         return "D";
  150.                     }
  151.  
  152.                     if (morse.charAt(3) == '.') {
  153.                         return "B";
  154.                     } else {
  155.                         return "X";
  156.                     }
  157.                 } else {
  158.                     if (morse.length() == 3) {
  159.                         return "K";
  160.                     }
  161.  
  162.                     if (morse.charAt(3) == '.') {
  163.                         return "C";
  164.                     } else {
  165.                         return "Y";
  166.                     } 
  167.                 }
  168.             } else {
  169.                 if (morse.length() == 2) {
  170.                     return "M";
  171.                 }
  172.  
  173.                 if (morse.charAt(2) == '.') {
  174.                     if (morse.length() == 3) {
  175.                         return "G";
  176.                     }
  177.  
  178.                     if (morse.charAt(3) == '.') {
  179.                         return "Z";
  180.                     } else {
  181.                         return "Q";
  182.                     }
  183.                 } else {
  184.                     if (morse.length() == 3) {
  185.                         return "O";
  186.                     }
  187.  
  188.                     if (morse.charAt(3) == '.') {
  189.                         return ".";
  190.                     } else {
  191.                         return "?";
  192.                     } 
  193.                 }
  194.             }
  195.         }
  196.  
  197.     /*if(morse.equals(".-"))
  198.     return new String ("A");
  199.     if(morse.equals("-..."))
  200.     return new String ("B");
  201.     if(morse.equals("-.-."))
  202.     return new String ("C");
  203.     if(morse.equals("-.."))
  204.     return new String("D");
  205.     if(morse.equals("."))
  206.     return new String("E");
  207.     if(morse.equals("..-."))
  208.     return new String("F");
  209.     if(morse.equals("--."))
  210.     return new String("G");
  211.     if(morse.equals("...."))
  212.     return new String("H");
  213.     if(morse.equals(".--."))
  214.     return new String("P");
  215.     if(morse.equals(".."))
  216.     return new String("I");
  217.     if(morse.equals(".---"))
  218.     return new String("J");
  219.     if(morse.equals("-.-"))
  220.     return new String("K");
  221.     if(morse.equals(".-.."))
  222.     return new String("L");
  223.     if(morse.equals("--"))
  224.     return new String("M");
  225.     if(morse.equals("-."))
  226.     return new String("N");
  227.     if(morse.equals("---"))
  228.     return new String("O");
  229.     if(morse.equals("--.-"))
  230.     return new String("Q");
  231.     if(morse.equals(".-."))
  232.     return new String("R");
  233.     if(morse.equals("..."))
  234.     return new String("S");
  235.     if(morse.equals("-"))
  236.     return new String("T");
  237.     if(morse.equals("..-"))
  238.     return new String("U");
  239.     if(morse.equals("...-"))
  240.     return new String("V");
  241.     if(morse.equals(".--"))
  242.     return new String("W");
  243.     if(morse.equals("-..-"))
  244.     return new String("X");
  245.     if(morse.equals("-.--"))
  246.     return new String("Y");
  247.     if(morse.equals("--.."))
  248.     return new String("Z");
  249.     if(morse.equals("..--"))
  250.     return new String("_");
  251.     if(morse.equals(".-.-"))
  252.     return new String(",");
  253.     if(morse.equals("---."))
  254.     return new String(".");
  255.     if(morse.equals("----"))
  256.     return new String("?");
  257.     return new String();*/
  258.     }
  259.  
  260.     public static String decode(String morse, String lengths) {
  261.         StringBuilder ret = new StringBuilder();
  262.         int currLen = 0;
  263.  
  264.         for (int i = 0; i < lengths.length(); i++) {
  265.             currLen = Integer.parseInt("" + lengths.charAt(i));
  266.  
  267.             ret.append(fs.decodeMorse(morse.substring(0, currLen)));
  268.             morse = morse.substring(currLen, morse.length());
  269.         }
  270.  
  271.         return ret.toString();
  272.     }
  273.  
  274.     public static String encode(char c) {
  275.  
  276.         return vagner[(int)c];
  277.     }
  278.  
  279.     public static void main(String[] args) {
  282.         String line;
  283.         StringBuilder morse = new StringBuilder();
  284.         StringBuilder lengths = new StringBuilder();
  285.  
  286.         fs.fillVagner();
  287.  
  288.         while (true) {
  289.  
  290.  
  291.             try {
  292.                 line = br.readLine();
  293.  
  294.                 if (line == null) {
  295.                     break;
  296.                 }
  297.  
  298.                 for (int i = 0; i < line.length(); i++) {
  299.                     char c = line.charAt(i);
  300.  
  301.                     String encoded = fs.encode(c);
  302.                     morse.append(encoded);
  303.                     lengths.append(encoded.length());
  304.                 }
  305.  
  306.                 lengths = lengths.reverse();
  307.  
  308.                 System.out.println(fs.decode(morse.toString(), lengths.toString()));
  309.  
  310.             } catch (IOException ex) {
  311.                 Logger.getLogger(fs.class.getName()).log(Level.SEVERE, null, ex);
  312.             }
  313.         }
  314.     }
  315. }
  316.  

Diff to submission s857

fs.java

--- c5.s857.cteam005.fs.java.0.fs.java
+++ c5.s884.cteam005.fs.java.0.fs.java
@@ -8,4 +8,71 @@
 public class fs {
 
+    static String[] vagner = new String[100]; 
+    
+    public static void fillVagner(){
+    
+      fs.vagner[65]=new String(".-");
+         
+                fs.vagner[66]= new String("-...");
+            
+                fs.vagner[67]= new String("-.-.");
+           
+                fs.vagner[68]= new String("-..");
+           
+                fs.vagner[69]= new String(".");
+           
+                fs.vagner[70]= new String("..-.");
+           
+                fs.vagner[71]= new String("--.");
+           
+                fs.vagner[72]= new String("....");
+           
+                fs.vagner[73]= new String("..");
+           
+                fs.vagner[74]= new String(".---");
+           
+                fs.vagner[75]= new String("-.-");
+           
+                fs.vagner[76]= new String(".-..");
+           
+                fs.vagner[77]= new String("--");
+           
+                fs.vagner[78]= new String("-.");
+           
+                fs.vagner[79]= new String("---");
+           
+                fs.vagner[80]= new String(".--.");
+           
+                fs.vagner[81]= new String("--.-");
+           
+                fs.vagner[82]= new String(".-.");
+           
+                fs.vagner[83]= new String("...");
+           
+                fs.vagner[84]= new String("-");
+           
+                fs.vagner[85]= new String("..-");
+           
+                fs.vagner[86]= new String("...-");
+            
+                fs.vagner[87]= new String(".--");
+            
+                fs.vagner[88]= new String("-..-");
+            
+                fs.vagner[89]= new String("-.--");
+            
+                fs.vagner[90]= new String("--..");
+          
+                fs.vagner[95]= new String("..--");
+            
+                fs.vagner[44]= new String(".-.-");
+            
+                fs.vagner[46]= new String("---.");
+            
+                fs.vagner[63]= new String("----");
+
+    
+    }
+    
     public static String decodeMorse(String morse) {
 
@@ -206,69 +273,6 @@
 
     public static String encode(char c) {
-        switch (c) {
-            case 'A':
-                return new String(".-");
-            case 'B':
-                return new String("-...");
-            case 'C':
-                return new String("-.-.");
-            case 'D':
-                return new String("-..");
-            case 'E':
-                return new String(".");
-            case 'F':
-                return new String("..-.");
-            case 'G':
-                return new String("--.");
-            case 'H':
-                return new String("....");
-            case 'I':
-                return new String("..");
-            case 'J':
-                return new String(".---");
-            case 'K':
-                return new String("-.-");
-            case 'L':
-                return new String(".-..");
-            case 'M':
-                return new String("--");
-            case 'N':
-                return new String("-.");
-            case 'O':
-                return new String("---");
-            case 'P':
-                return new String(".--.");
-            case 'Q':
-                return new String("--.-");
-            case 'R':
-                return new String(".-.");
-            case 'S':
-                return new String("...");
-            case 'T':
-                return new String("-");
-            case 'U':
-                return new String("..-");
-            case 'V':
-                return new String("...-");
-            case 'W':
-                return new String(".--");
-            case 'X':
-                return new String("-..-");
-            case 'Y':
-                return new String("-.--");
-            case 'Z':
-                return new String("--..");
-            case '_':
-                return new String("..--");
-            case ',':
-                return new String(".-.-");
-            case '.':
-                return new String("---.");
-            case '?':
-                return new String("----");
-
-        }
-
-        return new String();
+        
+        return vagner[(int)c];
     }
 
@@ -280,5 +284,9 @@
         StringBuilder lengths = new StringBuilder();
 
+        fs.fillVagner();
+
         while (true) {
+            
+     
             try {
                 line = br.readLine();