Run-length encoding: Difference between revisions

{{task|Compression}}

 

 

 

: Input: <code>WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW</code>

: Output: <code>12W1B12W3B24W1B14W</code>

 

Note: the encoding step in the above example is the same as a step of the [[Look-and-say sequence]].

 

=={{header|Ada}}==

with Ada.Strings.Fixed; use Ada.Strings.Fixed;

procedure Test_Run_Length_Encoding is

Put_Line (Encode ("WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW"));

Put_Line (Decode ("12W1B12W3B24W1B14W"));

Sample output:

<pre>

WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW

</pre>

 

=={{header|ALGOL 68}}==

 

 

Note: The following uses iterators, eliminating the need of declaring arbitrarily large CHAR arrays for caching.

STRING output := "12W1B12W3B24W1B14W";

 

 

 

# Note: The following 2 lines use currying. This not supported by ELLA ALGOL 68RS #

 

INT count := 0;

CHAR prev;

IF count = 0 THEN

count := 1;

prev := c

STRING str count := whole(count,0);

yield(prev); prev := c

ELSE

count +:=1

FI

STRING str count := whole(count,0);

yield(prev)

FI

STRING zero2nine = "0123456789";

 

INT repeat := 0;

repeat := repeat*10 + ABS c - ABS "0"

ELSE

repeat := 0

FI

);

 

# iterate through input string #

print("Encode input: ");

print(c)

print(new line);

 

print("Decode output: ");

print(c)

<pre>

Encode input: 12W1B12W3B24W1B14W

Decode output: WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW

</pre>

=={{header|AutoHotkey}}==

MsgBox % rle_decode(key)

 

}

Return output

 

=={{header|BASIC}}==

{{trans|PowerBASIC}}

 

DECLARE FUNCTION RLEncode$ (i AS STRING)

 

outP = outP + tmp2

RLEncode$ = outP

 

Sample output (last one shows errors from using numbers in input string):

111r

rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr

 

=={{header|C}}==

See [[Run-length encoding/C]]

 

=={{header|C++}}==

#include <string>

#include <sstream>

}

return oss.str( ) ;

 

=={{header|Clojure}}==

 

 

 

 

=={{header|Common Lisp}}==

(loop for x in (rest sequence)

with temp = (subseq sequence 0 1)

 

(run-length-encode "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW")

 

=={{header|D}}==

void main() {

}

 

}

}

 

}

 

=={{header|E}}==

 

var seen := null

var count := 0

}

return result

 

# value: [[12, 'W'], [1, 'B'], [12, 'W'], [3, 'B'], [24, 'W'], [1, 'B'], [14, 'W']]

 

? unrle(rle("WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW"))

 

=={{header|Erlang}}==

A single-threaded/process version with a simple set of unit test.

 

 

-export([encode/1,decode/1]).

?_assert(decode(Expected) =:= PreEncoded),

?_assert(decode(encode(PreEncoded)) =:= PreEncoded)

 

=={{header|FALSE}}==

 

=={{header|Fan}}==

** Generates a run-length encoding for a string

**

 

override Str toStr() { return "${count}${char.toChar}" }

 

=={{header|Haskell}}==

 

-- Datatypes

type Decoded = String

 

-- Takes a decoded string and returns an encoded list of tuples

rlencode :: Decoded -> Encoded

 

-- Takes an encoded list of tuples and returns the associated decoded String

rldecode :: Encoded -> Decoded

 

main :: IO ()

main = do

decoded = rldecode encoded

 

=={{header|J}}==

'''Solution:'''

 

'''Example:'''

12W1B12W3B24W1B14W

 

rld '12W1B12W3B24W1B14W'

 

=={{header|Java}}==

import java.util.regex.Pattern;

public class RunLengthEncoding {

System.out.println(decode("1W1B1W1B1W1B1W1B1W1B1W1B1W1B"));

}

Tests:

 

{{libheader|JUnit}}

 

import org.junit.Test;

 

}

 

=={{header|JavaScript}}==

Here's an encoding method that walks the input string character by character

var encoding = [];

var prev, count, i;

encoding.push([count, prev]);

return encoding;

 

Here's an encoding method that uses a regular expression to grab the character runs ({{works with|JavaScript|1.6}} for the <code>forEach</code> method)

var encoding = [];

input.match(/(.)\1*/g).forEach(function(substr){ encoding.push([substr.length, substr[0]]) });

return encoding;

 

And to decode (see [[Repeating a string#JavaScript|Repeating a string]])

var output = "";

encoded.forEach(function(pair){ output += new Array(1+pair[0]).join(pair[1]) })

return output;

 

=={{header|Logo}}==

if empty? :str [output (word :out :count :last)]

if equal? first :str :last [output (encode bf :str :out :count+1 :last)]

make "foo "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW

make "rle encode :foo

 

=={{header|Lua}}==

 

astable = Ct(C(1)^0)

 

end

return ret

 

 

=={{header|MMIX}}==

GREG @

Buf OCTA 0,0,0,0 integer print buffer

2H SET $4,#a print NL

GO $127,PChar

Example run encode --> decode:

<pre>~/MIX/MMIX/Rosetta> mmix rle

12W1B12W3B24W1B14W

WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW</pre>

 

=={{header|Objective-C}}==

 

=={{header|OCaml}}==

let len = String.length str in

let rec aux i acc =

let decode lst =

let l = List.map (fun (c,n) -> String.make n c) lst in

 

let e = encode "aaaaahhhhhhmmmmmmmuiiiiiiiaaaaaa" in

List.iter (fun (c,n) ->

) e;

print_endline (decode [('a', 5); ('h', 6); ('m', 7); ('u', 1); ('i', 7); ('a', 6)]);

 

;Using regular expressions

 

open Str

let () =

print_endline (encode "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW");

 

=={{header|Oz}}==

fun {RLEncode Xs}

for G in {Group Xs} collect:C do

{System.showInfo Data}

{Show Enc}

 

=={{header|Perl}}==