A cifra de mudança de teclado

21

Dada a seguinte entrada:

  • Um inteiro nonde n > 0.
  • Uma sequência em sque snão está vazia e s~=[0-9A-Z]+(apenas maiúsculas alfanuméricas).

Usando um teclado QWERTY simplificado padrão (como mostrado abaixo):

1234567890
QWERTYUIOP
ASDFGHJKL
ZXCVBNM

Execute a seguinte operação:

  • Encontre a linha original em que cada caractere está no teclado.
  • Substitua a letra pelo equivalente deslocado correto para nbaseado na sua posição original + n.
    • EG s="AB"e n=2: Ase tornaria De Bse tornaria M.
  • Se keyboard_row[position + n] > keyboard_row.length, envolva de volta ao início.
    • EG s="0P"e n=2: 0se tornaria 2e Pse tornaria W.

Exemplos:

f("0PLM",1)    = 1QAZ
f("ZXCVB",2)   = CVBNM
f("HELLO",3)   = LYDDW
f("0PLM",11)   = 1QSV
f("0PLM",2130) = 0PHX

Regras

  • Isso é código-golfe , vitórias mais baixas na contagem de bytes.

Isso é um pouco mais difícil do que parece à primeira vista.

code-golf  keyboard  cipher 
— Urna de polvo mágico
fonte
2
É permitido pegar a entrada como uma matriz de caracteres em vez de uma string? Atualmente assumiu nós, mas esqueci de perguntar ..
— Kevin Cruijssen
@KevinCruijssen encolhe os ombros com certeza, não é muito estranho. A menos que você economize um byte para quebrar um empate, não estou reclamando.
— Urna de polvo mágico

Respostas:

11

Gelatina , 13 bytes

ØQØDṭ,ṙ€¥⁸F€y

Experimente online!

Como funciona

ØQØDṭ,ṙ€¥⁸F€y  Main link. Left argument: n (integer). Right argument: s (string)

ØQ             Qwerty; set the return value to
               ["QWERTYUIOP", "ASDFGHJKL", "ZXCVBNM"].
  ØD           Digits; yield "0123456789".
    ṭ          Tack, yielding ["QWERTYUIOP", "ASDFGHJKL", "ZXCVBNM", "0123456789"].
        ¥⁸     Call the two links to the left as a dyadic chain, with right
               argument n.
      ṙ€       Rotate each string in the array n units to the left.
     ,         Yield the pair of the unmodified and the rotated string array.
          F€   Flatten each, mapping, e.g., ["QWERTYUIOP", ..., "0123456789"] to
               "QWERTYUIOPASDFGHJKLZXCVBNM0123456789".
            y  Translate s according to the mapping we've built.
— Dennis
fonte
2
Jelly tem embutidos no layout do teclado, eh?
— Urna de polvo mágico
4
@MagicOctopusUrn Não, apenas QWERTY agora :-P
— Erik the Outgolfer
13 bytes? Que conjunto de caracteres é esse? Em UTF-8 são 26 bytes!
— Cefalópode
2
O @Cephalopod Jelly usa a página de código Jelly .
— Dennis
9

Python 2 , 110 bytes

lambda s,n,y='1234567890'*99+'QWERTYUIOP'*99+'ASDFGHJKL'*99+'ZXCVBNM'*99:''.join(y[y.find(c)+n%630]for c in s)

Experimente online!

Isso usa uma sequência grande o suficiente (99 cópias de cada linha) e o LCM entre os comprimentos das linhas (630) para encontrar a substituição correta, evitando a correção individual entre cada linha.

— Cajado
fonte
7

Java 8, 159 158 bytes

n->s->{for(int i=s.length,j;i-->0;)for(String x:"1234567890;QWERTYUIOP;ASDFGHJKL;ZXCVBNM".split(";"))if((j=x.indexOf(s[i])+n)>=n)s[i]=x.charAt(j%x.length());}

