Roy‘s friends has been spying on his text messages, so Roy thought of an algorithm to encrypt text messages.

Encryption Algorithm is as follows:
We say message to be encrypted as Plain Text and encrypted form of message as Cipher.
Plain Text consists of lower case alphabets only.
Consider the Cipher Disk as shown in figure.

Initially, we start with 0 (zero). For each character in Plain Text, we move either clockwise or anti-clockwise on the disk depending on which way is closest from where we are currently standing.
If both clockwise and anti-clockwise distances are equal, we give priority to clockwise movement.
Clockwise movements are represented using positive numbers while Anti-clockwise movements are represented as negative numbers.

Roy needs your help in implementing this algorithm. Given a Plain Text message, your task is to encrypt it using above algorithm and print the Cipher Text.

Input:
First line contains integer T - number of test cases.
Each of next T lines contains a string representing Plain Text message.

Output:
For each test case, print the encrypted form of given string in new line.

Constraints:
1 <= T <= 100
1 <= Length of Plain Text string <= 100

Sample Test Case Explanation:
Explanation for 3rd sample test case "correct"

3
aeiou
hackerearth
correct

0 4 4 6 6
7 -7 2 8 -6 13 13 -4 -9 2 -12
2 12 3 0 13 -2 -9

We begin from 0 (zero) 1. ‘a‘->‘c‘ - two steps clockwise, we reach ‘c‘ 2. ‘c‘->‘o‘ - twelve steps clockwise, we reach ‘o‘ 3. ‘o‘->‘r‘ - three steps clockwise, we reach ‘r‘ 4. ‘r‘->‘r‘ - we are already at ‘r‘, so zero steps 5. ‘r‘->‘e‘ - thirteen steps clockwise, we reach ‘e‘ 6. ‘e‘->‘c‘ - here moving anti-clockwise is optimal, so two steps anticlockwise, and for anticlockwise we add negative sign. 7. ‘c‘->‘t‘ - again anti-clockwise, nine steps.

就是用0到26來代碼A到Z字母，然後根據輸入的字符串轉換成，兩個字母間的最小距離,用到了判斷絕對值的函數。其中 leftValue 為順時針計算的距離，rightValue 是逆時針計算的距離，然後取絕對值小的數值。

package main

import (
	"fmt"
)

var step int = 97

func CalcAbs(a int) (ret int) {
	ret = (a ^ a>>31) - a>>31
	return
}
func main() {
	var numCount int
	fmt.Scanln(&numCount)
	var question string
	var Previous int = -1
	for i := 0; i < numCount; i++ {
		fmt.Scanln(&question)
		for _, v := range question {
			if Previous == -1 {
				Previous = int(v) - 97
				fmt.Print(int(v)-97, " ")
			} else {
				var current = int(v) - 97
				var leftValue, rightValue int
				if current >= Previous {
					rightValue = current - Previous
					leftValue = 26 - current + Previous
				} else {
					leftValue = 26 - Previous + current
					rightValue = current - Previous
				}
				//fmt.Printf("left:%d-right:%d", left, right)
				//fmt.Println("")
				if CalcAbs(leftValue) > CalcAbs(rightValue) {
					fmt.Print(rightValue, " ")
				} else {
					fmt.Print(leftValue, " ")
				}
				Previous = current
			}
		}
		fmt.Println("")
	}
}

golang 輪訓加密算法