En este desafío, debe cambiar los caracteres en una cadena ingresada n número de veces y generar la cadena desplazada

Entrada

La entrada primero contendrá una cadena. En la siguiente línea, un número entero, que denota nestará presente.

Salida

• Si nes positivo, cambie los caracteres de la cadena a los ntiempos correctos .
• Si nes negativo, cambie los caracteres de la cadena a la izquierda n.
• Si nes cero, no desplace los caracteres en la cadena.

Después de cambiar (excepto cuando nes cero), imprima la cadena desplazada.

Notas

• La cadena no estará vacía o null.
• La cadena no tendrá más de 100 caracteres y solo contendrá caracteres ASCII en el rango (espacio) a ~(tilde) (códigos de caracteres 0x20 a 0x7E, inclusive). Consulte la tabla ASCII para referencia.
• El cambio es cíclico.
• El número npuede ser positivo, negativo o cero.
• n siempre será mayor o igual a -1000 y menor o igual a 1000
• Puede tomar datos a través de stdino desde argumentos de línea de comando
• La cadena desplazada debe salir en el stdout(o el equivalente más cercano)
• Puede escribir un programa completo o una función que tome la entrada y la salida de la cadena en el stdoutequivalente más cercano

Casos de prueba

1)

Hello world!
5             -->orld!Hello w

2)

Testing...
-3            -->ting...Tes

3)

~~~
1000          -->~~~

4)

12345
0             -->12345

5)

ABA
17            -->BAA

Puntuación

Este es el código de golf , por lo que gana el envío más corto (en bytes).

Pyth, 4 bytes

.>zQ

Esto es casi similar a mi versión de 5 bytes de CJam , excepto que Pyth como operador de entrada de evaluación automática Q.

.>              # Cyclic right shift of 
  z             # Input first line as string
   Q            # Rest of the input as evaluated integer

Pruébalo en línea aquí

Javascript ( ES5 ), 55 52 bytes

p=prompt;with(p())p(slice(b=-p()%length)+slice(0,b))

Comentado:

p = prompt; // store a copy of prompt function for reuse
with(p()) // extend scope chain with first input
    p( // print result
        slice(b = -p() % length) // take second input negated and modulo length
        +                        // and slice string by result
        slice(0, b) // concatenate with opposite slice
    )

CJam, 5 bytes

llim>

Esto es bastante sencillo.

l               e# Read the first line
 li             e# Read the second line and convert to integer
   m>           e# Shift rotate the first string by second integer places

Pruébalo en línea aquí

C, 93 bytes

main(a,v,n)char**v;{a=v[2]-v[1]-1;n=atoi(v[2]);a=a*(n>0)-n%a;printf("%s%.*s",v[1]+a,a,v[1]);}

Más clara es la versión de argumento de función que se modificó para hacer la versión de argumento de línea de comando

f(s,n,c)char*s;{c=strlen(s);c=c*(n>0)-n%c;printf("%s%.*s",s+c,c,s);}

Este tiene solo 68 bytes, lo que demuestra cuán desventajoso es C cuando se trata de argumentos de línea de comando.

Si el desplazamiento,, nes positivo, entonces strlen(s)-n%strlen(s)es el desplazamiento y si nes negativo, el desplazamiento es -n%strlen(s). Las printfimpresiones desde el desplazamiento, chasta el final de la cadena, y luego los ccaracteres finales desde el principio.

Ejemplos:

$ ./rotstr "¡Hola, mundo!" 5 5
orld! Hola w
$ ./rotstr "Pruebas ..." -3
ting ... Tes
$ ./rotstr "~~~" 1000
~~~
$ ./rotstr "12345" 0
12345
$ ./rotstr "ABA" 17
BALIDO
$ ./rotstr "¡Hola, mundo!" -dieciséis
¡Oh mundo! Infierno

Python 3, 45 bytes

s=input();n=int(input());print(s[-n:]+s[:-n])

El núcleo del programa es

s[-n:]+s[:-n]

Todo lo demás es solo un trabajo torpe con E / S.

K, 8 7 bytes

{|x!|y}

Ya existe un primitivo "rotar" ( !) que realiza una generalización de esta operación para las listas. Las cadenas K son listas de caracteres, por lo que se aplica. Sin embargo, la especificación favorece un poco a CJam y Pyth, porque la rotación de K pasa a la dirección opuesta a la deseada. Ajustar !una función y negar el argumento implícito xhará lo que queramos:

  f:{(-x)!y}
{(-x)!y}
  f[5;"Hello world!"]
