A command to print only last 3 characters of a string

Question

I know that the cut command can print the first n characters of a string but how to select the last n characters?

If I have a string with a variable number of characters, how can I print only the last three characters of the string. eg.

"unlimited" output needed is "ted"
"987654" output needed is "654"
"123456789" output needed is "789"

Answer 1

Why has nobody given the obvious answer?

sed 's/.*\(...\)/\1/'

… or the slightly less obvious

grep -o '...$'

Admittedly, the second one has the drawback that lines with fewer than three characters vanish; but the question didn’t explicitly define the behavior for this case.

Answer 2

Keeping it simple - tail

We should not need a regular expression, or more than one process, just to count characters.
The command tail, often used to show the last lines of a file, has an option -c (--bytes), which seems to be just the right tool for this:

$ printf 123456789 | tail -c 3
789

(When you are in a shell, it makes sense to use a method like in the answer of mikeserv, because it saves starting the process for tail.)

Real Unicode characters?

Now, you ask for the last three characters; That's not what this answer gives you: it outputs the last three bytes!

As long as each character is one byte, tail -c just works. So it can be used if the character set is ASCII, ISO 8859-1 or a variant.

If you have Unicode input, like in the common UTF-8 format, the result is wrong:

$ printf 123αβγ | tail -c 3
�γ

In this example, using UTF-8, the greek characters alpha, beta and gamma are two bytes long:

$ printf 123αβγ | wc -c  
9

The option -m can at least count the real unicode characters:

printf 123αβγ | wc -m
6

Ok, so the last 6 bytes will give us the last 3 characters:

$ printf 123αβγ | tail -c 6
αβγ

So, tail does not support handling general characters, and it does not even try (see below): It handles variable size lines, but no variable size characters.

Let's put it this way: tail is just right for the structure of the problem to solve, but wrong for the kind of data.

GNU coreutils

Looking further, it turns out that thee GNU coreutils, the collection of basic tools like sed, ls, tail and cut, is not yet fully internationalized. Which is mainly about supporting Unicode.
For example, cut would be a good candidate to use instead of tail here for character support; It does have options for working on bytes or chars, -c (--bytes) and -m (--chars);

Only that -m/--chars is, as of version
cut (GNU coreutils) 8.21, 2013,
not implemented!

From info cut:

