친구가 컴퓨터에 익숙하지 않아서 실제 농담으로 누군가가 키보드에서 문자 (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}}

설명

• 입력은 람다에 대한 인수로 사용됩니다.
• 사용 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

여기에서 온라인으로 사용해보십시오.

감소에 사용하기 위해 K에 G를 저장하고 필터를 시작하기 위해 not (not (J))을 사용해야하는 것과 같이이 프로그램 바이트에 비용이 드는 불행한 결과가 상당히 있습니다. 이 때문에 나는 이것이 여전히 골프를 칠 수 있다고 생각합니다.

다음과 같은 입력을받는 프로그램입니다.

aebcdjfghiqklmnopzrstuvwxy
'John Doe'

(첫 번째 주장에 인용 부호가 없음에 유의하십시오)

피로를 무너 뜨린 후에 오는 설명;)

하스켈 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 트릭입니다.