"orld!Hello w"
  f[-3;"Testing..."]
"ting...Tes"
  f[17;"ABA"]
"BAA"

Un enfoque un poco más corto, sugerido por kirbyfan64sos, es eliminar los paréntesis y la negación a favor de invertir la cadena ( |) antes y después de la rotación.

Si no fuera por este desajuste de impedancia, la solución sería simplemente

!

Llamado idénticamente:

  f:!
!
  f[5;"Hello, World!"]
", World!Hello"
  f[-5;"Hello, World!"]
"orld!Hello, W"
  f[0;"Hello, World!"]
"Hello, World!"

Pip, 10 bytes

Esto posiblemente podría mejorarse aún más. Aún así, para un idioma sin operador de turno, 10 bytes no está mal.

a@_M-b+,#a

Explicación:

            a, b are command-line args (implicit)
       ,#a  range(len(a))
    -b+     range(-b, len(a)-b)
a@_M        map(lambda x: a[x], range(-b, len(a)-b))
            Concatenate the list and print (implicit)

Funciona porque la cadena y la lista de indexación de la pipa es cíclico: "Hello"@9 == "Hello"@4 == "o".

rs , 180 caracteres

^(-\d+) (.*)/\1 \2\t
+^(-\d+) (.)(.*?)\t(.*)$/\1 \3\t\2\4
^(-\d+) \t/\1 
^(-?)(\d+)/\1 (_)^^(\2)
+_(_*) (.*)(.)$/\1 \3\2
^- /- \t
+^- (.*?)\t(.*?)(.)$/- \1\3\t\2
^-? +/
\t/

Demostración en vivo .

La mayor parte de esto está invirtiendo la cadena si el número de entrada es negativo. Aproveché el hecho de que solo algunos caracteres ASCII son entradas válidas y utilicé la pestaña para mi ventaja.

Tenga en cuenta que tuve que hacer un poco de trampa: dado que rs es un modificador de texto de una sola línea, tuve que usarlo <number> <text>como formato de entrada.

Java, 167

enum S{;public static void main(String[]r){int n=-Integer.parseInt(r[1]),l=r[0].length();while(n<0)n+=l;n%=l;System.out.print(r[0].substring(n)+r[0].substring(0,n));}}

Toma la entrada a través de la línea de comando.

Curiosamente, originalmente había invertido accidentalmente cómo se suponía que se debía mover la cuerda. Pero corregir ese error fue más corto para multiplicar n por -1 y luego escribir la lógica correctamente.

expandido:

enum Shift{
    ;
    public static void main(String[]args){
        int n=-Integer.parseInt(args[1]),length=args[0].length();
        while(n<0)n+=length;
        n%=length;
        System.out.print(args[0].substring(n)+args[0].substring(0,n));
    }
}

PHP> = 7.1, 88 bytes (no competitivos)

for([,$s,$t]=$argv;$t;)$s=$t<0?substr($s,1).$s[!$t++]:$s[-1].substr($s,!$t--,-1);echo$s;

Casos de prueba

Japt , 2 bytes

éV

Pruébalo en línea

Casio Basic, 27 bytes

StrRotate s,s,-n:Print s

¡Resulta que hay una función integrada para esto en la Casio ClassPad! Pero funciona a la inversa, por lo tanto -n.

24 bytes para el código, 3 bytes para especificar s,ncomo argumentos.

05AB1E , 6 bytes

DgI+FÁ

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

D         # Duplicate the text input
 g        # Take it's length
          #  i.e. "Testing..." → 10
  I       # Take the integer input
   +      # Add them together
          #  i.e. 10 and -3 → 7
    F     # Loop that many times
     Á    #  And rotate once towards the right during every iteration

Dado que 05AB1E solo tiene incorporados para Girar una vez hacia la derecha / izquierda , y no Girar la Ncantidad hacia la derecha / izquierda , hago un bucle de length + inputcantidad de veces y giro tantas veces hacia la derecha.

Por ejemplo:

• "Prueba ..." y -3 rotarán 10 + -3 = 7veces hacia la derecha, lo que dará como resultado ting...Tes.
• "Hola mundo" y 5 rotarán 11 + 5 = 16veces hacia la derecha, lo que dará como resultado worldHello.

Julia 0.6 , 31 bytes

s|n=String(circshift([s...],n))

Pruébalo en línea!

Stax , 2 bytes

|)

Ejecutar y depurarlo

Perl 5 + -palF, 26 bytes

$_=substr$_.$_,@F-<>%@F,@F

Pruébalo en línea!