Sync

Task/Run-length-encoding/Befunge/run-length-encoding.bf

@@ -0,0 +1,26 @@
+                    ~"y"- ~$         v
+  <temp var for when char changes
+format:
+first,'n' and a newline.             :
+a char then a                   v    _"n",v
+number then a space continuously          9
+example:                                  1
+n                               >    v  ,+<
+a5 b2
+decoded:aaaaabb
+the program is ended using   decoder
+Ctrl-C on linux,or alt-f4
+on windows.copy the output    >\v       encoder
+of the program somewhere      ^_ $ v
+to encode press y              :        > $11g:,  v
+to decode pipe file in      >1-^   ~       v  +1\<
+the output of the encoder   \  v<  $    ^     .\_^
+starts with n,this is so    ^,:<\&~< _~:,>1>\:v>^
+you can pipe it straight in              ^        <
+                                              ~
+the spaces seem to be a annoying thing        :
+thanks to CCBI...if a interpreter dosen't     1
+create them it's non-conforming and thus      1
+the validity of this program is NOT affected  p-
+                                              >^
+--written by Gamemanj,for Rosettacode

Task/Run-length-encoding/Erlang/run-length-encoding-1.erl

@@ -0,0 +1,46 @@
+-module(rle).
+
+-export([encode/1,decode/1]).
+
+-include_lib("eunit/include/eunit.hrl").
+
+encode(S) ->
+    doEncode(string:substr(S, 2), string:substr(S, 1, 1), 1, []).
+
+doEncode([], CurrChar, Count, R) ->
+    R ++ integer_to_list(Count) ++ CurrChar;
+doEncode(S, CurrChar, Count, R) ->
+    NextChar = string:substr(S, 1, 1),
+    if
+        NextChar == CurrChar ->
+            doEncode(string:substr(S, 2), CurrChar, Count + 1, R);
+        true ->
+            doEncode(string:substr(S, 2), NextChar, 1,
+                R ++ integer_to_list(Count) ++ CurrChar)
+    end.
+
+decode(S) ->
+    doDecode(string:substr(S, 2), string:substr(S, 1, 1), []).
+
+doDecode([], _, R) ->
+    R;
+doDecode(S, CurrString, R) ->
+    NextChar = string:substr(S, 1, 1),
+    IsInt = erlang:is_integer(catch(erlang:list_to_integer(NextChar))),
+    if
+        IsInt ->
+            doDecode(string:substr(S, 2), CurrString ++ NextChar, R);
+        true ->
+            doDecode(string:substr(S, 2), [],
+                R ++ string:copies(NextChar, list_to_integer(CurrString)))
+    end.
+
+rle_test_() ->
+    PreEncoded =
+        "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW",
+    Expected = "12W1B12W3B24W1B14W",
+    [
+        ?_assert(encode(PreEncoded) =:= Expected),
+        ?_assert(decode(Expected) =:= PreEncoded),
+        ?_assert(decode(encode(PreEncoded)) =:= PreEncoded)
+    ].

Task/Run-length-encoding/Erlang/run-length-encoding-2.erl

@@ -0,0 +1,20 @@
+-module(rle).
+
+-export([encode/1, decode/1]).
+
+encode(L) -> encode(L, []).
+encode([], Acc) -> {rle, lists:reverse(Acc)};
+encode([H|T], []) ->
+    encode(T, [{1, H}]);
+encode([H|T], [{Count, Char}|AT]) ->
+    if
+        H =:= Char ->
+            encode(T, [{Count + 1, Char}|AT]);
+        true ->
+            encode(T, [{1, H}|[{Count, Char}|AT]])
+    end.
+
+decode({rle, L}) -> lists:append(lists:reverse(decode(L, []))).
+decode([], Acc) -> Acc;
+decode([{Count, Char}|T], Acc) ->
+    decode(T, [[Char || _ <- lists:seq(1, Count)]|Acc]).

Task/Run-length-encoding/Objeck/run-length-encoding.objeck

@@ -0,0 +1,52 @@
+use RegEx;
+
+class RunLengthEncoding {
+  function : Main(args : String[]) ~ Nil {
+    input := "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW";
+
+    encoded := Encode(input);
+    "encoding: {$encoded}"->PrintLine();
+    test := encoded->Equals("12W1B12W3B24W1B14W");
+    "encoding match: {$test}"->PrintLine();
+
+    decoded := Decode(encoded);
+    test := input->Equals(decoded);
+    "decoding match: {$test}"->PrintLine();
+  }
+
+  function : Encode(source : String) ~ String {
+    dest := "";
+    each(i : source) {
+      runLength := 1;
+      while(i+1 < source->Size() & source->Get(i) = source->Get(i+1)) {
+        runLength+= 1;
+        i+= 1;
+      };
+      dest->Append(runLength);
+      dest->Append(source->Get(i));
+    };
+
+    return dest;
+  }
+
+  function : Decode(source : String) ~ String {
+    output := "";
+    regex := RegEx->New("[0-9]+|([A-Z]|[a-z])");
+    found := regex->Find(source);
+    count : Int;
+    each(i : found) {
+      if(i % 2 = 0) {
+        count := found->Get(i)->As(String)->ToInt();
+      }
+      else {
+        letter := found->Get(i)->As(String);
+        while(count <> 0) {
+          output->Append(letter);
+          count -= 1;
+        };
+      };
+    };
+
+    return output;
+  }
+}

Task/Run-length-encoding/Ruby/run-length-encoding-1.rb

@@ -1,14 +1,9 @@
 def encode(string)
   string.scan(/(.)(\1*)/).collect do |char, repeat|
-    [char, 1 + repeat.length]
-  end
+    [1 + repeat.length, char]
+  end.join
 end
 
-def decode(encoding)
-  encoding.collect { |char, length| char * length }.join
+def decode(string)
+  string.scan(/(\d+)(\D)/).collect {|length, char| char * length.to_i}.join
 end
-
-orig = "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW"
-enc = encode(orig)    # => [["W", 12], ["B", 1], ["W", 12], ["B", 3], ["W", 24], ["B", 1], ["W", 14]]
-dec = decode(enc)
-puts "success!" if dec == orig

Task/Run-length-encoding/Ruby/run-length-encoding-2.rb

@@ -1,15 +1,11 @@
 def encode(string)
-  encoding = []
-  for char, repeat in string.scan(/(.)(\1*)/)
-    encoding << [char, 1 + repeat.length]
+  string.scan(/(.)(\1*)/).inject("") do |encoding, (char, repeat)|
+    encoding << (1 + repeat.length).to_s << char
   end
-  encoding
 end
 
-def decode(encoding)
-  decoding = ""
-  for char, length in encoding
-    decoding << char * length
+def decode(string)
+  string.scan(/(\d+)(\D)/).inject("") do |decoding, (length, char)|
+    decoding << char * length.to_i
   end
-  decoding
 end

Task/Run-length-encoding/Ruby/run-length-encoding-3.rb

@@ -5,6 +5,3 @@ end
 def decode(str)
     str.gsub(/(\d+)(\D)/) {$2 * $1.to_i}
 end
-
-encode('WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW') #=> "12W1B12W3B24W1B14W"
-decode('12W1B12W3B24W1B14W') #=> "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW"

Task/Run-length-encoding/Ruby/run-length-encoding-4.rb

@@ -0,0 +1,4 @@
+orig = "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW"
+p enc = encode(orig)
+p dec = decode(enc)
+puts "success!" if dec == orig