Run-length encoding (RLE) is a form of lossless data compression in which runs of data (sequences in which the same data value occurs in many consecutive data elements) are stored as a single data value and count, rather than as the original run.
This is most efficient on data that contains many such runs.
For example simple graphic images such as icons, line drawings, Conway's Game of Life, and animations.
For files that do not have many runs, RLE could increase the file size.
RLE is suited for compressing any type of data regardless of its information content, but the content of the data will affect the compression ratio achieved by RLE.
Although most RLE algorithms cannot achieve the high compression ratios of the more advanced compression methods, RLE is both easy to implement and quick to execute, making it a good alternative to either using a complex compression algorithm or leaving your image data uncompressed.
RLE works by reducing the physical size of a repeating string of characters.
This repeating string, called a run, is typically encoded into two bytes.
The first byte represents the number of characters in the run and is called the run count. In practice, an encoded run may contain 1 to 128 or 256 characters; the run count usually contains as the number of characters minus one (a value in the range of 0 to 127 or 255).
The second byte is the value of the character in the run, which is in the range of 0 to 255, and is called the run value.
Uncompressed, a character run of 15 A characters would normally require 15 bytes to store:
\nAAAAAAAAAAAAAAA
The same string after RLE encoding would require only two bytes:
\n15A
The 15A code generated to represent the character string is called an RLE packet. Here, the first byte, 15, is the run count and contains the number of repetitions. The second byte, A, is the run value and contains the actual repeated value in the run.
Consider a screen containing plain black text on a solid white background, over hypothetical scan line, it can be rendered as follows:
\n12W1B12W3B24W1B14W2W
This can be interpreted as a sequence of twelve Ws, one B, twelve Ws, three Bs, etc., and represents the original 67 characters in only 18.
\nWhile the actual format used for the storage of images is generally binary rather than ASCII characters like this, the principle remains the same.
\n\n\nPerform Run–length encoding (RLE) data compression algorithm on string
\nstr
def encode(s):\n\n encoding = \"\" # stores output string\n\n i = 0\n while i < len(s):\n # count occurrences of character at index `i`\n count = 1\n\n while i + 1 < len(s) and s[i] == s[i + 1]:\n count = count + 1\n i = i + 1\n\n # append current character and its count to the result\n encoding += str(count) + s[i]\n i = i + 1\n\n return encoding\n\n\nif __name__ == '__main__':\n\n s = 'ABBCCCD'\n print(encode(s))\nOutput:
\n1A2B3C1D
Run-length encoding (RLE) is a form of lossless data compression in which runs of data (sequences in which the same data value occurs in many consecutive data elements) are stored as a single data value and count, rather than as the original run.
This is most efficient on data that contains many such runs.
For example simple graphic images such as icons, line drawings, Conway's Game of Life, and animations.
For files that do not have many runs, RLE could increase the file size.
RLE is suited for compressing any type of data regardless of its information content, but the content of the data will affect the compression ratio achieved by RLE.
Although most RLE algorithms cannot achieve the high compression ratios of the more advanced compression methods, RLE is both easy to implement and quick to execute, making it a good alternative to either using a complex compression algorithm or leaving your image data uncompressed.
RLE works by reducing the physical size of a repeating string of characters.
This repeating string, called a run, is typically encoded into two bytes.
The first byte represents the number of characters in the run and is called the run count. In practice, an encoded run may contain 1 to 128 or 256 characters; the run count usually contains as the number of characters minus one (a value in the range of 0 to 127 or 255).
The second byte is the value of the character in the run, which is in the range of 0 to 255, and is called the run value.
Uncompressed, a character run of 15 A characters would normally require 15 bytes to store:
\nAAAAAAAAAAAAAAA
The same string after RLE encoding would require only two bytes:
\n15A
The 15A code generated to represent the character string is called an RLE packet. Here, the first byte, 15, is the run count and contains the number of repetitions. The second byte, A, is the run value and contains the actual repeated value in the run.
Consider a screen containing plain black text on a solid white background, over hypothetical scan line, it can be rendered as follows:
\n12W1B12W3B24W1B14W2W
This can be interpreted as a sequence of twelve Ws, one B, twelve Ws, three Bs, etc., and represents the original 67 characters in only 18.
\nWhile the actual format used for the storage of images is generally binary rather than ASCII characters like this, the principle remains the same.
\n\n\nPerform Run–length encoding (RLE) data compression algorithm on string
\nstr
def encode(s):\n\n encoding = \"\" # stores output string\n\n i = 0\n while i < len(s):\n # count occurrences of character at index `i`\n count = 1\n\n while i + 1 < len(s) and s[i] == s[i + 1]:\n count = count + 1\n i = i + 1\n\n # append current character and its count to the result\n encoding += str(count) + s[i]\n i = i + 1\n\n return encoding\n\n\nif __name__ == '__main__':\n\n s = 'ABBCCCD'\n print(encode(s))\nOutput:
\n1A2B3C1D
Nice article ! now i understand RLE
", "rawMarkdown": "Nice article ! now i understand RLE", "votes": null }, { "id": "1551180", "postDate": "10/20/2021 11:40:12", "content": "Thank you @vatsalsavaliya
", "rawMarkdown": "Thank you @vatsalsavaliya", "votes": null } ], "comments": [ { "id": 1550957, "author_name": "vatsalsavaliya", "author_url": "", "post_date": "10/20/2021 07:18:42", "content": "Nice article ! now i understand RLE
", "votes": null, "replies": [ { "id": 1551180, "author_name": "ishandutta", "author_url": "", "post_date": "10/20/2021 11:40:12", "content": "Thank you @vatsalsavaliya
", "votes": null, "replies": [] } ] } ], "raw_markdown_by_id": { "1550476": "### About\n\n- **Run-length encoding (RLE)** is a form of **lossless data compression** in which runs of data (sequences in which the same data value occurs in many consecutive data elements) are stored as a single data value and count, rather than as the original run. \n- This is most efficient on data that contains many such runs.\n- For example simple graphic images such as icons, line drawings, Conway's Game of Life, and animations. \n- For files that do not have many runs, RLE could increase the file size.\n- RLE is suited for compressing any type of data regardless of its information content, but the content of the data will affect the compression ratio achieved by RLE. \n- Although most RLE algorithms cannot achieve the high compression ratios of the more advanced compression methods, RLE is both *easy to implement and quick to execute*, making it a good alternative to either using a complex compression algorithm or leaving your image data uncompressed.\n \n- RLE works by reducing the physical size of a repeating string of characters. \n- This repeating string, called a run, is typically encoded into two bytes. \n- The first byte represents the number of characters in the run and is called the run count. In practice, an encoded run may contain 1 to 128 or 256 characters; the run count usually contains as the number of characters minus one (a value in the range of 0 to 127 or 255). \n- The second byte is the value of the character in the run, which is in the range of 0 to 255, and is called the run value. \n \n---\n \n### Example - 1 \n \n**Uncompressed**, a character run of 15 A characters would normally require 15 bytes to store: \n`AAAAAAAAAAAAAAA`\n\nThe same string after **RLE encoding** would require only two bytes: \n`15A`\n\nThe `15A` code generated to represent the character string is called an `RLE packet`. Here, the first byte, `15`, is the run count and contains the number of repetitions. The second byte, `A`, is the run value and contains the actual repeated value in the run.\n \n---\n \n### Example - 2\n \nConsider a screen containing plain black text on a solid white background, over hypothetical scan line, it can be rendered as follows: \n \n`12W1B12W3B24W1B14W2W` \n \nThis can be interpreted as a sequence of twelve Ws, one B, twelve Ws, three Bs, etc., and represents the original 67 characters in only 18. \n \nWhile the actual format used for the storage of images is generally binary rather than ASCII characters like this, the principle remains the same.\n \n---\n \n### Implementation:\n> Perform Run–length encoding (RLE) data compression algorithm on string `str`\n```\ndef encode(s):\n \n encoding = \"\" # stores output string\n \n i = 0\n while i < len(s):\n # count occurrences of character at index `i`\n count = 1\n \n while i + 1 < len(s) and s[i] == s[i + 1]:\n count = count + 1\n i = i + 1\n \n # append current character and its count to the result\n encoding += str(count) + s[i]\n i = i + 1\n \n return encoding\n \n \nif __name__ == '__main__':\n \n s = 'ABBCCCD'\n print(encode(s))\n```\n\n**Output:**\n`1A2B3C1D`\n \n---\n \n### Additional Resources\n- [Run-length encoding](https://en.wikipedia.org/wiki/Run-length_encoding)\n- [Lossless image compression](https://www.khanacademy.org/computing/computers-and-internet/xcae6f4a7ff015e7d:digital-information/xcae6f4a7ff015e7d:data-compression/a/simple-image-compression)\n- [Coding - Compression Run length encoding](https://www.csfieldguide.org.nz/en/chapters/coding-compression/run-length-encoding/)\n- [Run-Length Encoding (RLE)](https://www.fileformat.info/mirror/egff/ch09_03.htm)\n\n---", "1550957": "Nice article ! now i understand RLE", "1551180": "Thank you @vatsalsavaliya" }, "source": "meta" }