Digitando con tasti criptati

16

Il tuo amico non è troppo bravo con i computer, quindi per scherzo qualcuno ha scritto le lettere (az) sulla tastiera. Quando si sedette e provò a digitare il suo nome guardando la tastiera, si rese conto che le lettere erano confuse e chiese il tuo aiuto.

Sei intelligente, quindi sai che se digita il suo nome e quindi reinserisce ripetutamente ciò che appare sullo schermo invece del suo nome, alla fine riuscirà a inserire il suo nome. Sei anche gentile e riorganizza i tasti ma vuoi sapere quante svolte ci vorrebbero per avere successo.

Il tuo compito è quello di scrivere un programma o una funzione che abbia dato il mescolamento delle lettere e il nome dell'amico calcola il numero di turni.

Dettagli di input:

  • Vengono fornite due stringhe come input in una struttura conveniente per la tua lingua.
  • La prima stringa è l'elenco delle nuove lettere minuscole in ordine alfabetico di quelle vecchie. (Il primo carattere è quello che si trova nella posizione di a, l'ultimo è nella posizione di z.) Alcuni cambiamenti si verificano sempre nella stringa.
  • La seconda stringa è il nome. Potrebbe contenere qualsiasi carattere ASCII stampabile, ma solo i caratteri alfabetici maiuscoli e minuscoli verranno mescolati, se presenti. Il nome stesso potrebbe non essere mischiato ad al.

Dettagli di uscita:

  • L'output è un singolo numero intero il numero di giri minimo richiesto. Newline è facoltativo.

Esempi:

Input: 'abcfdeghijklmnopqrstuvwxyz' 'Mr. John Doe'(posizioni d, e, f modificate)

Output: 3(I nomi visualizzati sono: Mr. John Fod=> Mr. John Eof=> Mr. John Doe)

Input: 'nopqrstuvwxyzabcdefghijklm' 'Mr. John Doe'(la cifra ROT13 )

Output: 2(Qualsiasi nome di input che contiene lettere richiederà dei 2round per produrre il nome originale.)

Ingresso: 'aebcdjfghiqklmnopzrstuvwxy' 'John Doe'

Produzione: 140

Questo è code-golf, quindi vince l'ingresso più breve.

code-golf  string  permutations 
— randomra
fonte
1
Probabilmente dovresti includere questo caso di test: aebcdjfghiqklmnopzrstuvwxy(output 1260 per Mr John Doe). Questo è il massimo possibile - è costituito da cicli di ordine 4, 5, 7, 9 (e invariato a), e ogni nome che contiene almeno una lettera di ciascun ciclo produrrà 1260. E immagino che prendere l'alfabeto stesso come input o l'utilizzo di un nome non interessato sono anche importanti casi limite.
— Martin Ender,
@ MartinBüttner Aggiunto con modifica.
— randomra,
Sono un po 'confuso su come ti viene in mente il numero di turni.
— FUZxxl,
@FUZxxl In generale, è possibile scomporre la permutazione in cicli , quindi controllare quali cicli includono caratteri dal nome. Il risultato è l'LCM delle lunghezze di quei cicli (i cicli tra caratteri non nel nome sono irrilevanti, ovviamente). Tuttavia, per questa sfida, non è davvero necessario ... basta eseguire le sostituzioni fino a quando non si colpisce il nome originale e contare la frequenza con cui è stato necessario sostituire.
— Martin Ender,
1
Come nota a margine, John File Marker aka EOFè assolutamente incredibile!
— rev

Risposte:

9

Pyth, 16 byte

JGfqzuXGJrQ0UTz1

Provalo qui.

L'input deve essere dato su due righe, nome e quindi permutazione. La permutazione dovrebbe essere citata. Il nome può essere citato o non quotato. Per esempio:

"John Doe"
"aebcdjfghiqklmnopzrstuvwxy"

Dà 140.

Spiegazione:

                            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
fonte
Il metodo di input dovrebbe essere identico per le stringhe.
— randomra,
10

CJam, 31 27 25 24 byte

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

Accetta input sotto forma di:

aebcdjfghiqklmnopzrstuvwxy
Mr. John Doe

cioè prima riga - alfabeti, seconda riga - nome.

Come funziona :

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

Provalo online qui

— Optimizer
fonte
5

Ruby, 58 anni

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

Spiegazione

  • L'input viene preso come argomento per un lambda.
  • Usa Enumerable#find(grazie a @Ventero!) E String#tr!per sostituire i caratteri fino a quando quelli sostituiti Stringcorrispondono al vero nome.
— britishtea
fonte
""+nè un po 'più breve di n.dup, e puoi salvare un altro byte facendo un uso creativo Enumerable#findinvece di usare un contatore esplicito:(1..1e4).find{t.tr!(...)==n}
— Ventero
Inoltre, puoi salvare molti byte inserendo l'input n in minuscolo
— Ottimizzatore
@Optimizer Questo non sembra salvarmi nulla, il metodo di Ruby per convertire in minuscolo è piuttosto lungo (dovrei usare n.downcase!).
— britishtea,
sì, ma poi non devi fare A-Ze+a.upcase
— Ottimizzatore
A-Z+a.upcasee n.downcase!\nhanno la stessa lunghezza :)
— britishtea
2

CJam, 32 31 byte

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

Provalo qui.Prende la permutazione sulla prima riga e il nome sulla seconda riga dell'input.

Spiegazione

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

Pyth 26

KGJ@GrQZfqJusm@zxKdGUTJ!!J

Provalo online qui.

Ci sono alcune sfortunate conseguenze che costano questo byte di programma, come dover archiviare G in K per usarlo nella riduzione, oltre a dover usare not (non (J)) per avviare il filtro. Per questo motivo, mi aspetto che questo possa ancora essere giocato a golf.

Questo è un programma che accetta input come:

aebcdjfghiqklmnopzrstuvwxy
'John Doe'

(Nota la mancanza di virgolette nel primo argomento)

Spiegazione a venire dopo paralizzante stanchezza;)

— FryAmTheEggman
fonte
Devo ripetere il mio precedente commento ")
— Ottimizzatore
@Optimizer: PI ha perso l'ultimo;)
— FryAmTheEggman
Stavi dicendo ? ;)
— Ottimizzatore
1

Haskell 131 byte

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

Chiama fcon la stringa di permutazione e il nome per ottenere il risultato

Spiegazione

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

GolfScript (33 byte)

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

Accetta l'input come due stringhe (singole o doppie) tra virgolette separate da qualsiasi quantità di spazio bianco; per esempio

'abcfdeghijklmnopqrstuvwxyz' 'Mr. John Doe'

Demo online

Dissezione

~           # 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 traslitterazione si basa sul fatto che tutti i caratteri sono interessati (è {'ABC'?'abc'=}%con la A$sostituzione della stringa ordinata 'ABC'e la Asostituzione della permutazione 'abc'); le alternative più generali non risparmiano abbastanza perché il filtro per i caratteri alfabetici è così economico.

Questo si basa anche -1$sull'accesso al fondo dello stack, che è un trucco GS relativamente raro.

— Peter Taylor
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.