Code Golf Challenge

Eu tenho um problema, meus dedos estão gordos e eu frequentemente juro um problema de digitar um pressionamento de tecla à direita no meu teclado.

Receio que o atraso esteja piorando e piorando com o passar do tempo.

Sopn cada tecla que eu faço; desloque-se para a direita!

Antes, eu gostaria que um programa (ou functipn) autp mudasse cada tecla pressionada de volta para a esquerda.

Certificarei-me de que tomo meu tomo pelo resto do tempo, para não causar confusão.

Objetivo:

Escreva um programa ou função que utilize uma das seguintes teclas verdes em um teclado QWERTY padrão e retorne o caractere da tecla à esquerda.

Condições:

• Você pode supor que a pessoa que está executando este programa está usando um teclado QWERTY como o da foto acima.

• Entrada e Saída não fazem distinção entre maiúsculas e minúsculas, você pode usar qualquer caso (ou uma mistura de combinações de casos) para esse desafio e também pode assumir que todas as entradas estarão em um caso, se desejar.

• Se o seu idioma não tiver como permitir que um usuário insira a tecla Enter por algum motivo, você poderá ignorar o pressionamento de uma tecla para isso.

• Esse desafio é apenas para os valores padrão das teclas, por exemplo, se a 4tecla for pressionada, você pode assumir que sempre será 4e nunca$

• Você pode assumir que apenas as teclas verdes serão pressionadas.

Exemplo Input-> Output:

