根据用户输入旋转给定列表中的索引，而旋转顺序则来自另一个列表中的索引

Question

This problem is from the ACM ICPC MidCentral 2014 problem set. Specifically, it is problem G, ReverseRot.

I have to write a program which takes a user inputted string, reverses it, and then rotates it according to a list containing the uppercase alphabet from A to Z, underscore, and period. So far, I've been able to do everything but rotate it correctly. This is the code I have thus far:

#character list which is referenced during the rotation
rotationList = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "_", "."] 
reverseRotList = [] #list which stores the completed rotation, later to be joined into a string

def reverse(string) : #reverses the string and stores each character in indexes within a list
    string = string[::-1]
    string = list(string)
    return string

string = input("What is the string? ").upper()
print(reverse(string)) #to show string was reversed and converted into a list correctly

rotAmount = int(input("Amount to be rotated? ")) #user decides how much rotation there will be

for i in string:

How would I rotate the string list according to the user input while rotating in accordance to the rotation list?

Answer 1

Building the rotated list

Method one

Say you have a sequence of numbers such as:

[0, 1, 2, 3, 4, 5, 6, 7]

and you want to rotate them by 3 to the left like this:

[3, 4, 5, 6, 7, 0, 1, 2]

Notice that the first three numbers are shifted by +3 from the original while the remaining two numbers are shifted by -5 from the original. Do you notice a pattern here?

The key thing to notice is that -5 is just +3 - 8 , where 8 is the length of the list. In other words, the numbers undergo an additive shift followed by a modulo operation :

new_i = (old_i - shift) % length

Now, what you have is not a list of numbers, but a list of characters, but the difference is superficial: applying the same transformation to the index of the strings leads to the same effect of a rotation:

new_list[old_i] = old_list[new_i]

Then it's just a matter of repeating this operation for every element in the list.

(There is a slight subtlety with regards to the sign of shift ; here, I use the convention that a positive shift is equivalent to rotating the values right.)

Method two

Another way is to think of a list rotation as a two step operation:

1. First you break up the list old_list into two parts: left_half and right_half .
2. Then you join them back together as right_half + left_half .

The main question here is: where do you break the list? It is again related to the amount you want to shift in a simple way:

break_index = shift % length

The modulo is needed because a rotation by an integer multiple of length has no real effect on your list.

Translating characters

To use the rotated list to translate a character (or a string of characters), you will need to find the location of the character in the original ordering:

index = old_list.index(character)

Then find the corresponding character in the rotated list:

translated_character = new_list[index]

Optimizations

Building the new_list that contains the rotated alphabet is actually unnecessary for performing translations. By performing some algebraic transformations, one see that the translated characters can be directly computed from the original alphabet:

translated_character = old_list[(index - shift) % length]

Additionally, using the index method is inefficient: it's better to construct a dictionary to speed up the lookups.