-1 byte graças a @ OlivierGrégoire modificando a matriz de entrada em vez de imprimir diretamente.

Explicação:

Experimente online.

n->s->{  // Method with integer and character-array parameters, and no return-type
  for(int i=s.length,j;i-->0;)
         //  Loop over the input character-array with index
    for(String x:"1234567890;QWERTYUIOP;ASDFGHJKL;ZXCVBNM".split(";"))
         //   Inner loop over the qwerty-lines
      if((j=x.indexOf(s[i])+n)>=n)
         //    If the current qwerty-line contains the character
         //     Set `j` to the index of this character on that line + input `n`
        s[i]=x.charAt(j%x.length());}
         //     Replace the character at index `i`
         //     with the new character (at index `j` modulo length_of_qwerty_line)
— Kevin Cruijssen
fonte
1
158 bytes , ao custo de entrada e saída do arquivo char[].
— Olivier Grégoire
5

Retina , 49 bytes

"$&"+T`9o`dQW\ERTYUI\OPQASDFG\HJK\LAZXC\VBNMZ
0A`

Experimente online! Recebe entrada ne sem linhas separadas. Explicação:

"$&"+

Repita os ntempos.

T`9o`dQW\ERTYUI\OPQASDFG\HJK\LAZXC\VBNMZ

Mude todos os caracteres uma tecla para a direita.

0A`

Excluir n.

— Neil
fonte
5

JavaScript (ES6), 101 99 bytes

Recebe entrada na sintaxe de currying (s)(n). Funciona com matrizes de caracteres.

s=>n=>s.map(c=>(S='1QAZ2WSX3EDC4RFV5TGB6YHN7UJM8IK_9OL_0P')[(p=S.search(c)+n*4)%(-~'9986'[p%4]*4)])

Casos de teste

Mostrar snippet de código

Quão?

Procuramos a posição p de cada caractere da entrada dentro de uma string S, onde as linhas do teclado são intercaladas: os 4 primeiros caracteres são '1QAZ' (primeira coluna do teclado), os próximos 4 caracteres são '2WSX' (segunda coluna) do teclado) e assim por diante. As posições não utilizadas são preenchidas com sublinhados e as últimas são simplesmente descartadas.

col # | 0    | 1    | 2    | 3    | 4    | 5    | 6    | 7    | 8    | 9
------+------+------+------+------+------+------+------+------+------+---
row # | 0123 | 0123 | 0123 | 0123 | 0123 | 0123 | 0123 | 0123 | 0123 | 01
------+------+------+------+------+------+------+------+------+------+---
char. | 1QAZ | 2WSX | 3EDC | 4RFV | 5TGB | 6YHN | 7UJM | 8IK_ | 9OL_ | 0P

Isso nos permite identificar facilmente a linha com p mod 4 e elimina a necessidade de separadores explícitos entre as linhas.

Nós avançamos por 4n posições, aplicar o modulo correta para esta linha (40, 40, 36 e 28, respectivamente) e escolher o caractere de substituição encontrado nesta nova posição em S .

— Arnauld
fonte
3

C,  152  149 bytes

Obrigado a @gastropner por salvar três bytes!

j,l;f(S,n){for(char*s=S,*k;*s;++s)for(k="1234567890\0QWERTYUIOP\0ASDFGHJKL\0ZXCVBNM\0";l=strlen(k);k+=l+1)for(j=l;j--;)k[j]-*s||putchar(k[(j+n)%l]);}

Experimente online!

Desenrolado:

j,l;
f(S,n)
{
    for (char*s=S, *k; *s; ++s)
        for (k="1234567890\0QWERTYUIOP\0ASDFGHJKL\0ZXCVBNM\0"; l=strlen(k); k+=l+1)
            for (j=l; j--;)
                k[j]-*s || putchar(k[(j+n)%l]);
}
— Steadybox
fonte
Ou estou tendo alucinações, ou o loop interno pode ser alterado para, for(j=l;j--;)mas não sei por que sem nenhuma outra alteração. Ainda assim, deve levá-lo a 149.
— gastropner
@gastropner Ah, sim, a ordem de pesquisa não importa, então funciona. Obrigado!
— Steadybox
2