S-> a
4-> 3
=-> -
[->p

Isso é código-golfe , então o programa com o menor número de bytes vence!

Ruby, 76 71 69 bytes

->a{"`1234567890-=qwertyuiop[]\\asdfghjkl;'\nzxcvbnm,./"[/.#{a}/][0]}

Perl 6 , 87 83 69 bytes

{[Q"`1234567890-=qwertyuiop[]\asdfghjkl;'
zxcvbnm,./".comb].&{%(.[1..*]Z=>$_)}{$_}}

{~Q"`1234567890-=qwertyuiop[]\asdfghjkl;'
zxcvbnm,./".match(/.)>$_/)}

Experimente online!

Pensando se existe uma maneira de codificar essa sequência codificada para algo mais curto ...

(Roubou a ideia de regex do GB por -14 bytes.)

Geléia , 34 33 bytes

ØD”`1¦ṭØqż“[]\“;'¶“,./“0-=”Fṡ2UZy

Experimente online!

Como funciona

ØD”`1¦ṭØqż“[]\“;'¶“,./“0-=”Fṡ2UZy  Main link. Argument: s (string)

ØD                                 Digits; yield "0123456789".
  ”`1|                             Replace '0' with a backtick.
       Øq                          Qwerty; yield
                                   ["qwertyuiop", "asdfghjkl", "zxcvbnm"].
      ṭ                            Tack; add "`123456789" as the last element of
                                   the qwerty array.
          “[]\“;'¶“,./“0-=”        Yield ["[]\\", ";'\n", "0-="].
         ż                         Zip; combine the strings of the array to the
                                   left with the corresponding strings of the array
                                   to the right, yielding an array of string pairs.
                           F       Flatten, yielding a string.
                            ṡ2     Obtain all overlapping pairs of characters.
                              U    Upend; reverse each pair.
                               Z   Zip, yielding a pair of strings.
                                y  Translate the input s according to the generated
                                   replacement table.

Python 3, 85 78 bytes:

lambda x,k="`1234567890-=qwertyuiop[]\\asdfghjkl;'\nzxcvbnm<>?":k[k.‌​find(x)-1]

Python , 76 bytes

s="1234567890-=qwertyuiop[]\\asdfghjkl;'\nzxcvbnm<>?"
dict(zip(s,'`'+s)).get

Experimente online!

Cria um dicionário que leva cada tecla à esquerda, fechando a seqüência de caracteres com sua versão deslocada. A linha inferior é a função, a superior é uma definição.

Usar translatepara criar um mapeamento deu uma solução mais longa. Experimente online!

lambda s:s.translate("';"*22+"_0__9`12345678_LM-<>_\\VXSWDFGUHJKNBIO=EARYCQZT\nP][___"*4)

Retina , 53 51 bytes

T`1-90\-=QW\ERTYUI\OP[]\\ASDF-HJ-L;'¶ZXCVBNM,./`\`o

Experimente online!

Uma transliteração simples deslocando cada posição do personagem 1 para trás. Tudo, de 1até, /é o conjunto de caracteres original, enquanto a parte a seguir é o novo conjunto, usando opara indicar o outro conjunto.

He Lsão classes de caracteres especiais para transliteração na retina (mapeamento respectivamente para dígitos hexadecimais e letras maiúsculas), mas, felizmente, ocorrem no teclado dentro de seqüências ordenadas alfabeticamente ( FGHe JKL), para que possamos evitá-las, colocando-as em intervalos e ganhando assim. 2 bytes.

C ++, 109 bytes

void f(char i){std::string k="`1234567890-=qwertyuiop[]\\asdfghjkl;'\nzxcvbnm,./";std::cout<<k[k.find(i)-1];}

Experimente online!

TI-Básico, 70 bytes

Duvido que poderia ficar mais curto do que isso ...

Input Str1
"`1234567890-=QWERTYUIOP[]\ASDFGHJKL;'ZXCVBNM,./
sub(Ans,inString(Ans,Str1)-1,1

PS As fichas de dois bytes são Str1, `, \, sub(, e inString(.

V , 57 54 51 bytes

3 bytes salvos graças a @ nmjcman101 por usar em hxVpvez do que eu tinha para o teclado multilinha

i`¬190-=qwertyuiop[]\asdfghjkl;'zxcvbnm,./<esc>/<C-r>a
hxVp

Experimente online!

<esc>é 0x1be <c-r>é0x12

Nota: isso não suporta a tecla Enter

Contém imprimíveis, então aqui está o hexdump

00000000: 6960 ac31 3930 2d3d 7177 6572 7479 7569  i`.190-=qwertyui
00000010: 6f70 5b5d 5c61 7364 6667 686a 6b6c 3b27  op[]\asdfghjkl;'
00000020: 7a78 6376 626e 6d2c 2e2f 1b2f 1261 0a68  zxcvbnm,././.a.h
00000030: 7856 70                                  xVp

Explicação

A maior parte do programa gera o teclado. ientra no modo de inserção e todos os caracteres a seguir são impressos no buffer. Mas há uma pequena peculiaridade aqui, ¬19insere caracteres entre 1 e 9.

O programa sai do modo de inserção no <esc>. E então aqui /<c-r>aele procura o argumento no buffer. Isso coloca o cursor em cima do caractere encontrado.

h                  " move the cursor to the left
 x                 " delete this character
  Vp               " select this line and replace it with the deleted character

PowerShell, 82 bytes

$k="1234567890-=qwertyuiop[]\asdfghjkl;'
zxcvbnm,./";$k[$k.IndexOf((read-host))-1]

A tecla Enter é suportada, mas não pode ser testada Read-Hostporque o ato de pressionar Enter sem valor não retorna nada no PowerShell.

Japonês , 56 42 bytes

;D=Dv ·q i"[]\\",A i";'",22 +",./")Dg1nDbU

Explicação

;D=Dv ·q i"[]\\",A i";'",22 +",./")Dg1nDbU

;D=D                                        // Shortcut for QWERTY (with newlines and spaces), assigning to variable D
    v                                       // Setting D to lowercase
      ·q                                    // Joining D into an array with no spaces or newlines
        i"[]\\",A                          // Inserting "[]\" into index 10 (A)
                   i";'",22                 // Inserting ";'" into index 22
                           +",./"           // Appending ",./"
                                  Dg        // Returns the character at index:
                                    1n      //    -1+
                                       DbU  //     Index of U (the input)

Experimente online!

Java 8, 99 bytes

c->{String r="`1234567890-=qwertyuiop[]\\asdfghjkl;'\nzxcvbnm,./";return r.charAt(r.indexOf(c)-1);}

Explicação:

Experimente aqui.

c->{                // Method with character as both parameter and return-type
  String r="`1234567890-=qwertyuiop[]\\asdfghjkl;'\nzxcvbnm,./";
                    //  Literal String of the qwerty keyboard layout of the challenge
  return r.charAt(  //  Return the character at the following index:
    r.indexOf(c)    //   The index of the input character
    -1);            //   -1 to shift it to the left
}                   // End of method

JavaScript (ES6), 74 bytes

c=>(s=".,mnbvcxz\n';lkjhgfdsa\\][poiuytrewq=-0987654321`")[s.indexOf(c)+1]

Como /não está na minha string, indexOfretorna -1, que quando incrementado causa .a saída. 93 bytes para processar uma sequência:

s=>s.replace(/./g,c=>s[s.indexOf(c)+1],s="><mnbvcxz\n';lkjhgfdsa\\][poiuytrewq=-0987654321`")

GNU sed , 72 + 1 (sinalizador r) = 73 bytes

s:$:`1234567890-=qwertyuiop[]\\asdfghjkl;'\nzxcvbnm,./:
s:(.).*(.)\1.*:\2:

A chave de retorno não pode ser testada, porque o sed by design divide a entrada usando \ncomo delimitador e, em seguida, executa o script quantas vezes houver linhas.

Execução de teste: par contínuo de entrada e saída (quando terminar, pressione Ctrl + D ou Ctrl + C)

me@LCARS:/PPCG$ sed -rf shift_key.sed
s
a
4
3
=
-
a
\
1
`
\
]

05AB1E , 50 bytes

'`žhÀ"-=qwertyuiop[]\\asdfghjkl;'\nzxcvbnm,./"JDÀ‡

Experimente online!

Explicação:

'`                                                  # 1 char string: `
  žh                                                # Push numbers 0123456789
    À                                               # Rotated 1 left (123456890)
     "-=qwertyuiop[]\\asdfghjkl;'\nzxcvbnm,./"      # Push string literal
                                              J     # Join all elements pushed to the stack to one string
                                               D    # Duplicate
                                                À   # Rotate 1 left
                                                 ‡  # Transliterate: a.get(b.indexOf(input))

Pitão - 56 bytes

@K"`1234567890-=qwertyuiop[]\\asdfghjkl;'
zxcvbnm,./"txK

Conjunto de Teste .