El reto:

Dada cualquier entrada que pueda escribirse en un teclado, mueva el texto con N caracteres.

Aquí está el teclado QWERTY para ser utilizado. Puede ignorar las teclas modificadoras (Shift, Caps, Enter, Delete y Tab). Una vez que llegas a un lado (por ejemplo |) gira de nuevo, |pasa a Qif N = 1.

No es necesario mover los espacios (vuelven al espacio al omitir los modificadores). Si se utilizó turno para escribir el carácter (por ejemplo, !e @) el carácter cambiado también debe ser escrito utilizando turno (es decir, !va a @no 2si N = 1).

Los teclados del Reino Unido son diferentes a esto, pero utilízalo para poder comparar.

Entrada:

Cualquier oración que se pueda escribir en el teclado anterior seguido de un entero positivo. No hay un máximo para el tamaño de este número entero.

Salida:

La misma oración, desplazada por N.

Ejemplos:

My name is Tim 3
?o .f/y [g I[/

Hello World 7
Spgge Oe[g;

I Wi5h I h4d b3773r C@d3ing ski{{s 3
{ T[8l { l7h ,6006u N%h6[.k g'[QQg

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

C, 217 bytes

char*t=" @A$%^*a)_(~.=/z-234567890\"'>`?Z#SNVFRGHJOKL:<MP{WTDYIBECUX]q\\&=1snvfrghjokl;,mp[wtdyibecux}Q|!";l,d,k;f(char*s){for(l=strlen(s);s[--l]-32;);d=atoi(s+l);for(s[l]=0;d--;)for(k=l;k--;s[k]=t[s[k]-32]);puts(s);}

Versión legible con espacios en blanco, incluye, etc.

#include <string.h>
#include <stdlib.h>
#include <stdio.h>

char* t = " @A$%^*a)_(~.=/z-234567890\"'>`?Z#SNVFRGHJOKL:<MP{WTDYIBECUX]q\\&=1snvfrghjokl;,mp[wtdyibecux}Q|!";
int l, d, k;

void f(char* s) {
    l = strlen(s);
    for( ; s[--l] - 32; );
    d = atoi(s + l);
    s[l] = 0;
    for ( ; d--; ) {
        for (k = l; k--; s[k] = t[s[k] - 32]);
    }
    puts(s);
}

El código habla más o menos por sí mismo. Solo una tabla de búsqueda que asigna de cada carácter al siguiente carácter, que se aplica el número dado de veces. Gran parte del código es en realidad para analizar el número de la entrada.

05AB1E , 61 bytes

-1 byte gracias a Kevin Cruijssen

žVDu«1ú`žhÀ“~!@#$%^&*()_+ `ÿ-=ÿ<>?ÿ:"ÿ{}|ÿ,./ÿ;'ÿ[]\“#vyy¹._‡

Pruébalo en línea!

Pyth, 126 bytes

XjdPczdsJc"~!@#$%^&*()_+ `1234567890-= qwertyuiop[]\ QWERTYUIOP{}| asdfghjkl;, ASDFGHJKL:\" zxcvbnm,./ ZXCVBNM<>?")sm.<dvecz)J

Pruébelo en línea: Demostración o conjunto de pruebas

Explicación:

    czd                       split input by spaces
   P                          remove the last element
 jd                           join by spaces (=#1)

          "..."               string with the chars of each row
         c     )              split by spaces
        J                     assign to J
       sJ                     sum of J (=#2)

                       cz)    split input by spaces
                      e       take the last element
                     v        and evaluate it 
                 m        J   map each row d of J to:
                  .<d           rotate the row d by value
                s             sum (=#3)

X                             Take #1, and replace the chars in #2 by the chars in #3

Python 3, 311 bytes

*i,s=input().split()
r=["`1234567890-=","qwertyuiop[]\\","asdfghjkl;'","zxcvbnm,./","~!@#$%^&*()_+","QWERTYUIOP{}|",'ASDFGHJKL:"',"ZXCVBNM<>?"]
print("".join([[x[int(s):]+x[:int(s)]for x in r][r.index([x for x in r if c in x][0])][([x for x in r if c in x][0]).index(c)]if c!=" "else " " for c in " ".join(i)]))

Python 3, 271 255 bytes

La línea de base, casi sin golf, solía crear las palabras desplazadas en la pregunta.

x=input().split()
n=int(x[-1])
x=' '.join(x[:-1])
l=['`1234567890-=','qwertyuiop[]\\',"asdfghjkl;'",'zxcvbnm,./', '~!@#$%^&*()_+','QWERTYUIOP{}|','ASDFGHJKL:"','ZXCVBNM<>?',' ']
y=''
for i in x:
 for q in l:
  if i in q:y+=q[(q.index(i)+n)%len(q)]
print(y)

Explicación:

x=input().split()    # Get input
n=int(x[-1])         # Get N from input
x=' '.join(x[:-1])   # Get the words from input
                     # Create list of letters

l=['`1234567890-=', 'qwertyuiop[]\\',
   "asdfghjkl;'",   'zxcvbnm,./',
   '~!@#$%^&*()_+', 'QWERTYUIOP{}|',
   'ASDFGHJKL:"',   'ZXCVBNM<>?',
   ' ']

y=''                 # Blank string
for i in x:          # Loop through letters in input
    for q in l:      # Loop through items in list
        if i in q:   # Is letter of input in item of list?
            y+=q[                          # Append letter to y
                 (q.index(i)+n)            # locate the letter in item, and add N
                               %len(q)]    # % is modulus, loop to beginning if big
print(y)             # Print out the offset word.

JavaScript (ES6), 200 216

Usando cadenas de plantilla, las nuevas líneas son significativas y contadas.

Nota sobre replace: los dos fragmentos string.split('x').map(w=>...)y string.replace(/[^x]+/g,w=>...)son formas igualmente válidas para ejecutar una función para cada parte de una cadena, utilizando un separador. Usar una nueva línea como separador es útil cuando la regexp de reemplazo se vuelve /.+/g, porque el punto coincide con cualquier línea que no sea nueva. Y al usar cadenas con plantillas, las nuevas líneas no tienen costo adicional.

f=(t,d)=>[for(c of t)`~!@#$%^&*()_+
1234567890-=
QWERTYUIOP{}|
qwertyuiop[]\\
ASDFGHJKL:"
asdfghjkl;'
ZXCVBNM<>?
zxcvbnm,./`.replace(/.+/g,r=>(p=r.indexOf(c))<0?0:q=r[(p+d)%r.length],q=c)&&q].join('')

// less golfed
x=(t,d)=>
  [for(c of t)
    '~!@#$%^&*()_+ 1234567890-= QWERTYUIOP{}| qwertyuiop[]\\ ASDFGHJKL:" asdfghjkl;\' ZXCVBNM<>? zxcvbnm,./'
    .split(' ')
    .map(r=>(p=r.indexOf(c))<0?0:q=r[(p+d)%r.length],q=c)&&q
  ].join('')
  
// TEST

out=x=>O.innerHTML+=x+'\n'

;[['Hello World',7,],['My name is Tim',3],['I Wi5h I h4d b3773r C@d3ing ski{{s', 3]]
.forEach(p=>out(p+' -> '+f(p[0],p[1])))

<pre id=O></pre>

CJam, 107 bytes

lS/)~\S*\",./ ;'  <>? :\"  _+~!@#$%^&*() -=`"A,s(++S/"zxcvbnm
asdfghjkl
[]\qwertyuiop"N/_32ff^+.+_@fm>s\ser

Pruébelo en línea en el intérprete de CJam .

Cómo funciona

lS/)   e# Read one line from STDIN, split at spaces and pop the last chunk.
~\S*\  e# Evaluate the popped chunk and join the remaining ones back together.
",./ ;'  <>? :\"  _+~!@#$%^&*() -=`"
       e# Push that string.
A,s(++ e# Concatenate it with "1234567890".
S/     e# Split at spaces.
"zxcvbnm asdfghjkl []\qwertyuiop"
       e# Push that string.
S/     e# Split at spaces. (`N/' would split at linefeeds.)
_32ff^ e# XOR each character of a copy with 32.
+      e# Concatenate the copies.
.+     e# Perform vectorized concatenation. This pushes the following array:
          [ ",./zxcvbnm" ";'asdfghjkl" "[]\qwertyuiop" "<>?ZXCVBNM"
           ":\"ASDFGHJKL" "{}|QWERTYUIOP" "_+~!@#$%^&*()" "-=`1234567890" ]
_@fm>  e# Rotate each chunk by the number of character specified in the input.
s\s    e# Flatten this array and the original.
er     e# Perform transliteration.

Jalea , 67 bytes

ØDṙ1ṭØQ;Øq;"“{}|“:"“<>?“-=`“[]\“;'“,./“~!@#$%^&*()_+“ ”
¢œiⱮ+2¦€œị¢

Pruébalo en línea!

Un enlace diádico que toma la cadena como argumento izquierdo y el número de lugares para cambiar como argumento derecho.

Python 2 , 194 bytes

f=lambda s,n:n and f(''.join(B[B.find(c)+1]for c in s),n-1)or s
A='qwertyuiop%sqasdfghjkl%sazxcvbnm%sz'
B='`1234567890-=`~!@#$%^&*()_+~'+A%('[]\\',";'",',./')+(A%('{}|',':"','<>?')).upper()+'  '

Pruébalo en línea!