Run-length encoding: Difference between revisions

{{trans|Python}}

 

V count = 1

V prev = Char("\0")

V value = encode(‘aaaaahhhhhhmmmmmmmuiiiiiiiaaaaaa’)

print(‘Encoded value is ’value.map(v -> String(v[1])‘’v[0]))

 

{{out}}

Output is in hexadecimal but is otherwise correct.

 

.stack 1024 ; load SP with 0400h

.data ; no data segment needed

OutputRam byte 256 dup (0)

 

 

{{out}}

 

=={{header|Action!}}==

CHAR c

BYTE len

PrintE("decoded:")

PrintE(decoded)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Run-length_encoding.png Screenshot from Atari 8-bit computer]

 

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

 

=={{header|AppleScript}}==

 

-- encode :: String -> String

end repeat

v

{{Out}}

<pre>W12B1W12B3W24B1W14

WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW

true</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|BASIC256}}==

function FBString(lon, cad$)

# Definimos la función String en BASIC256

print decoded$

end

{{out}}

La salida es similar a la de [[#BASIC|BASIC]], mostrada arriba.

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

 

 

return 0;

 

See [[Run-length encoding/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

Stringbuilder version. Might be more performant but mixes output formatting with encoding/decoding logic.

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

using System.Linq;

using static System.Console;

}

}

Output:

<pre>raw = WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW

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|C++}}==

#include <array>

#include <iterator>

std::cout.setf(std::cout.boolalpha);

std::cout << "Round trip works: " << (test_string == decoded_str) << '\n';

 

{{libheader|boost}}

#include <string>

#include <sstream>

}

return oss.str( ) ;

 

=={{header|Ceylon}}==

"Takes a string such as aaaabbbbbbcc and returns 4a6b2c"

assert (compress("WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW") == "12W1B12W3B24W1B14W");

assert (decompress("24a") == "aaaaaaaaaaaaaaaaaaaaaaaa");

 

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

=={{header|Delphi}}==

{{libheader| System.SysUtils}}

program RunLengthTest;

 

writeln(Data.Decode);

Readln;

{{out}}

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

 

=={{header|Elena}}==

import system'routines;

import extensions;

int count := 0;

char current := s[0];

{

if (ch == current)

char current := $0;

var a := new StringWriter();

{

current := ch;

s := compressor.decompress(s);

console.printLine(s)

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

 

=={{header|Emacs Lisp}}==

(let (output)

(with-temp-buffer

(count (skip-chars-forward (string char))))

(push (format "%d%c" count char) output))))

 

{{libheader|seq.el}}

 

