Taper avec des touches cryptées

16

Votre ami n'est pas trop bon avec les ordinateurs, donc comme une plaisanterie pratique, quelqu'un a brouillé les lettres (az) sur son clavier. Quand il s'est assis et a essayé de taper son nom en regardant le clavier, il s'est rendu compte que les lettres étaient brouillées et a demandé votre aide.

Vous êtes intelligent, vous savez donc que s'il tape son nom puis retape à plusieurs reprises ce qui s'affiche à l'écran au lieu de son nom, il réussira à entrer son nom. Vous êtes également gentil et réorganisez les touches, mais vous voulez savoir combien de tours faudrait-il pour réussir.

Votre tâche consiste à écrire un programme ou une fonction qui, compte tenu du brassage des lettres et du nom de l'ami, calcule le nombre de tours.

Détails d'entrée:

  • Deux chaînes sont données en entrée dans une structure adaptée à votre langue.
  • La première chaîne est la liste des nouvelles lettres minuscules dans l'ordre alphabétique des anciennes. (Le premier caractère est celui qui est à la position de a, le dernier est à la position dez .) Certains changements se produiront toujours dans la chaîne.
  • La deuxième chaîne est le nom. Il peut contenir n'importe quel caractère ascii imprimable, mais seuls les caractères alphabétiques supérieur et minuscule seront mélangés le cas échéant. Le nom lui-même pourrait ne pas être mélangé à al.

Détails de sortie:

  • La sortie est un entier unique, le nombre de tours requis au minimum. La nouvelle ligne est facultative.

Exemples:

Contribution: 'abcfdeghijklmnopqrstuvwxyz' 'Mr. John Doe' (positions d, e, f modifiées)

Sortie: 3(Les noms affichés sont: Mr. John Fod=> Mr. John Eof=>Mr. John Doe )

Entrée: 'nopqrstuvwxyzabcdefghijklm' 'Mr. John Doe'(le chiffre ROT13 )

Sortie: 2(Tout nom d'entrée contenant des lettres prendra2 tours pour produire le nom d'origine.)

Contribution: 'aebcdjfghiqklmnopzrstuvwxy' 'John Doe'

Production: 140

Il s'agit de code-golf, donc l'entrée la plus courte l'emporte.

code-golf  string  permutations 
— randomra
source
1
Vous devriez probablement inclure ce cas de test: aebcdjfghiqklmnopzrstuvwxy(sortie 1260 pour Mr John Doe). C'est le maximum possible - il se compose de cycles d'ordre 4, 5, 7, 9 (et un inchangé a), et chaque nom qui contient au moins une lettre de chaque cycle donnera 1260. Et je suppose que l'alphabet lui-même comme entrée ou l'utilisation d'un nom non affecté sont également des cas marginaux importants.
— Martin Ender
@ MartinBüttner Ajouté avec modification.
— randomra
Je suis un peu confus quant à la façon dont vous arrivez avec le nombre de tours.
— FUZxxl
@FUZxxl En général, vous pouvez décomposer la permutation en cycles , puis vous vérifiez quels cycles incluent des caractères du nom. Le résultat est le LCM des longueurs de ces cycles (les cycles à travers des caractères qui ne sont pas dans le nom ne sont pas pertinents, bien sûr). Cependant, pour ce défi, ce n'est pas vraiment nécessaire ... effectuez simplement les substitutions jusqu'à ce que vous frappiez le nom d'origine et comptez la fréquence à laquelle vous avez dû remplacer.
— Martin Ender
1
En remarque, John File Marker aka EOFest totalement incroyable!
— rev

Réponses:

9

Pyth, 16 octets

JGfqzuXGJrQ0UTz1

Essayez-le ici.

L'entrée doit être donnée sur deux lignes, nom puis permutation. La permutation doit être citée. Le nom peut être cité ou non. Par exemple:

"John Doe"
"aebcdjfghiqklmnopzrstuvwxy"

Donne 140.

Explication:

                            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
source
La méthode d'entrée doit être identique pour les chaînes.
— randomra
10

CJam, 31 27 25 24 octets

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

Prend des informations sous la forme de:

aebcdjfghiqklmnopzrstuvwxy
Mr. John Doe

c'est-à-dire première ligne - alphabets, deuxième ligne - nom.

Comment ça marche :

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

Essayez-le en ligne ici

— Optimiseur
source
5

Rubis, 58

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

Explication

  • L'entrée est considérée comme un argument d'un lambda.
  • Utilisez Enumerable#find(merci @Ventero!) Et String#tr!pour remplacer les caractères jusqu'à ce que le remplacement Stringcorresponde au vrai nom.
— britishtea
source
""+nest un peu plus court que n.dup, et vous pouvez enregistrer un autre octet en faisant un usage créatif Enumerable#findau lieu d'utiliser un compteur explicite:(1..1e4).find{t.tr!(...)==n}
— Ventero
En outre, vous pouvez économiser beaucoup d'octets en rendant l'entrée n en minuscules
— Optimizer
@Optimizer Cela ne semble pas me sauver quoi que ce soit, la méthode de Ruby pour convertir en minuscules est assez longue (je devrais utiliser n.downcase! ).
— britishtea
oui, mais alors vous n'avez pas à faire A-Zet+a.upcase
— Optimizer
A-Z+a.upcaseet n.downcase!\nont la même longueur :)
— britishtea
2

CJam, 32 31 octets

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

Testez-le ici. Il prend la permutation sur la première ligne et le nom sur la deuxième ligne de l'entrée.

Explication

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

Pyth 26

KGJ@GrQZfqJusm@zxKdGUTJ!!J

Essayez-le en ligne ici.

Il y a quelques conséquences malheureuses qui coûtent à ce programme des octets, comme devoir stocker G dans K pour l'utiliser dans la réduction, ainsi que devoir utiliser non (pas (J)) pour démarrer le filtre. Pour cette raison, je m'attends à ce que cela puisse encore être joué.

Ceci est un programme qui prend des entrées comme:

aebcdjfghiqklmnopzrstuvwxy
'John Doe'

(Notez le manque de guillemets dans le premier argument)

Explication à venir après épuisement paralysant;)

— FryAmTheEggman
source
Dois-je répéter mon commentaire précédent ')
— Optimizer
@Optimizer: PI a perdu ce dernier;)
— FryAmTheEggman
Tu disais ? ;)
— Optimizer
1

Haskell 131 octets

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

Appel f avec la chaîne de permutation et le nom pour obtenir le résultat

Explication

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

GolfScript (33 octets)

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

Prend l'entrée comme deux chaînes entre guillemets (simples ou doubles) séparées par n'importe quelle quantité d'espace; par exemple

'abcfdeghijklmnopqrstuvwxyz' 'Mr. John Doe'

Démo en ligne

Dissection

~           # 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 translittération repose sur le fait que tous les caractères sont affectés (c'est {'ABC'?'abc'=}%avec le A$remplacement de la chaîne triée 'ABC'et le Aremplacement de la permutation'abc' ); les alternatives plus générales n'économisent pas suffisamment car le filtre des caractères alphabétiques est très bon marché.

Cela dépend également -1$de l'accès au bas de la pile, ce qui est une astuce GS relativement rare.

— Peter Taylor
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.