Bei dieser Herausforderung müssen Sie die Zeichen in einer eingegebenen Zeichenfolge n-mal verschieben und die verschobene Zeichenfolge ausgeben

Eingang

Die Eingabe enthält zunächst eine Zeichenfolge. In der nächsten Zeile steht eine ganze Zahl, die bezeichnet n.

Ausgabe

• Wenn dies npositiv ist, verschieben Sie die Zeichen in der Zeichenfolge nach rechts n.
• Wenn dies nnegativ ist, verschieben Sie die Zeichen in der Zeichenfolge nach links n.
• Wenn nNull ist, verschieben Sie die Zeichen in der Zeichenfolge nicht.

nDrucken Sie nach dem Verschieben (außer wenn Null ist) die verschobene Zeichenfolge.

Anmerkungen

• Die Zeichenfolge wird nicht leer sein oder null.
• Die Zeichenfolge darf nicht länger als 100 Zeichen sein und enthält nur ASCII-Zeichen im Bereich (Leerzeichen) bis ~(Tilde) (Zeichencodes 0x20 bis 0x7E, einschließlich). Siehe ASCII-Tabelle als Referenz.
• Die Verschiebung ist zyklisch.
• Die Zahl nkann positiv, negativ oder null sein.
• n wird immer größer oder gleich -1000 und kleiner oder gleich 1000 sein
• Sie können Eingaben über stdinoder über Befehlszeilenargumente vornehmen
• Die verschobene Zeichenfolge muss in der stdout(oder der nächsthöheren Entsprechung) ausgegeben werden.
• Sie können ein vollständiges Programm oder eine Funktion schreiben, die die Eingabe und Ausgabe der Zeichenfolge in stdoutoder in der nächsten Entsprechung übernimmt

Testfälle

1)

Hello world!
5             -->orld!Hello w

2)

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

3)

~~~
1000          -->~~~

4)

12345
0             -->12345

5)

ABA
17            -->BAA

Wertung

Dies ist Code-Golf , also gewinnt die kürzeste Einreichung (in Bytes).

Pyth, 4 Bytes

.>zQ

Das ist fast ähnlich wie meiner CJam-5-Byte-Version , mit der Ausnahme, dass Pyth als Operator für die automatische Bewertung der Eingabe fungiert Q.

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

Probieren Sie es hier online aus

Javascript ( ES5 ), 55 52 Bytes

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

Kommentiert:

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>

Das ist ziemlich einfach.

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

Probieren Sie es hier online aus

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

Deutlicher ist die Funktionsargumentversion, die geändert wurde, um die Befehlszeilenargumentversion zu erstellen

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

Dies sind nur 68 Bytes, was nur zeigt, wie benachteiligt C im Umgang mit Befehlszeilenargumenten ist.

Wenn die Verschiebung,, npositiv ist, strlen(s)-n%strlen(s)ist der Versatz und wenn sie nnegativ ist, ist der Versatz -n%strlen(s). Der printfAusdruck erfolgt vom Offset, cbis zum Ende der Zeichenfolge und dann die letzten cZeichen vom Anfang an.

Beispiele:

$ ./rotstr "Hallo Welt!" 5
orld! Hallo w
$ ./rotstr "Testing ..." -3
ting ... Tes
$ ./rotstr "~~~" 1000
~~~
$ ./rotstr "12345" 0
12345
$ ./rotstr "ABA" 17
BAA
$ ./rotstr "Hallo Welt!" -16
o Welt! Hölle

Python 3, 45 Bytes

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

Der Kern des Programms ist

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

Der Rest ist nur schwerfällige Arbeit mit I / O.

K, 8 7 Bytes

{|x!|y}

Es gibt bereits ein primitives "rotate" ( !), das eine Verallgemeinerung dieser Operation für Listen durchführt. K-Zeichenfolgen sind Listen von Zeichen, daher gilt dies. Die Spezifikation bevorzugt jedoch CJam und Pyth, da Ks Drehung zufällig in die entgegengesetzte Richtung von dem geht, was gewünscht wird. Verpackung! eine Funktion einschließen und das implizite Argument negieren x, tun Sie, was wir wollen:

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

Ein etwas kürzerer Ansatz, den kirbyfan64sos vorschlägt, besteht darin, die Klammern und die Negation zu beseitigen, um die Zeichenfolge ( |) vor und nach der Drehung umzukehren .

Ohne diese Impedanzfehlanpassung wäre die Lösung einfach

!

Identisch genannt:

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

Pip, 10 Bytes

Dies könnte möglicherweise weiter verbessert werden. Für eine Sprache ohne Shift-Operator sind 10 Bytes jedoch nicht schlecht.

a@_M-b+,#a

Erläuterung:

            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)

Es funktioniert , weil String und Liste Indizierung in Pip ist zyklisch: "Hello"@9 == "Hello"@4 == "o".

rs , 180 Zeichen

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

Live-Demo .

Meistens wird die Zeichenfolge umgekehrt, wenn die eingegebene Nummer negativ ist. Ich habe die Tatsache ausgenutzt, dass nur einige ASCII-Zeichen gültige Eingaben sind, und die Registerkarte zu meinem Vorteil verwendet.

Beachten Sie, dass ich ein wenig schummeln musste: Da rs ein einzeiliger Textmodifikator ist, musste ich <number> <text>als Eingabeformat verwenden.

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

Übernimmt die Eingabe über die Befehlszeile.

lustig genug, ursprünglich hatte ich versehentlich umgekehrt, wie die Saite verschoben werden sollte. Die Behebung dieses Fehlers war jedoch kürzer, als nur n mit -1 zu multiplizieren und dann die Logik richtig zu schreiben.

erweitert:

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 (nicht konkurrierend)

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

Testfälle

Japt , 2 Bytes

éV

Probieren Sie es online aus

Casio Basic, 27 Bytes

StrRotate s,s,-n:Print s

Wie sich herausstellt, gibt es dafür ein eingebautes Casio ClassPad! Aber es funktioniert umgekehrt-n .

24 Bytes für den Code, 3 Bytes s,nals Argumente.

05AB1E , 6 Bytes

DgI+FÁ

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

Seit 05AB1E gibt es nur integrierte Funktionen zum Drehen einmal nach rechts / links und nicht zum Drehen des NBetrags nach rechts / links , I - Schleifelength + input Höhe der Zeit und dass viele Male nach rechts drehen.

Beispielsweise:

• "Testing ..." und -3 drehen sich 10 + -3 = 7 mal nach rechts, was zur Folge hatting...Tes .
• "Hallo Welt" und 5 drehen sich 11 + 5 = 16mal nach rechts, was dazu führt worldHello.

Julia 0,6 , 31 Bytes

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

Probieren Sie es online!

Stax , 2 Bytes

|)

Führen Sie es aus, und debuggen Sie es

Perl 5+ -palF, 26 Bytes

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

Probieren Sie es online!