In questa sfida, è necessario spostare i caratteri in una stringa immessa n numero di volte e generare la stringa spostata

Ingresso

L'input conterrà prima una stringa. Nella riga successiva, nsarà presente un numero intero, che indica .

Produzione

• Se nè positivo, sposta i caratteri nella stringa nei nmomenti giusti .
• Se nè negativo, sposta i caratteri nella stringa verso sinistra n.
• Se nè zero, non spostare i caratteri nella stringa.

Dopo lo spostamento (tranne quando nè zero), stampare la stringa spostata.

Appunti

• La stringa non sarà vuota o null.
• La stringa non sarà più lunga di 100 caratteri e conterrà solo caratteri ASCII nell'intervallo (spazio) da ~(tilde) (codici carattere da 0x20 a 0x7E, inclusi). Vedere la tabella ASCII per riferimento.
• Lo spostamento è ciclico.
• Il numero npuò essere positivo, negativo o zero.
• n sarà sempre maggiore o uguale a -1000 e minore o uguale a 1000
• È possibile accettare input tramite stdino da argomenti della riga di comando
• La stringa spostata deve essere emessa nel stdout(o equivalente più vicino)
• È possibile scrivere un programma completo o una funzione che accetta input e genera la stringa stdoutnell'equivalente più vicino

Casi test

1)

Hello world!
5             -->orld!Hello w

2)

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

3)

~~~
1000          -->~~~

4)

12345
0             -->12345

5)

ABA
17            -->BAA

punteggio

Questo è code-golf , quindi vince l'invio più breve (in byte).

Pyth, 4 byte

.>zQ

Questo è quasi simile alla mia versione CJam 5 byte , tranne che Pyth come operatore di input di valutazione automatica Q.

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

Provalo online qui

Javascript ( ES5 ), 55 52 byte

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

ha commentato:

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 byte

llim>

Questo è piuttosto semplice.

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

Provalo online qui

C, 93 byte

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

Più chiara è la versione dell'argomento della funzione che è stata modificata per rendere la versione dell'argomento della riga di comando

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

Questo ha solo 68 byte, il che dimostra quanto C sia svantaggiato quando si tratta di argomenti da riga di comando.

Se lo spostamento,, nè positivo, allora strlen(s)-n%strlen(s)è l'offset e se nè negativo lo è -n%strlen(s). Le printfstampe dall'offset, cfino alla fine della stringa, e quindi i ccaratteri finali dall'inizio.

Esempi:

$ ./rotstr "Ciao mondo!" 5
orld! Ciao w
$ ./rotstr "Test ..." -3
ting ... Tes
$ ./rotstr "~~~" 1000
~~~
$ ./rotstr "12345" 0
12345
$ ./rotstr "ABA" 17
BAA
$ ./rotstr "Ciao mondo!" -16
o mondo! Inferno

Python 3, 45 byte

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

Il nocciolo del programma è

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

Tutto il resto è solo un lavoro goffo con l'I / O.

K, 8 7 byte

{|x!|y}

Esiste già una "rotazione" primitiva ( !) che esegue una generalizzazione di questa operazione per gli elenchi. Le stringhe K sono elenchi di caratteri, quindi si applica. Le specifiche favoriscono un po 'CJam e Pyth, però, perché la rotazione di K sembra andare nella direzione opposta a ciò che si desidera. Avvolgere !una funzione e annullare l'argomento implicito xfarà ciò che vogliamo:

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

Un approccio leggermente più breve, suggerito da kirbyfan64sos, è quello di eliminare le parentesi e la negazione a favore dell'inversione della stringa ( |) prima e dopo la rotazione.

Se non fosse per questa discrepanza di impedenza, la soluzione sarebbe semplicemente

!

Chiamato in modo identico:

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

Pip, 10 byte

Questo potrebbe probabilmente essere ulteriormente migliorato. Tuttavia, per una lingua senza operatore a turni, 10 byte non sono male.

a@_M-b+,#a

Spiegazione:

            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)

Funziona perché stringa e lista indicizzazione nei Pip è ciclica: "Hello"@9 == "Hello"@4 == "o".

rs , 180 caratteri

^(-\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/

Demo dal vivo .

La maggior parte di questo sta invertendo la stringa se il numero di input è negativo. Ho approfittato del fatto che solo alcuni caratteri ASCII sono input validi e ho usato la scheda a mio vantaggio.

Nota che ho dovuto imbrogliare un po ': poiché rs è un modificatore di testo a riga singola, ho dovuto usare <number> <text>come formato di input.

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

Accetta l'input tramite la riga di comando.

abbastanza divertente, originariamente avevo invertito accidentalmente il modo in cui la stringa doveva essere spostata. Ma correggere quell'errore è stato più breve semplicemente moltiplicando n per -1, quindi per scrivere correttamente la logica.

allargato:

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 byte (non competitivo)

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

Casi test

Japt , 2 byte

éV

Provalo online

Casio Basic, 27 byte

StrRotate s,s,-n:Print s

A quanto pare, c'è un built-in per questo sul Casio ClassPad! Ma funziona al contrario, quindi -n.

24 byte per il codice, 3 byte da specificare s,ncome argomenti.

05AB1E , 6 byte

DgI+FÁ

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Poiché 05AB1E ha solo i builtin per Ruota una volta verso destra / sinistra , e non Ruota Nquantità verso destra / sinistra , eseguo il ciclo length + inputdi volte e lo giro molte volte verso destra.

Per esempio:

• "Test ..." e -3 ruoteranno i 10 + -3 = 7tempi verso destra, risultando in ting...Tes.
• "Hello world" e 5 ruoteranno i 11 + 5 = 16tempi verso destra, risultando in worldHello.

Julia 0.6 , 31 byte

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

Provalo online!

Stax , 2 byte

|)

Esegui ed esegui il debug

Perl 5 + -palF, 26 byte

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

Provalo online!