Vermelho , 152 bytes

f: func[s n][foreach c s[foreach[t l]["1234567890"10"QWERTYUIOP"10"ASDFGHJKL"9"ZXCVBNM"7][if p: find t c[if(i:(index? p)+ n // l)= 0[i: l]prin t/(i)]]]]

Experimente online!

Ungolfed:

f: func [s n][1
    foreach c s [
        foreach [t l] ["1234567890"10"QWERTYUIOP"10"ASDFGHJKL"9"ZXCVBNM"7][
            p: find t c
            if p [ 
                i: (index? p) + n // l
                if i = 0 [i: l]
                prin t/(i) ]]]]
— Galen Ivanov
fonte
2

Haskell , 99 bytes

f(s,n)=[dropWhile(/=c)(cycle r)!!n|c<-s,r<-words"1234567890 QWERTYUIOP ASDFGHJKL ZXCVBNM",elem c r]

Experimente online!

— Roman Czyborra
fonte
Você pode usar em s#n= ...vez do f(s,n)= ...qual é apenas uma notação de exemplo usada para os exemplos.
— Laikoni
1

Perl 5 , 94 + 1 ( -p) = 95 bytes

$s=<>;for$i(1234567890,QWERTYUIOP,ASDFGHJKL,ZXCVBNM){eval"y/$i/".(substr$i,$s%length$i)."$i/"}

Experimente online!

— Xcali
fonte
Porra, eu não vi sua resposta. Eles são basicamente os mesmos, fique à vontade para usar minhas otimizações e removerei minha resposta. Deixe-me saber, se não, eu vou remover este comentário :)
— Dom Hastings
@DomHastings Eles são diferentes o suficiente. Por favor, guarde os dois. Eu gosto de ver variações na abordagem. Eu aprendo com todos eles ...
— Ton Hospel
1

Japonês, 20 bytes

Correndo pela porta para jantar, mais golfe e uma explicação a seguir.

;£=D·i9òs)æøX)gV+UbX

Tente

— Shaggy
fonte
1

Perl, 59 58 57 56 bytes

Inclui +para-p

Dê entrada em STDIN como 2 linhas, primeiro a string e depois a repetição

(echo 0PLM; echo 2130) | perl -pe '$a="OPQWERTYUILASDF-MZXCVBNM0-90";eval"y/HI$a/J$a/;"x<>'
— Ton Hospel
fonte
Uau, não acredito que você tenha 29 bytes do meu! Eu estava muito feliz com ele originalmente ...
— Dom Hastings
0

Limpo , 144 119 bytes

import StdEnv


\n s=[l.[(i+n)rem(size l)]\\c<-s,l<-["1234567890","QWERTYUIOP","ASDFGHJKL","ZXCVBNM"],i<-[0..]&j<-:l|j==c]

Experimente online!

Função Lambda com a assinatura Int ![Char] -> [Char]

— Furioso
fonte
0

Ruby , 101 bytes

->s,n{n.times{s.tr! '1234567890QWERTYUIOPASDFGHJKLZXCVBNM','2345678901WERTYUIOPQSDFGHJKLAXCVBNMZ'};s}

Experimente online!

Sinceramente, estou um pouco decepcionado por não ter conseguido fazer melhor com métodos 'inteligentes'. O mais próximo que cheguei foi ao longo das linhas de

a=%w{1234567890 QWERTYUIOP ASDFGHJKL ZXCVBNM}
b=a.map{|r|r[1..-1]<<r[0]}*''
a*=''
n.times{s.tr! a,b}

para um ganho líquido de 7 caracteres.

— benj2240
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.