Tu amigo no es muy bueno con las computadoras, así que, como una broma práctica, alguien revolvió las letras (az) en su teclado. Cuando se sentó e intentó escribir su nombre mirando el teclado, se dio cuenta de que las letras estaban codificadas y le pidió ayuda.

Eres inteligente, así que sabes que si escribe su nombre y luego vuelve a escribir repetidamente lo que aparece en la pantalla en lugar de su nombre, eventualmente ingresará su nombre. También es amable y reorganiza las teclas, pero desea saber cuántos giros se necesitarían para tener éxito.

Su tarea es escribir un programa o función que, dada la combinación de las letras y el nombre del amigo, calcule el número de turnos.

Detalles de entrada:

Se proporcionan dos cadenas como entrada en una estructura conveniente para su idioma.
La primera cadena es la lista de las nuevas letras minúsculas en orden alfabético de las antiguas. (El primer carácter es el que está en la posición de a, el último está en la posición de z). Siempre se producirá algún cambio en la cadena.
La segunda cadena es el nombre. Podría contener cualquier carácter ascii imprimible, pero solo los caracteres alfabéticos en mayúscula y minúscula se mezclarán si los hay. El nombre en sí podría no ser barajado en todos

Detalles de salida:

La salida es un número entero, el número de vueltas mínimamente requerido. Newline es opcional.

Ejemplos:

Entrada: 'abcfdeghijklmnopqrstuvwxyz' 'Mr. John Doe'(d, e, f posiciones cambiadas)

Salida: 3(Los nombres que se muestran son: Mr. John Fod=> Mr. John Eof=> Mr. John Doe)

Entrada: 'nopqrstuvwxyzabcdefghijklm' 'Mr. John Doe'(el cifrado ROT13 )

Salida: 2(Cualquier nombre de entrada que contenga letras tomará 2rondas para producir el nombre original).

Entrada: 'aebcdjfghiqklmnopzrstuvwxy' 'John Doe'

Salida: 140

Este es el código de golf, por lo que gana la entrada más corta.

code-golf string permutations

— randomra
fuente

1

Probablemente debería incluir este caso de prueba: aebcdjfghiqklmnopzrstuvwxy(salida 1260 para Mr John Doe). Este es el máximo posible: consiste en ciclos de orden 4, 5, 7, 9 (y sin cambios a), y cada nombre que contenga al menos una letra de cada ciclo producirá 1260. Y supongo que tomar el alfabeto como entrada o el uso de un nombre no afectado también son casos importantes.

— Martin Ender

@ MartinBüttner Agregado con modificación.

— randomra

Estoy un poco confundido acerca de cómo se te ocurre la cantidad de vueltas.

— FUZxxl

@FUZxxl En general, puede descomponer la permutación en ciclos , luego verifica qué ciclos incluyen caracteres del nombre. El resultado es el MCM de las longitudes de esos ciclos (los ciclos a través de caracteres que no están en el nombre son irrelevantes, por supuesto). Sin embargo, para este desafío, eso no es realmente necesario ... solo realice las sustituciones hasta que llegue al nombre original y cuente con qué frecuencia tuvo que sustituir.

— Martin Ender

1

Como nota al margen, John File Marker aka EOFes totalmente increíble.

— rev

9

Pyth, 16 bytes

JGfqzuXGJrQ0UTz1

Pruébalo aquí

La entrada debe darse en dos líneas, nombre y luego permutación. La permutación debe ser citada. El nombre puede ser citado o no citado. Por ejemplo:

"John Doe"
"aebcdjfghiqklmnopzrstuvwxy"

Da 140.

Explicación:

                            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().

— isaacg
fuente

El método de entrada debe ser idéntico para las cadenas.

— randomra

10

CJam, 31 27 25 24 bytes

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

Toma entrada en forma de:

aebcdjfghiqklmnopzrstuvwxy
Mr. John Doe

es decir, primera línea - alfabetos, segunda línea - nombre.

Cómo funciona :

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";

Pruébalo en línea aquí

— Optimizador
fuente

5

Rubí, 58

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

Explicación

La entrada se toma como argumentos para una lambda.
Use Enumerable#find(¡gracias @Ventero!) Y String#tr!para reemplazar caracteres hasta que el reemplazado Stringcoincida con el nombre real.

— britishtea
fuente

""+nes un poco más corto que n.dup, y puede guardar otro byte haciendo un uso creativo en Enumerable#findlugar de usar un contador explícito:(1..1e4).find{t.tr!(...)==n}

— Ventero

Además, puede guardar muchos bytes haciendo que la entrada sea minúscula

— Optimizer

@Optimizer Eso no parece ahorrarme nada, el método de Ruby para convertir a minúsculas es bastante largo (tendría que usarlo n.downcase!).

— britishtea

Sí, pero no tienes que hacerlo A-Zy+a.upcase

— Optimizer

A-Z+a.upcasey n.downcase!\ntienen la misma duración :)

— britishtea

2

CJam, 32 31 bytes

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

Pruébalo aquí. Toma la permutación en la primera línea y el nombre en la segunda línea de la entrada.

Explicación

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.";

— Martin Ender
fuente

2

Pyth 26

KGJ@GrQZfqJusm@zxKdGUTJ!!J

Pruébelo en línea aquí.

Hay bastantes consecuencias desafortunadas que le cuestan a este programa bytes, como tener que almacenar G en K para usarlo en la reducción, así como también tener que usar no (no (J)) para iniciar el filtro. Debido a esto, espero que todavía se pueda jugar golf.

Este es un programa que toma datos como:

aebcdjfghiqklmnopzrstuvwxy
'John Doe'

(Tenga en cuenta la falta de comillas en el primer argumento)

Explicación que vendrá después de un agotamiento paralizante;)

— FryAmTheEggman
fuente

¿Debo repetir mi comentario anterior ')

— Optimizer

@Optimizer: PI perdió el último;)

— FryAmTheEggman

Estabas diciendo ? ;)

— Optimizador

1

Haskell 131 bytes

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

Llame fcon la cadena de permutación y el nombre para obtener el resultado.

Explicación

-- 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

— Jmac
fuente

1

GolfScript (33 bytes)

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

Toma la entrada como dos cadenas entre comillas (simple o doble) separadas por cualquier cantidad de espacio en blanco; p.ej

'abcfdeghijklmnopqrstuvwxyz' 'Mr. John Doe'

Demostración en línea

Disección

~           # 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

La transliteración se basa en el hecho de que todos los caracteres están afectados (es {'ABC'?'abc'=}%con el A$reemplazo de la cadena ordenada 'ABC'y el Areemplazo de la permutación 'abc'); Las alternativas más generales no ahorran lo suficiente porque el filtro de caracteres alfabéticos es muy barato.

Esto también se basa en -1$acceder al fondo de la pila, que es un truco GS relativamente raro.

— Peter Taylor
fuente

Escribir con teclas codificadas

Detalles de entrada:

Detalles de salida:

Ejemplos:

Pyth, 16 bytes

Explicación:

CJam, 31 27 25 24 bytes

Rubí, 58

Explicación

CJam, 32 31 bytes

Explicación

Pyth 26

Haskell 131 bytes

Explicación

GolfScript (33 bytes)

Disección