ASCII Code

The ASCII (American Standard Code for Information Interchange) character encoding standard is an encoding system that assigns a unique numerical code to each character (letters, numbers, symbols) on a computer, which facilitates the exchange of data between different computer systems.

This standard was published in 1963 (updated in 1967 and 1986) and contains 128 7-bit codes including 95 printable characters (i.e. the vast majority of characters allowing writing in English, but not fully in other languages, there are no accents for example).

Today this standard is outdated and supplanted by Unicode, which is backward compatible with ASCII.

Encoding/Encryption consists of replacing/translating each character with its value in the ASCII table (see below). This value can be written in several formats, depending on the needs, such as decimal, binary, hexadecimal or even octal.

ASCII decoding/conversion consists of replacing/translating each value (binary, octal, decimal or hexadecimal) with the corresponding character in the ASCII table. Its representation can be independently formatted into binary (0-1), octal (0-7), decimal (0-9) or hexadecimal (0-9a-f).

The message is generally written either in binary, or in decimal, or in hexadecimal (or rarely in octal).

The values are between 0 and 127 (decimal), the most common/frequent, corresponding to usual characters such as uppercase or lowercase letters are between 65 and 122 (decimal).

Typically, ASCII values (7 bits) are encoded as 1 byte (8 bits), with the first (left) bit always being 0.

Any reference to skiing (ASCII ≈ a ski) or sky is a clue.

The notion of American standard (USA) is a clue.

Computer languages usually use functions like fromCharCode(), CharCode(), Chr()

The ASCII table assigns a unique numeric code to each character, but this code (between 0 and 127) can be written in multiple ways depending on the needs.

— BIN: writing in binary base 2 (from 0 to 1111111)

— BIN /7: division every 7 bits (from 0000000 to 1111111)

— BIN /8: division every 8 bits (from 00000000 to 01111111)

— BIN /1-7: adaptive splitting between 1 and 7 bits

— BIN /1-8: adaptive splitting between 1 and 8 bits

— BIN /N: adaptive slicing from 1 to N bits

— OCT: writing in octal base 8 from (0 to 177)

— OCT /3: division every 3 digits (from 000 to 177)

— OCT /1-3: adaptive splitting of 1 to 3 octal digits

— OCT /N: adaptive slicing from 1 to N octal digits

— DEC: writing in decimal base 10 from (0 to 127)

— DEC /2: division every 2 digits (from 0 to 99, message without lower case)

— DEC /3: division every 3 digits (from 000 to 127)

— DEC /1-3: adaptive division of 1 to 3 digits

— DEC /N: adaptive division from 1 to N digits

— HEX: writing in base 16 hexadecimal (from 0 to 7F)

— HEX /2: division every 2 characters (from 00 to 7F)

— HEX /N: adaptive splitting from 1 to N hexadecimal digits

Adaptive splitting automatically reconstructs groups of bits according to the length needed to find a valid character.

Characters that are not valid in bases 2, 8, 10, or 16 are ignored during conversion.

Sometimes the symbols ⥅0 or ⥆0 are displayed, they mean that initial or final 0 have been added to allow decoding.

An ASCII code is represented on 7 bits, which allows 128 different characters to be represented.

In practice, the ASCII code is almost always represented on 1 byte (8bits) even if it occupies only 7bits.

In binary, use either 7 bits or 8 bits (by adding a leading zero) to represent an ASCII character.

In octal, it is represented with 3 characters (from 000 to 177).

In decimal, the value is between 0 and 127 (i.e. 1 to 3 digits).

In hexadecimal, 2 characters are used (from 00 to 7f).

In the ASCII code there is a difference of 32 between an uppercase letter and a lowercase letter. So add 32 to the ASCII code of a capital letter to get a lowercase and subtract 32 from the ASCII code of a lowercase letter to have a capital letter. The corresponding binary operation consists in setting the 5th bit (starting from the right) to 0 (upper case) or 1 (lower case).

Full 7-bit ASCII table

The values from 128 to 255 do not exist in the ASCII table. There are other tables often called extended ASCII which complement the ASCII code but are not ASCII.

Codes between 0 and 31 are control characters. They do not represent visible symbols, but control the behavior of a device (printer, terminal, etc.).

To encode accents, several Extended ASCII norms have been proposed. Several variants use the 8th bit to add other characters, often language- or system-specific, with codes 128 to 255.

— ISO/IEC 8859-1 (Latin-1): European standard adding accents (é, è, ç, ü, etc.).

— CP437: Original DOS character set, containing graphic symbols (frames, arrows, etc.).

— Windows-1252: Variant of Latin-1 used by Microsoft, with additional symbols (€, typographical quotation marks, etc.).

Here is the ISO/IEC 8859-1 (Latin-1) table:

The main difference between ASCII and Unicode lies in the number of characters they can represent.

ASCII is a historical standard based on 7 bits, with a total of 128 codes, sufficient to represent basic English characters (letters, numbers, and common symbols).

Unicode, the newer standard, is a universal standard that assigns a unique code to each character used in all the world's languages and scripts.

ASCII corresponds to the first part of Unicode (values 0 to 127, identical in both systems).

Today, UTF-8, based on Unicode, is the most widely used format: it can represent over a million different characters while remaining fully compatible with ASCII.

Here are some lines of source code for ASCII encoding and decoding: // Python
[ord(c) for c in "dCode"]

"".join(chr(n) for n in [100, 67, 111, 100, 101])

// PHP
foreach (str_split("dCode") as $c) echo ord($c).' ';

$codes = [100, 67, 111, 100, 101];
foreach ($codes as $n) echo chr($n);

// C
char *txt = "dCode";
for (int i = 0; txt[i] != "\0"; i++) printf("%d ", txt[i]);

int codes[] = {100, 67, 111, 100, 101};
for (int i = 0; i < 5; i++) printf("%c", codes[i]);

// JavaScript
[..."dCode"].map(c => c.charCodeAt(0))

String.fromCharCode(100, 67, 111, 100, 101)