(defun run-length-encode (str)

(apply #'concat (mapcar (lambda (items)

(format "%d%c" (length items) (car items)))

 

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

sequences.extras sequences.repeating splitting.extras

splitting.monotonic strings ;

"WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW"

"12W1B12W3B24W1B14W"

{{out}}

<pre>

 

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

 

end do

end subroutine

 

Output:

 

=={{header|FreeBASIC}}==

Dim As String initial, encoded, decoded

 

Print decoded

End

{{out}}

La salida es similar a la de [[#BASIC|BASIC]], mostrada arriba.

 

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

===In terms of group===

 

-- Datatypes

encoded = rlencode input

decoded = rldecode encoded

{{Out}}

<pre>Encoded: [(12,'W'),(1,'B'),(12,'W'),(3,'B'),(24,'W'),(1,'B'),(14,'W')]

 

Or:

import Data.List (group, groupBy)

 

decode = runLengthDecode encode

mapM_ putStrLn [text, encode, decode]

{{out}}

<pre>WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW

 

===In terms of span===

import Data.List (span)

 

src = "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW"

encoded = encode src

{{Out}}

<pre>W12B1W12B3W24B1W14

 

===As a fold===

 

runLengths :: String -> [(Int, Char)]

runLengths "" = []

 

--------------------------- TEST -------------------------

main = do

let testString =

encoded = runLengths testString

putStrLn $ showLengths encoded

 

------------------------- DISPLAY ------------------------

showLengths :: [(Int, Char)] -> String

showLengths [] = []

{{Out}}

<pre>12W1B12W3B24W1B14W

 

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

===ES5===

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;

 

===ES6===

By defining a generic ''group'' function:

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>From: "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW"

 

A <code>.reduce()</code> based one-liner

const rlEncode = (s: string) => s.match(/(.)\1*/g).reduce((result,char) => result+char.length+char[0],"")

const rlValidate = (s: string) => /^(\d+\D)+$/.test(s)

const rlDecode = (s: string) => rlValidate(s) ? s.match(/(\d[a-z\s])\1*/ig).reduce((res,p) => res+p[p.length-1].repeat(parseInt(p)),"") : Error("Invalid rl")

 

=={{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|M2000 Interpreter}}==

Module RLE_example {

inp$="WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW"

}

RLE_example

 

{{out}}

The function

 

 

takes as input an arbitrary string of characters and returns a list of {c, n} pairs, where c is the character and n is the number of repeats. The function

 

 

recreates the string.

Example: For the string

 

 

here is the run-length encoding:

 

 

 

Check that the input string is recreated:

 

 

 

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

 

proc compress(input: string): string =

let compressed = Text.compress()

echo "Compressed: ", compressed

 

{{out}}

 

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

 

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

function encode($str)

{

echo encode('WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW'), PHP_EOL;

echo decode('12W1B12W3B24W1B14W'), PHP_EOL;

 

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

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

prev = None

if value[1] == 0:

print("Encoded value is {}".format(value[0]))

 

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|Quackery}}==

<code>lookandsay</code> is defined at [[Look-and-say sequence#Quackery]].

 

 

[ $ "" 0 rot

dup echo$ cr

decode

 

{{out}}

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

count from 0, not from 1.

 

 

sub decode($str) { $str.subst(/(\d+) (.)/, { $1 x $0 }, :g) }

my $e = encode('WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW');

say $e;

 

Output:

Note that this REXX version (for encoding and decoding) uses a &nbsp; ''replication'' &nbsp; count, not the &nbsp; ''count'' &nbsp; of characters,

<br>so a replication count of &nbsp; '''11''' &nbsp; represents a count of &nbsp; '''12''' &nbsp; characters.

parse arg input . /*normally, input would be in a file. */

default= 'WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW'

$= $ || copies( substr(x, k, 1), n) /*N: is now the number of characters. */

j= j + # + 1 /*increment the DO loop index by D+1. */

{{out|output|text=&nbsp; when using the default input:}}

<pre>

 

===version 2===

/*REXX*/

s='WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW'

 

o: ol=ol||arg(1)

{{out}}

<pre> s=WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW

===version 3===

No need to output counts that are 1

/*REXX*/

s='WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW'

 

o: ol=ol||arg(1)

{{out}}

<pre> s=WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW

 

=={{header|Ring}}==

# Project : Run-length encoding

 

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|Rust}}==

s.chars()

// wrap all values in Option::Some

assert_eq!(text, decoded);

}

{{out}}

<pre>original: WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW

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)}'''

 

A simpler (?) decoder (that can handle a string like "2AB", producing "AAB"):

Code.findAllIn(s).foldLeft("") { case (acc, Code(len, c)) =>

acc + c * Option(len).map(_.toInt).getOrElse(1)

 

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

{{works with|Smalltalk/X}} (and others)

 

compress := [:string |

String streamContents:[:out |

]

].

 

-> '12W1B12W3B24W1B14W'

 

decompress value:'12W1B12W3B24W1B14W'

 

Most Smalltalk dialects include a class named "RunArray", which can be used as:

{{works with|Smalltalk/X}}

{{works with|VisualWorks}}

String streamContents:[:out |

string asRunArray runsDo:[:count :char |

 

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

 

Encoding:

ordcop: ord/copy;

ord: char(ch)/last [ch!=lch?]\new [cnt++] fail;

last: parse(out) [lch=0];

copy: smark any(!<<>>);

ch: 0;

lch: 0;

 

copy: smark any(!<<>>)

repeat: [n?] parse(( scopy )) [--n>0?]\repeat;

/* Reads decimal integer */

readint: proc(n;i) ignore(<<>>) [n=0] inta

int1: [n = n*12+i] inta\int1;

inta: char(i) [i<72?] [(i =- 60)>=0?];

i: 0;

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT,{}

input="WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW",output=""

PRINT input

PRINT output

Output:

<pre>

=={{header|UNIX Shell}}==

{{works with|bash}}

local phrase=$1

[[ -z $phrase ]] && return

# replace spaces with the char

echo "${result// /$char}"

Demo

enc=$(encode "$str")

dec=$(decode "$enc")

declare -p str enc dec

Output

<pre>declare -- str="WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW"

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.

 

=={{header|VBA}}==

Option Explicit

 

Next

length_decoding = a

{{out}}

<pre>12W1B12W3B24W1B14W

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

This methods supports any type of input.

BOF

While (!At_EOF) {

}

}

 

=={{header|Wren}}==

{{libheader|Wren-pattern}}

 

var p = Pattern.new("/u") // match any upper case letter

System.print("Original = decoded : %(s == d)\n")

}

 

{{out}}

 

=={{header|XPL0}}==

string 0; \use zero-terminated strings, instead of MSb terminated

 

CrLf(0);

Expand("W11BW11B2W23BW13"); CrLf(0);

 

Output (with slightly better compression than the example):

W11BW11B2W23BW13

WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW

</pre>

 

=={{header|zkl}}==

A byte stream to byte stream codec, the streams hard coded for ease. Character '\1' is used as a sentinel and there are limits on the run length to avoid byte overflow.

fcn compress(text){ // !empty byte/text stream -->Data (byte stream)

sink:=Data(); cnt:=Ref(0);

},text[0]) : write(_,cnt.value);

sink;

data.howza(3).pump(String,

fcn(c){ // if c==1, read n,c2 and expand, else write c

if(c=="\x01") return(Void.Read,2) else return(Void.Write,c) },

fcn(_,n,c){ c*n.toAsc() })

d:=compress(text);

d.bytes().println();

println(text.len()," bytes --> ",d.len()," bytes");

{{out}}

<pre>