Nesse desafio, você deve alterar os caracteres em uma sequência de caracteres inserida n número de vezes e emitir a sequência de caracteres deslocada

Entrada

A entrada primeiro conterá uma sequência. Na próxima linha, um número inteiro, que indica nestará presente.

Resultado

• Se nfor positivo, mude os caracteres da sequência para os nhorários certos .
• Se nfor negativo, mude os caracteres da sequência para os ntempos da esquerda .
• Se nfor zero, não mude os caracteres na string.

Após o deslocamento (exceto quando nzero), imprima a sequência deslocada.

Notas

• A cadeia não estará vazia ou null.
• A cadeia não terá mais de 100 caracteres e conterá apenas caracteres ASCII no intervalo (espaço) a ~(til) (códigos de caracteres 0x20 a 0x7E, inclusive). Consulte a tabela ASCII para referência.
• A mudança é cíclica.
• O número npode ser positivo, negativo ou zero.
• n será sempre maior ou igual a -1000 e menor ou igual a 1000
• Você pode receber informações via stdinou a partir de argumentos da linha de comando
• A string deslocada deve ser emitida no stdout(ou equivalente mais próximo)
• Você pode escrever um programa completo ou uma função que recebe entrada e gera a string no stdoutequivalente mais próximo

Casos de teste

1)

Hello world!
5             -->orld!Hello w

2)

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

3)

~~~
1000          -->~~~

4)

12345
0             -->12345

5)

ABA
17            -->BAA

Pontuação

Isso é código-golfe , então o envio mais curto (em bytes) vence.

Pitão, 4 bytes

.>zQ

Isso é quase semelhante à minha versão de 5 bytes do CJam , exceto pelo Pyth como um operador de entrada de avaliação automática Q.

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

Experimente online aqui

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>

Isso é bem direto.

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

Experimente online aqui

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]);}

Mais clara é a versão do argumento da função que foi modificada para tornar a versão do argumento da linha 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 tem apenas 68 bytes, o que mostra apenas como C está em desvantagem ao lidar com argumentos de linha de comando.

Se o deslocamento,, né positivo, então strlen(s)-n%strlen(s)é o deslocamento e se né negativo, o deslocamento é -n%strlen(s). As printfimpressões do deslocamento,, caté o final da sequência e, em seguida, os ccaracteres finais desde o início.

Exemplos:

$ ./rotstr "Olá, mundo!" 5
Olá, Olá!
$ ./rotstr "Testando ..." -3
ting ... Tes
$ ./rotstr "~~~" 1000
~~~
$ ./rotstr "12345" 0
12345
$ ./rotstr "ABA" 17
BAA
$ ./rotstr "Olá, mundo!" -16
o mundo!

Python 3, 45 bytes

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

O núcleo do programa é

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

Todo o resto é apenas um trabalho desajeitado com E / S.

K, 8 7 bytes

{|x!|y}

Já existe um primitivo "rotate" ( !) que executa uma generalização dessa operação para listas. K strings são listas de caracteres, portanto se aplicam. A especificação favorece um pouco CJam e Pyth, porque a rotação de K passa na direção oposta ao que é desejado. O agrupamento !de uma função e a negação do argumento implícito xfarão o que queremos:

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

Uma abordagem um pouco mais curta, sugerida por kirbyfan64sos, é eliminar os parênteses e a negação em favor de reverter a string ( |) antes e depois da rotação.

Se não fosse por essa incompatibilidade de impedância, a solução seria simplesmente

!

Chamado de forma idêntica:

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

Pip, 10 bytes

Isso poderia possivelmente ser melhorado ainda mais. Ainda assim, para um idioma sem operador de turno, 10 bytes não são ruins.

a@_M-b+,#a

Explicação:

            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)

Ele funciona porque corda e lista de indexação em Pip é cíclica: "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/

Demonstração ao vivo .

A maior parte disso está revertendo a string se o número de entrada for negativo. Aproveitei o fato de que apenas alguns caracteres ASCII são válidos e usei a guia para minha vantagem.

Note que eu tive que trapacear um pouco: como o rs é um modificador de texto de linha única, eu tive que usar <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));}}

Leva a entrada pela linha de comando.

engraçado o suficiente, originalmente eu havia revertido acidentalmente como a corda deveria ser trocada. Mas corrigir esse erro foi mais curto: basta multiplicar n por -1 e depois escrever a lógica corretamente.

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 (não concorrente)

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

Casos de teste

Japonês , 2 bytes

éV

Experimente online

Casio Basic, 27 bytes

StrRotate s,s,-n:Print s

Como se vê, há um recurso interno para isso na Casio ClassPad! Mas funciona ao contrário, portanto -n.

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

05AB1E , 6 bytes

DgI+FÁ

Experimente online ou verifique todos os casos de teste .

Explicação:

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

Como o 05AB1E possui apenas integrados para Girar uma vez para a direita / esquerda , e não Girar Nquantidade para a direita / esquerda , faço um loop na length + inputquantidade de vezes e giro várias vezes para a direita.

Por exemplo:

• "Testando ..." e -3 girarão os 10 + -3 = 7tempos para a direita, resultando em ting...Tes.
• "Olá, mundo" e 5 girarão os 11 + 5 = 16tempos para a direita, resultando em worldHello.

Julia 0.6 , 31 bytes

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

Experimente online!

Stax , 2 bytes

|)

Execute e depure

Perl 5 + -palF, 26 bytes

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

Experimente online!