CODEWITHSUNDEEP
bashstring
Euphorbium
Euphorbium

Reputation: 1277

How to shift each letter of the string by a given number of letters?

How can i shift each letter of a string by a given number of letters down or up in bash, without using a hardcoded dictionary?

Upvotes: 21

Views: 45852

Answers (7)

gmagno
gmagno

Reputation: 2000

If you want to rotate also the capitals you could use something like this:

cat data.txt | tr 'a-z' 'n-za-m' | tr 'A-Z' 'N-ZA-M'

where data.txt has whatever you want to rotate.

Upvotes: 12

paxdiablo
paxdiablo

Reputation: 882646

If you mean something like ROT13, you can use tr:

pax$ echo 'hello there' | tr 'a-z' 'n-za-m'
uryyb gurer

pax$ echo 'hello there' | tr 'a-z' 'n-za-m' | tr 'a-z' 'n-za-m'
hello there

For a more general solution where you want to provide an arbitrary rotation (0 through 26), you can use:

#!/usr/bin/bash
    
dual=abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz
phrase='hello there'
rotat=13
newphrase=$(echo $phrase | tr "${dual:0:26}" "${dual:${rotat}:26}")
echo ${newphrase}

Upvotes: 38

Arpan Saini
Arpan Saini

Reputation: 5247

Problem statement and how this command can help you:

For example The password is stored in the file data.txt, where 13 positions have rotated all lowercase (a-z) and uppercase (A-Z) letters.

The data.txt file contains 1 line encrypted with the ROT13 ( rotation by 13) algorithm. In order to decrypt it, I have to replace every letter with the letter 13 positions ahead.

file contains the data as shown below

cat data.txt
Gur cnffjbeq vf WIAOOSFzMjXXBC0KoSKBbJ8puQm5lIEi

after rotation to 13 character, the password will look like this.

The password is JVNBBFSmZwKKOP0XbFXOoW8chDz5yVRv

The command to Do that is given below.

cat data.txt | tr '[A-Za-z]' '[N-ZA-Mn-za-m]'

Explanation of the Command

cat data.txt read all the character in data.txt file and then pass to tr command, tr commands takes two arguments, the first argument [A-Za-z] read only the characters made of A-Z or a-z. and in the second argument is rotation regular expression.

[13th character from A - ZA-12th character from A and same expression as for small letters]

[N-ZA-Mn-za-m]
 N : 13th character from A. 
 Z : to the end. 
 A : first character. 
 N : just a previous character from the 13th character. to complete the circle. 
 
 repeat the same expression for small letters.

We rotated by 13, you can replace the 13th and Previous character by any x position to rotate the string by x characters

Upvotes: 1

Surepic 342
Surepic 342

Reputation: 77

Without using tr, shift 1 to 25 characters and can be decrypted using 26 - original key

#!/bin/bash

#set -x

i=0
for letters in {A..Z}
do
abc_cap[$i]="$letters"
((i++))
done

i=0
for letters in {a..z}
do
abc_small[$i]="$letters"
((i++))
done

read -r -p "Enter message to be encrypted/decrypted: " -a message
read -r -p "Enter shift amount (26 - orig key for decrypt): " shift_amount

echo -n "Encrypted message: "

if [ "$shift_amount" -gt 25 ] || [ "$shift_amount" -lt 1 ]
then  
echo "Shift amount out of range"
exit  
fi  

for word in "${message[@]}"
do
 
while read -r -n 1 letter
do
if [[ "$letter" = [a-z] ]]
then
        for a in "${!abc_small[@]}"
        do
        if [ "${abc_small[$a]}" = "$letter" ]
        then
        a=$(echo "($a + $shift_amount) % 26" | bc)
        echo -n "${abc_small[$a]}"
        fi
        done

elif [[ "$letter" = [A-Z] ]]
then
        for a in "${!abc_cap[@]}"
        do
       if [ "${abc_cap[$a]}" = "$letter" ]
        then
        a=$(echo "($a + $shift_amount) % 26" | bc)
        echo -n "${abc_cap[$a]}"
        fi
        done

elif [[ "$letter" = "" ]]
then echo -n " "
 
else echo -n "$letter"
fi
 
done < <(echo "$word")
done
echo
exit

Upvotes: 0

KMA Badshah
KMA Badshah

Reputation: 1125

Shift by 12 characters(A becomes M, and vice versa)

Encryption
----------
$> echo ABCDE | tr '[A-Z]' '[M-ZA-L]' // prints MNOPQ

Decryption
----------
$> echo MNOPQ | tr '[M-ZA-L]' '[A-Z]' // prints ABCDE

In the encryption example, we are piping ABCDE to the command tr which is given two arguments. The first one is a matching string. It will match certain strings in your input(in our case ABCDE). The second argument works upon the result of the first argument and modifies it accordingly. So, we're basically matching any uppercase letter present in the input ABCDE and passing it to the second argument. The second argument replaces the characters with their 12th next counterpart. Now, this part is important to understand and might confuse some people, we're basically going from [M-L] in the second argument. Since the tr command doesn't accept this directly, we're breaking it up into two separate chunks. First chunk is [M-Z] and the second one is [A-L]. It's basically like a search-and-replace mechanism. You search with the first argument, modify with the second argument, as simple as that.

For the second example, I've just swapped the first argument with the second one in the tr command. Which acts perfectly as a decryptor. You could write it the same way as the first example, but I find it less time consuming when I have the encryption algorithm and I can just swap the arguments to have a decryption algorithm as well.

Upvotes: 3

Tima
Tima

Reputation: 21

Or

cat data.txt | tr 'a-zA-Z' 'n-za-mN-ZA-M'

It will also work

Upvotes: 2

Ignacio Vazquez-Abrams
Ignacio Vazquez-Abrams

Reputation: 799470

$ alpha=abcdefghijklmnopqrstuvwxyz
$ rot=3
$ sed "y/${alpha}/${alpha:$rot}${alpha::$rot}/" <<< 'foobar'
irredu

Upvotes: 9

Related Questions