您的朋友不太擅长使用计算机，所以有人打扰他键盘上的字母（az）成为一个恶作剧。当他坐下来尝试在键盘上键入自己的名字时，他意识到字母被打乱了，要求您的帮助。

您很聪明，所以您知道，如果他键入他的名字，然后重复输入屏幕上出现的内容而不是他的名字，他最终将成功输入他的名字。您也很友善并重新排列了按键，但想知道要成功旋转几圈。

您的任务是编写给定字母改组的程序或函数，而朋友的名字将计算转数。

输入详细信息：

• 以方便您的语言的结构形式输入了两个字符串作为输入。
• 第一个字符串是按照旧字母的字母顺序列出的新小写字母的列表。（第一个字符位于的位置a，最后一个字符位于的位置z。）字符串中总是会发生一些变化。
• 第二个字符串是名称。它可以包含任何可打印的ascii字符，但是只有大写和小写字母字符会被打乱。这个名字本身可能不会被改组。

输出详细信息：

• 输出是单个整数，最小所需匝数。换行符是可选的。

例子：

输入：（ 'abcfdeghijklmnopqrstuvwxyz' 'Mr. John Doe'更改了d，e，f个位置）

输出：（ 3显示的名称是：Mr. John Fod=> Mr. John Eof=> Mr. John Doe）

输入： 'nopqrstuvwxyzabcdefghijklm' 'Mr. John Doe'（ROT13密码）

输出：（ 2任何包含字母的输入名称都会2四舍五入以产生原始名称。）

输入： 'aebcdjfghiqklmnopzrstuvwxy' 'John Doe'

输出： 140

这是代码高尔夫球，因此最短的条目将获胜。

Pyth，16个字节

JGfqzuXGJrQ0UTz1

在这里尝试。

输入应在两行上给出，即名称和排列。排列应加引号。名称可以带引号或不带引号。例如：

"John Doe"
"aebcdjfghiqklmnopzrstuvwxy"

给出140。

说明：

                            Implicit:
                            z = input()              z is the name.
                            Q = eval(input())        Q is the permutation.
                            G = 'abcdefghijklmnopqrstuvwxyz'

JG                          J = G
  f             1           Starting at 1 and counting upwards, find
                            the first case where the following is true:
   qz                       z ==
     u       UTz            reduce, where the accumulator, G, is initialized to z on
      XG                    translate G
        J                   from the normal alphabet, J
         rQ0                to Q.lower().

CJam，31 27 25 24字节

l:A;lel:N{_A_$er_N#}g;],

采取以下形式的输入：

aebcdjfghiqklmnopzrstuvwxy
Mr. John Doe

即第一行-字母，第二行-名称。

运作方式：

l:A;lel:N{_A_$er_N#}g;],
l:A;                         "Read the alphabets from the 1st line in A and pop from stack";
    lel:N                    "Read the name in small caps from 2nd line and store in N";
         {         }g        "Run a while loop until we have the original name back again";
          _                  "Put a dummy string on stack just to keep count of times";
           A                 "Put the alphabets on stack";
            _$               "Copy them and sort the copy to get the correct order";
              er             "Transliterate the right keys with the wrong ones";
                _N#          "Copy the result and see if its equal to the original name";
                     ;]      "Pop the last name and wrap everything in an array";
                       ,     "Get the length now. Since we were putting a dummy string";
                             "on stack in each iteration of the while loop, this length";
                             "represents the number of times we tried typing the name";

在这里在线尝试

红宝石，58岁

->a,n{t=""+n
(1..2e3).find{t.tr!("a-zA-Z",a+a.upcase)==n}}

说明

• 输入作为lambda的参数。
• 使用Enumerable#find（感谢@Ventero！）和 String#tr!替换字符，直到替换的字符String与真实姓名匹配为止。

CJam，32 31字节

llel_2e3,{;'{,97>3$er_2$=}#)p];

在这里测试。它在输入的第一行接受排列，在第二行接受名称。

说明

llel_2e3,{;'{,97>3$er_2$=}#)p];
ll                              "Read both lines into strings.";
  el_                           "Convert the name to lower-case and duplicate.";
     2e3,                       "Get a range from 0 to 1999 to cover all possible results.";
         {               }#     "Find the first index where the block yields a true result.";
          ;                     "Discard the number, it's just a dummy.";
           '{,97>               "Create a string of the lower-case alphabet.";
                 3$             "Copy the permutation.";
                   er           "Substitute letters in the second copy of the name.";
                     _2$=       "Duplicate and check for equality with original name.";
                           )p   "Increment by 1 and print.";
                             ]; "Clear the stack to prevent extraneous output.";

腐霉菌 26

KGJ@GrQZfqJusm@zxKdGUTJ!!J

在这里在线尝试。

不幸的是，有很多不幸的结果使该程序字节耗费，例如必须将G存储在K中以在reduce中使用它，以及需要使用not（not（J））来启动过滤器。因此，我希望它仍然可以打高尔夫球。

这是一个需要输入如下内容的程序：

aebcdjfghiqklmnopzrstuvwxy
'John Doe'

（请注意第一个参数中没有引号）

筋疲力尽之后的解释;）

Haskell 131字节

import Data.Char
h n=(!!((ord n)-97))
g s n m|n==m=1|0<1=1+g s(h n s)m
f s=foldr1 lcm.map((\x->g s(h x s)x).toLower).filter isAlpha

f使用排列字符串和名称进行调用以获取结果

说明

-- h finds the mapping of a character given the permutation
h :: Char   -> -- Character to map
     String -> -- Character permutation
     Char      -- Mapped character

-- g finds the number of character mappings required to reach a given character
-- by calling h on the given character every time it calls itself.
g :: String -> -- The character permutation
     Char   -> -- The current character
     Char   -> -- The character to find
     Int       -- The number of mapped to find the character

-- f finds the number of mappings required to return the given string back to itself
-- by finding the lowest common multiple of the period of all the characters in the
-- given string
g :: String -> -- The permutation string
     String -> -- The string to get back
     Int       -- The final answer

GolfScript（33字节）

~{32|}%\:A&{.{A$?A=}%.-1$=!}do],(

将输入作为两个（单引号或双引号）带引号的字符串，并以任意数量的空格分隔；例如

'abcfdeghijklmnopqrstuvwxyz' 'Mr. John Doe'

在线演示

解剖

~           # Eval. Stack: perm name
{32|}%      # Lower-case name (also affects non-alphabetic characters but...)
\:A&        # Store perm in A and filter name to alphabetic characters, giving str_0
{           # do-while loop. Stack: str_0 str_1 ... str_i
  .         #   Duplicate str_i
  {A$?A=}%  #   tr 'a-z' perm   giving str_{i+1}
  .-1$=!    #   Loop while str_{i+1} != str_0
}do         # end do-while loop
],(         # Gather the sequence of permuted strings in an array and take its length - 1
            # to account for containing str_0 twice

音译依赖于所有字符都受影响的事实（{'ABC'?'abc'=}%用排序的字符串A$替换'ABC'和置换的A置换'abc'）；更为通用的替代方法无法节省足够的费用，因为对字母字符的过滤器非常便宜。

这也依赖于-1$访问堆栈的底部，这是一个相对罕见的GS技巧。