Run-length encoding: Difference between revisions

{{Wikipedia|Run-length_encoding}}

{{task|Compression}}

[[Category: Encodings]]

 

 

 

: 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>

 

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

STRING output := "12W1B12W3B24W1B14W";

 

print(c)

# OD # );

Output:

<pre>

Encode input: 12W1B12W3B24W1B14W

Decode output: WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW

</pre>

 

=={{header|APL}}==

[1] count←∣2-/((1,(2≠/rll),1)×⍳1+⍴rll)~0

[2] ret←(⍕count,¨(1,2≠/rll)/rll)~' '

∇

Sample Output:

<pre>

12W1B12W3B24W1B14W

</pre>

 

=={{header|AutoHotkey}}==

MsgBox % rle_decode(key)

 

}

Return output

 

=={{header|AWK}}==

'''Encoding'''

 

FS=""

}

}

printf("%d%c", j, cp)

 

'''Decoding'''

 

RS="[0-9]+[^0-9]"

final = "";

END {

print final

 

=={{header|BaCon}}==

 

LOCAL result$, c$ = LEFT$(txt$, 1)

encoded$ = Rle_Encode$(rle_data$)

PRINT "Encoded: ", encoded$

{{out}}

<pre>RLEData: WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW

{{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|BBC BASIC}}==

The run counts are indicated by means of character codes in the range 131 to 255.

PRINT "Input: " input$

rle$ = FNencodeRLE(input$)

ENDIF

ENDWHILE

 

=={{header|Befunge}}==

Pipe the output of the program-it's more reliable.

{{works with|CCBI|2.1}}

<temp var for when char changes

format:

the validity of this program is NOT affected p-

>^

 

=={{header|Bracmat}}==

= character otherCharacter acc begin end

. :?acc

)

& run-length$WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW

<pre> 12W1B12W3B24W1B14W</pre>

 

=={{header|Burlesque}}==

"WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW"

=[{^^[~\/L[Sh}\m

 

=={{header|C}}==

Encoder that can deal with byte streams. Can encode/decode any byte values and any length with reasonable efficiency. Also showing OO and polymophism with structs.

#include <stdlib.h>

 

typedef struct stream_t stream_t, *stream;

struct stream_t {

or -1 to signify end of input */

int (*get)(stream);

 

return 0;

 

See [[Run-length encoding/C]]

 

=={{header|C sharp|C#}}==

=== Linq ===

<!--Martin Freedman 22/02/2018-->

using System.Linq;

using static System.Console;

}

}

Output:

<pre>raw = WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW

 

Many solutions do not follow the suggested output guideline in the challenge (not helped by its wording), instead producing a list of tuples or equivalent. This is much simpler (especially for decode) and the following provides an equivalent of those (IMHO deficient) solutions, to make comparisons easier.

using System.Linq;

using static System.Console;

string.Join(",", list.Select(t => $"[{t.i},{t.c}]"));

}

Output:

<pre>raw = WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW

Encode(raw) = encoded = [12,W],[1,B],[12,W],[3,B],[24,W],[1,B],[14,W]

Decode(encoded) = WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW

Decode(Encode(raw)) = True

</pre>

This example only works if there are no digits in the string to be encoded and then decoded.

 

{

string input = "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW";

}

return sb.ToString();

 

=== RegEx ===

Somewhat shorter, using Regex.Replace with MatchEvaluator (using C#2 syntax only):

using System.Text.RegularExpressions;

 

});

}

 

=={{header|Clojure}}==

(->> (partition-by identity s) (mapcat (juxt count first)) (apply str)))

 