`-c CHARACTER-LIST'
`--characters=CHARACTER-LIST'
     Select for printing only the characters in positions listed in CHARACTER-LIST.  
     The same as `-b' for now, but internationalization will change that.

See also this answer to Can not use `cut -c` (`--characters`) with UTF-8?.

Answer 3

If your text is in a shell variable called STRING, you can do this in a bash, zsh, mksh or busybox ash shell:

printf '%s\n' "${STRING:(-3)}"

Or

printf '%s\n' "${STRING: -3}"

which also has the benefit to work with ksh93 where that syntax comes from.

The point is that the : has to be separated from the -, otherwise it becomes the ${var:-default} operator of the Bourne shell.

The equivalent syntax in the zsh or yash shells is:

printf '%s\n' "${STRING[-3,-1]}"

Answer 4

Using awk:

awk '{ print substr( $0, length() - 2) }' file
ted
654
789

Answer 5

If the string is in a variable you can do:

printf %s\\n "${var#"${var%???}"}"

That strips the last three characters from the value of $var like:

${var%???}

...and then strips from the head of $var everything but what was just stripped like:

${var#"${var%???}"}

This method has its upsides and downsides. On the bright side it is fully POSIX-portable and should work in any modern shell. Also, if $var does not contain at least three characters nothing but the trailing \newline is printed. Then again, if you want it printed in that case, you need an additional step like:

last3=${var#"${var%???}"}
printf %s\\n "${last3:-$var}"

In that way $last3 is only ever empty if $var contains 3 or fewer bytes. And $var is only ever substituted for $last3 if $last3 is empty or unset - and we know it is not unset because we just set it.

Answer 6

You can do this, but this is a little ... excessive:

words=( unlimited 987654 123456789 )

for s in "${words[@]}"; do
    rev <<< "$s" | cut -c 1-3 | rev
done 

ted
654
789

Answer 7

The bulletproof solution for utf-8 strings:

utf8_str=$'\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82' # привет

last_three_chars=$(perl -CAO -e 'print substr($ARGV[0], -3)' -- "$utf8_str")

(the -- is critical here, or you'd introduce an arbitary command injection vulnerability).

Or use:

last_three_chars=$(perl -MEncode -CO -e '
  print substr(decode("UTF-8", $ARGV[0], Encode::FB_CROAK), -3)
' -- "$utf8_str")

to prevent the malformed data handling.

Example:

perl -MEncode -CO -e '
  print substr(decode("UTF-8", $ARGV[0], Encode::FB_CROAK), -3)
' -- $'\xd0\xd2\xc9\xd7\xc5\xd4' # koi8-r привет

Outputs something like this:

utf8 "\xD0" does not map to Unicode at /usr/lib/x86_64-linux-gnu/perl/5.20/Encode.pm line 175.

Doesn't depend on locale settings (i.e. works with LC_ALL=C). Bash, sed, grep, awk, rev require something like this: LC_ALL=en_US.UTF-8

Common solution:

• Receive bytes
• Detect encoding
• Decode bytes to characters
• Extract charaсters
• Encode character to bytes

You can detect encoding with uchardet. See also related projects.

You can decode/encode with Encode in Perl, codecs in Python 2.7

Example:

Extract last three characters from utf-16le string and convert these characters to utf-8

utf16_le_str=$'\xff\xfe\x3f\x04\x40\x04\x38\x04\x32\x04\x35\x04\x42\x04' # привет

chardet <<<"$utf16_le_str"  # outputs <stdin>: UTF-16LE with confidence 1.0

last_three_utf8_chars=$(perl -MEncode -e '
    my $chars = decode("utf-16le", $ARGV[0]);
    my $last_three_chars = substr($chars, -3);
    my $bytes = encode("utf-8", $last_three_chars);
    print $bytes;
  ' "$utf16_le_str"
)

See also: perlunitut, Python 2 Unicode HOWTO

Answer 8

What about using "expr" or "rev" ?

An answer similar the one provided by @G-Man : expr "$yourstring" : '.*\(...\)$' It has the same drawback than the grep solution.

A well known trick is to combine "cut" with "rev" : echo "$yourstring" | rev | cut -n 1-3 | rev

Answer 9

Using Raku (formerly known as Perl_6)

The three main solutions employed here use either Raku's substr substring routine, or Raku's m/…/ match operator, or Raku's s/…/…/ substitution operator. Since Raku handles Unicode by default, many of the caveats listed within other answers to this question are obviated.

First three code examples return the last 3 characters per line (and a blank line if there are less than 3 characters available):

raku -ne 'put .substr( *-3 ) // "";' 

#OR

raku -ne 'put m{ .**3 $ } // "";'

#OR

raku -ne 'm{  .**3 $ } ?? $/.put !! "".put;' 

1. Example 1 uses Raku's substr (substring) routine in conjunction with the // "defined-OR" operator. The substr routine takes a $from-to parameter, and *-3 indicates the third character from the end. Note, substr actually takes a Range here, so .substr(*-3,*) also works, with * representing the last (rightmost) character. This answer could also be written in sub form à la Perl5 as: raku -ne 'put substr($_, *-3) // "";'.

2. The second answer uses Raku's m{ … } operator with user-defined delimiters (curly braces). The way to say three consecutive . characters of any kind is .**3. This is followed by the $ end-of-string zero-width assertion ($$ end-of-line zero-width assertion is also available in Raku). To handle the case where three characters are not available (and the match is therefore False/undefined), Raku's // "defined-OR" operator is employed to return an empty string.

3. Example 3 uses the m{ … } match operator in conjunction with Raku's <Test> ?? <True> !! <False> ternary operator, to handle cases similar to the first example. The True condition returns $/.put wherein $/ represents Raku's match variable. Currently, $<> can be used interchangeably with $/, for those who have an aversion to slash/backslash characters.

---

Below, returning last 1 to 3 characters per line, depending on character availability (will return a blank line if given a blank line):

raku -ne 'put m[ .**{0..3} $ ];' 

#OR

raku -pe 's/ .*? (.**3) $ /$0/;'     

#OR

raku -pe 's/ <(.*?)> .**3 $ //;'

Answers 4-through-6 (above) return 0 up to 3 characters, depending on character availability:

4. Again in example 4, the m[ … ] operator is employed with user defined delimiters (square braces). Here the match asks for .**{0..3} zero-to-three consecutive characters of any kind.
5. In example 5, the s/…/…/ substitution operator is employed. The first atom .*? non-greedily ("frugally") matches any character zero-or-more times (the trailing ? indicates frugal and changes the default greedy to non-greedy). The second atom matches and captures (.**3) any character zero-or-more times (the parentheses direct capturing). In the replacement half, the $0 capture is returned. Because the first atom is non-greedy, the $0 capture varies in length from 0 up to 3 characters.
6. Finally, in example 6 the s/…/…/ substitution operator is employed using a method that is somewhat opposite that of example 4. The same atoms as example 4 are employed, however this time the first atom <(.*?)> is captured. In fact, the <( … )> "pointy-curly" capture markers instruct Raku to drop anything outside of these markers. In the replacement half, this capture is deleted, leaving the .**3 $ second atom's characters.

---

Sample Input (first line is blank):

0
10
210
3210
43210
543210

Sample Output (code examples 1 through 3, three blank lines at top returned):

210
210
210
210

Sample Output (code examples 4 through 6, one blank line returned at top):

0
10
210
210
210
210

https://docs.raku.org/routine/substr
https://docs.raku.org/routine/substr-rw
https://raku.org

Answer 10

Get size of the string with:

size=${#STRING}

Then get substring of last n character:

echo ${STRING:size-n:size}

For example:

STRING=123456789
n=3
size=${#STRING}
echo ${STRING:size-n:size}

would give:

789

Answer 11

printf will not work if string has spaces in it.

Below code for string with space

str="Welcome to Linux"
echo -n $str | tail -c 3

nux

Answer 12

tail -n 1 revisions.log | awk '{ print substr( $0, 0, length($0)-(length($0)-13 )) }'

If you want to print first thirteen characters from the begining