(->> (re-seq #"(\d+)([A-Z])" s)

(mapcat (fn [[_ n ch]] (repeat (Integer/parseInt n) ch)))

 

=={{header|COBOL}}==

{{works with|GNU Cobol|2.0}}

IDENTIFICATION DIVISION.

PROGRAM-ID. run-length-encoding.

END-PERFORM

.

 

{{out}}

=={{header|CoffeeScript}}==

 

str.replace /(.)\1*/g, (w) ->

w[0] + w.length

console.log s = "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW"

console.log encode s

 

<pre>

The following version encodes the number of ocurrences as an unicode character. You can change the way it looks by rotating the offset.

 

str.replace /(.)\1*/g, (w) ->

w[0] + String.fromCharCode(offset+w.length)

str.split('').map((w,i) ->

if not (i%2) then w else new Array(+w.charCodeAt(0)-offset).join(str[i-1])

 

<pre>

 

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

(loop for x in (rest sequence)

with temp = (subseq sequence 0 1)

 

(run-length-encode "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW")

 

=={{header|D}}==

===Short Functional Version===

 

alias encode = group;

"WWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW";

assert(s.encode.decode.equal(s));

 

===Basic Imperative Version===

 

// Similar to the 'look and say' function.

writeln("Encoded: ", encoded);

assert(txt == encoded.decode);

{{out}}

<pre>Input: WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW

D's native string is utf-encoded. This version works for utf string, and uses a [[Variable-length_quantity|Variable-length Quantity]] [[Variable-length_quantity#D|module]].

 

import vlq;

 

auto sEncoded = RLE.init.encode(s).encoded ;

assert(s == RLE(sEncoded).decode(), "Not work");

 

output from "display.txt":

 

The code looks more complex than the third Python version because this also handles digits by escaping them with #.

std.algorithm;

 

"11#222##333";

assert(s == reDecode(reEncode(s)));

 

=={{header|Déjà Vu}}==

if not dup:

drop

rle "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW"

!. dup

{{out}}

<pre>[ & 12 "W" & 1 "B" & 12 "W" & 3 "B" & 24 "W" & 1 "B" & 14 "W" ]

"WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW"</pre>

 

=={{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"))

 

singleton compressor

{

if (ch == current)

count += 1

current := ch

^ tb

^ tb

}

{{out}}

<pre>

 

=={{header|Elixir}}==

def encode(str) when is_bitstring(str) do

to_char_list(str) |> encode |> to_string

|> Run_length.encode |> IO.inspect

|> Run_length.decode |> IO.inspect

 

{{out}}

'12W1B12W3B24W1B14W'

'WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW'</pre>

 

=={{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)

 

A version that works on character lists:

 

-module(rle).

 

decode([{Count, Char}|T], Acc) ->

decode(T, [[Char || _ <- lists:seq(1, Count)]|Acc]).

 

=={{header|Euphoria}}==

 

function encode(sequence s)

pretty_print(1,s,{3})

puts(1,'\n')

 

Output:

 

=={{header|F Sharp|F#}}==

open System

open System.Text.RegularExpressions

|> List.map (fun m -> Int32.Parse(m.Groups.[1].Value), m.Groups.[2].Value)

|> List.fold (fun acc (len, s) -> acc + String.replicate len s) ""

 

=={{header|FALSE}}==

 

=={{header|Fan}}==

** Generates a run-length encoding for a string

**

 

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

 

=={{header|Forth}}==

: n>a (.) tuck a @ swap move a +! ;

: >a a @ c! 1 a +! ;

i c@ digit? if 10 * i c@ [char] 0 - + else

a @ over i c@ fill a +! 0 then

 

Example:

 

here 1000 + encode here 2000 + decode cr 3 spaces type

 

=={{header|Fortran}}==

{{works with|Fortran|95 and later}}

implicit none

 

integer, parameter :: bufsize = 100 ! Sets maximum size of coded and decoded strings, adjust as necessary

call Encode(teststr, codedstr)

end do

end subroutine

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=b30707043cb64effba91a2edc4d4be94 Click this link to run this code]'''

Dim sString As String = "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW"

Dim siCount As Short = 1

Print sString & gb.NewLine & sHold.Join(", ")

 

Output:

<pre>

=={{header|Go}}==

Decoder kind of necessary to demonstrate task requirement that I can recreate the input.

 

import "fmt"

}

return string(d)

Output:

<pre>

 

=={{header|Groovy}}==

def encoded = new StringBuilder()

(text =~ /(([A-Z])\2*)/).each { matcher ->

}

decoded.toString()

Test code

def rleEncoded = rleEncode(text)

assert rleEncoded == '12W1B12W3B24W1B14W'

 

println "Original Text: $text"

Output:

<pre>Original Text: WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW

 

=={{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

main :: IO ()

main = do

decoded = rldecode encoded

 

 

main = do

{{out}}

12W1B12W3B24W1B14W

WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW

 

=={{header|Icon}} and {{header|Unicon}}==

 

s := "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW"

procedure Repl(n, c)

return repl(c,n)

 

Sample output:

=={{header|J}}==

'''Solution:'''

 

'''Example:'''

12W1B12W3B24W1B14W

 

rld '12W1B12W3B24W1B14W'

 

Note that this implementation fails for the empty case. Here's a version that fixes that:

 

 

Other approaches include using <nowiki>rle ::(''"_)</nowiki> or <nowiki>rle^:(*@#)</nowiki> or equivalent variations on the original sentence.

A numeric approach, based on a discussion in the J forums (primarily [http://jsoftware.com/pipermail/programming/2015-June/042139.html Pascal Jasmin] and [http://jsoftware.com/pipermail/programming/2015-June/042141.html Marshall Lochbaum]):

 

 

Task example:

 

12 87

1 66

14 87

u: frle torle a.i.'WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW'

 

Note that this approach also fails on the empty case.

 

=={{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|jq}}==

 

'''Utility function:'''

reduce .[] as $item

( [];

else . + [[$item, 1]]

end

'''Run-length encoding and decoding''':

explode | runs | reduce .[] as $x (""; . + "\($x[1])\([$x[0]]|implode)");

 

($pair[0:-1] | tonumber) as $n

| $pair[-1:] as $letter

'''Example''':

{{out}}

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

 

encode(str::String) = collect((length(g), first(g)) for g in groupby(first, str))

decoded = decode(encoded)

println("Original: $original\n -> encoded: $encoded\n -> decoded: $decoded")

 

{{out}}

=={{header|K}}==

 

 

{{trans|J}}

 

 

'''Example:'''

 

"12W1B12W3B24W1B14W"

rld "12W1B12W3B24W1B14W"

 

=={{header|Kotlin}}==

Tail recursive implementation of Run Length Encoding

if (text.isEmpty()){

return prev

assert(runLengthEncoding("WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW")

== "12W1B12W3B24W1B14W")

 

=={{header|Lasso}}==

local(orig = #str->values->asCopy,newi=array, newc=array, compiled=string)

while(#orig->size) => {

 

rlde('12W1B12W3B24W1B14W')

 

{{out}}

 

=={{header|Liberty BASIC}}==

 

'In$ ="aaaaaaaaaaaaaaaaaccbbbbbbbbbbbbbbba" ' testing...

next i

Decoded$ =r$

 

=={{header|LiveCode}}==

local charCount

put 1 into charCount

end repeat

return repStr

 

=={{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|Maxima}}==

[n: slength(a), b: "", c: charat(a, 1), k: 1],

for i from 2 thru n do

sconcat(b, k, c)

)$

 

rle("WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW");

 

=={{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

=={{header|Nim}}==

{{trans|Python}}

 

 

count = 1

else:

 

 

 

=={{header|Objeck}}==

 

class RunLengthEncoding {

return output;

}

 

<pre>encoding: 12W1B12W3B24W1B14W

 

=={{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|Oforth}}==

 

StringBuffer new

s group apply(#[ tuck size asString << swap first <<c ]) ;

loop: i [ c <<c ] 0

]

 

{{out}}

</pre>

 

=={{header|Oz}}==

fun {RLEncode Xs}

for G in {Group Xs} collect:C do

{System.showInfo Data}

{Show Enc}

=={{header|PARI/GP}}==

if(s=="", return(s));

my(v=Vec(s),cur=v[1],ct=1,out="");

};

rle("WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW")

Output:

<pre>%1 = "12W1B12W3B24W1B14W"

 

=={{header|Pascal}}==

procedure encode(s: string; var counts: array of integer; var letters: string);

decode(s, counts, letters);

writeln(s);

Output:

<pre>:> ./RunLengthEncoding

Simple version using ASCII numerals as length markers, like the example in the task description (won't work correctly on input strings that already contain digits):

 

shift =~ s/(.)\1*/length($&).$1/grse;

}

sub decode {

shift =~ s/(\d+)(.)/$2 x $1/grse;

 

Modified version that can take arbitrary byte strings as input (produces encoded byte strings that are compatible with the [[#C|C solution]]):

 

shift =~ s/(.)\1{0,254}/pack("C", length($&)).$1/grse;

}

sub decode {

shift =~ s/(.)(.)/$2 x unpack("C", $1)/grse;

 

Further modified version that supports compact representation of longer non-repeating substrings, just like the [[#C|C solution]] (so should be fully compatible with that solution for both encoding and decoding):

 

my $str = shift;

my $ret = "";

}

return $ret;

 

Demonstration of the third version:

 

dd my $str = "XXXXXABCDEFGHIoooooooooooooooooooooooooAAAAAA";

dd my $enc = encode($str);

 

{{out}}

"XXXXXABCDEFGHIoooooooooooooooooooooooooAAAAAA"

</pre>

 

=={{header|Phix}}==

{{out}}

<pre>

{12,87'W',1,66'B',12,87'W',3,66'B',24,87'W',1,66'B',14,87'W'}

 

=={{header|PHP}}==

}

 

}

 

 

=={{header|PicoLisp}}==

(pack

(make

(prinl "Data: " "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW")

(prinl "Encoded: " (encode @))

Output:

<pre>Data: WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW

 

=={{header|PL/I}}==

declare run_length fixed binary;

declare input file;

end;

put edit ((c do i = 1 to run_length)) (a);

 

=={{header|PowerBASIC}}==

This version can handle any arbitrary string that doesn't contain numbers (not just letters). (A flag value could be added which would allow the inclusion of ''any'' character, but such a flag isn't in this example.)

 

DIM Loop0 AS LONG, rCount AS STRING, outP AS STRING, m AS STRING

 

'in PB/Win, "?" = MSGBOX; in PB/DOS & PB/CC. "?" = PRINT

? initial & $CRLF & encoded & $CRLF & decoded

 

Outputs are similar to those in [[#BASIC|BASIC]], above.

 

=={{header|PowerShell}}==

$re = [regex] '(.)\1*'

$ret = ""

}

return $ret

Output:

<pre>PS> Compress-RLE "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW"

PS> Expand-RLE "12W1B12W3B24W1B14W"

WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW</pre>

=={{header|Prolog}}==

Works with SWI-Prolog.<br>

This code is inspired from a code found here : http://groups.google.com/group/comp.lang.prolog/browse_thread/thread/b053ea2512e8b350 (author : Pascal J. Bourguignon).

run_length :-

L = "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW",

 

run(Var,[Other|RRest], [1,Var],[Other|RRest]):-

Output :

<pre> ?- run_length.

 

=={{header|Pure}}==

 

encode s = strcat $ map (sprintf "%d%s") $ encode $ chars s with

let s = "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW";

let r = encode s; // "12W1B12W3B24W1B14W"

 

=={{header|PureBasic}}==

{{trans|PowerBasic}} with some optimations to use pointers instead of string functions. According to the task description it works with uppercase A - Z. In this implementation it also functions with all characters that are non-digits and whose value is non-zero.

Protected.s repCount, output, currChar, tmp

Protected *c.Character = @toDecode

Input()

CloseConsole()

Sample output:

<pre>Type something: WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWW

 

=={{header|Python}}==

count = 1

lst = []

for character in input_string:

if character != prev:

if prev:

lst.append(entry)

count = 1

prev = character

count += 1

else:

def decode(lst):

for character, count in lst:

#Method call

 

Functional

{{works with|Python|2.4}}

def encode(input_string):

return [(len(list(g)), k) for k,g in groupby(input_string)]

 

encode("aaaaahhhhhhmmmmmmmuiiiiiiiaaaaaa")

 

<br>'''By regular expression'''<br>

The simplified input range of only uppercase characters allows a simple regular expression to be applied repeatedly for encoding, and another for decoding:

 

def encode(text):

 

textin = "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW"

 

=={{header|R}}==

R has a built-in function, rle, for run length encoding. This modification allows input and output in the forms specified above.

{

splitx <- unlist(strsplit(input, ""))

 

input <- "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW"

Similarly, inverse.rle provides decompression after a run length encoding.

{

lengths <- as.numeric(unlist(strsplit(output, "[[:alpha:]]")))

 

output <- "12W1B12W3B24W1B14W"

 

=={{header|Racket}}==

 

#lang racket

(define (encode str)

(define (decode str)

(regexp-replace* #px"([0-9]+)(.)" str (λ (m n c) (make-string (string->number n) (string-ref c 0)))))

 

=={{header|REXX}}==

The task (input) rule was relaxed a bit as this program accepts upper─ and lowercase input.

 

 

 

<pre>

decoded= WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW

</pre>

 

===version 2===

Say ' s='s

enc=encode(s)

 

o: ol=ol||arg(1)

{{out}}

<pre> s=WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW

===version 3===

No need to output counts that are 1

Say ' s='s

enc=encode(s)

 

o: ol=ol||arg(1)

{{out}}

<pre> s=WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW

 

=={{header|Ring}}==

# Project : Run-length encoding

 

load "stdlib.ring"

see dec

next

Output:

<pre>

12W1B12W3B24W1B14W

WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW

</pre>

 

Ruby has built-in run-length encoding in the form of <code>chunk</code>, here I provide a thin wrapper around it:

 

# run_encode("aaabbbbc") #=> [["a", 3], ["b", 4], ["c", 1]]

def run_encode(string)

end

 

 

string.scan(/(.)(\1*)/).collect do |char, repeat|

[1 + repeat.length, char]

def decode(string)

string.scan(/(\d+)(\D)/).collect {|length, char| char * length.to_i}.join

 

This usage also seems to be idiomatic, and perhaps less cryptic:

string.scan(/(.)(\1*)/).inject("") do |encoding, (char, repeat)|

encoding << (1 + repeat.length).to_s << char

decoding << char * length.to_i

end

 

<br>'''By regular expression'''<br>

The simplified input range of only uppercase characters allows a simple regular expression to be applied repeatedly for encoding, and another for decoding:

str.gsub(/(.)\1*/) {$&.length.to_s + $1}

end

def decode(str)

str.gsub(/(\d+)(\D)/) {$2 * $1.to_i}

 

'''Test:'''

p enc = encode(orig)

p dec = decode(enc)

 

{{out}}

 

=={{header|Run BASIC}}==

beg = 1

i = 1

beg = i

if i < len(press$) then goto [expand]

<pre>Compressed:12W1B12W3B24W1B14W

Expanded:WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW</pre>

 

=={{header|Scala}}==

Care is taken to use StringBuilder for performance reasons.

 

case ((len, c, sb), index) if c != s(index) => sb.append(len); sb.append(c); (1, s(index), sb)

case ((len, c, sb), _) => (len + 1, c, sb)

for (Code(len, c) <- Code findAllIn s) sb.append(c * len.toInt)

sb.toString

 

A simpler (?) encoder:

s.foldLeft((0,s(0),""))( (t,c) => t match {case (i,p,s) => if (p==c) (i+1,p,s) else (1,c,s+i+p)})

match {case (i,p,s) => s+i+p}

 

To make it faster (it's also faster than the longer implementation above) just replace '''""''' with '''new StringBuilder''' and '''s+i+p''' with '''{s.append(i);s.append(p)}'''

 

=={{header|Scheme}}==

(apply string-append (map (lambda (p) (make-string (car p) (cdr p))) v)))

 

; ((12 . #\W) (1 . #\B) (12 . #\W) (3 . #\B) (24 . #\W) (1 . #\B) (14 . #\W))

(run-length-decode '((12 . #\W) (1 . #\B) (12 . #\W) (3 . #\B) (24 . #\W) (1 . #\B) (14 . #\W)))

 

=={{header|sed}}==

The encode script:

/^$/ b

:start

s/^([0-9]+.)(.*)/\2\1/

b start

 

The decode script:

/^$/ b

:start

s/^0+//

b loop }

 

Example (assuming the scripts reside in the files <code>encode.sed</code> and <code>decode.sed</code>):

sed -rf encode.sed <<< "foo oops"

# 1f2o1 2o1p1s

(sed -rf decode.sed | sed -rf encode.sed) <<< 1000.

# 1000.

 

=={{header|Seed7}}==

include "scanstri.s7i";

 

writeln(letterRleEncode("WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW"));

writeln(letterRleDecode("12W1B12W3B24W1B14W"));

 

=={{header|Sidef}}==

First solution:

str.gsub(/((.)(\2*))/, {|a,b| "#{a.len}#{b}" });

}

func decode(str) {

str.gsub(/(\d+)(.)/, {|a,b| b * a.to_i });

{{out}}

<pre>12W1B12W3B24W1B14W</pre>

 

Second solution, encoding the length into a byte:

str.gsub(/(.)(\1{0,254})/, {|a,b| b.len+1 -> chr + a});

}

}

return r;

{{out}}

<pre>"\fW\1B\fW\3B\30W\1B\16W"</pre>

=={{header|Smalltalk}}==

See [[Run-length encoding/Smalltalk]]

 

=={{header|SNOBOL4}}==

{{works with|CSnobol}}

 

define('rle(str)c,n') :(rle_end)

rle str len(1) . c :f(return)

str = rle(str); output = str

str = elr(str); output = str

 

Output:

12W1B12W3B24W1B14W

WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW</pre>

 

=={{header|SQL}}==

<br>

* RLE encoding

-- variable table

drop table if exists var;

where noWithinGroup = 1

) Rle_Compressed

 

* RLE decoding

-- variable table

DROP TABLE IF EXISTS var;

string_agg(replicated_Letter, '' ORDER BY group_no) decoded_string

FROM lettersReplicated

 

=={{header|Standard ML}}==

let

fun aux (sub, acc) =

 

fun decode lst =

Example:

<pre>

=={{header|Swift}}==

Using array as the internal representation of the encoded input:

 

// "WWWBWW" -> [(3, W), (1, B), (2, W)]

return encoded.reduce("") { $0 + String(count: $1.0, repeatedValue: $1.1) }

}

 

'''Usage:'''

 

let input = "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW"

let output = decode(encode(input))

print(output == input)

 

{{Out}}

Converting encoded array into the string and then decoding it using NSScanner:

 

func decode(encoded: String) -> String {

let scanner = NSScanner(string: encoded)

return out

}

 

print(encodedString)

let outputString = decode(encodedString)

print(outputString == input)

 

{{Out}}

=={{header|Tcl}}==

The encoding is an even-length list with elements <tt>{count char ...}</tt>

set encoding {}

# use a regular expression to match runs of one character

}

return $decoded

 

set enc [encode $str] ;# ==> {12 W 1 B 12 W 3 B 24 W 1 B 14 W}

set dec [decode $enc]

if {$str eq $dec} {

puts "success"

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT,{}

input="WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW",output=""

PRINT input

PRINT output

Output:

<pre>

12W1B12W3B24W1B14W

</pre>

 

=={{header|Ursala}}==

which is a second order function taking a binary predicate that decides

when consecutive items of an input list belong to the same run.

#import nat

 

<

encode test_data,

The output shows an encoding of the test data, and a decoding of the encoding, which

matches the original test data.

<pre>12W1B12W3B24W1B14W

WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW</pre>

Newlines are not converted (the regular expression does not count newlines).

This methods supports any type of input.

BOF

While (!At_EOF) {

}

}