Dans ce défi, vous devez déplacer les caractères dans une chaîne entrée n nombre de fois et sortir la chaîne décalée

Contribution

L'entrée contiendra d'abord une chaîne. Dans la ligne suivante, un entier, qui indique nsera présent.

Production

• Si nest positif, déplacez les caractères de la chaîne au bon nmoment.
• Si nest négatif, déplacez les caractères de la chaîne vers la gauche n.
• Si nest égal à zéro, ne déplacez pas les caractères dans la chaîne.

Après le décalage (sauf quand nest zéro), imprimez la chaîne décalée.

Remarques

• La chaîne ne sera pas vide ou null.
• La chaîne ne dépassera pas 100 caractères et ne contiendra que des caractères ASCII dans la plage (espace) à ~(tilde) (codes de caractères 0x20 à 0x7E, inclus). Voir le tableau ASCII pour référence.
• Le changement est cyclique.
• Le nombre npeut être positif, négatif ou nul.
• n sera toujours supérieur ou égal à -1000 et inférieur ou égal à 1000
• Vous pouvez prendre des entrées via stdinou à partir d'arguments de ligne de commande
• La chaîne décalée doit être sortie dans stdout(ou l'équivalent le plus proche)
• Vous pouvez écrire un programme complet ou une fonction qui prend en entrée et sort la chaîne dans stdoutou l'équivalent le plus proche

Cas de test

1)

Hello world!
5             -->orld!Hello w

2)

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

3)

~~~
1000          -->~~~

4)

12345
0             -->12345

5)

ABA
17            -->BAA

Notation

Il s'agit de code-golf , donc la soumission la plus courte (en octets) l'emporte.

Pyth, 4 octets

.>zQ

Ceci est presque similaire à ma version CJam 5 octets , sauf que Pyth en tant qu'opérateur d'entrée auto-eval Q.

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

Essayez-le en ligne ici

Javascript ( ES5 ), 55 52 octets

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

Commenté:

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 octets

llim>

C'est assez simple.

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

Essayez-le en ligne ici

C, 93 octets

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

Plus claire est la version d'argument de fonction qui a été modifiée pour rendre la version d'argument de ligne de commande

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

Celui-ci ne fait que 68 octets, ce qui montre à quel point C est désavantagé lors du traitement des arguments de ligne de commande.

Si le décalage,, nest positif alors strlen(s)-n%strlen(s)est le décalage et s'il nest négatif, le décalage est -n%strlen(s). Les printfimpressions à partir du décalage,, cjusqu'à la fin de la chaîne, puis les derniers ccaractères depuis le début.

Exemples:

$ ./rotstr "Bonjour tout le monde!" 5
orld! Bonjour w
$ ./rotstr "Test ..." -3
ting ... Tes
$ ./rotstr "~~~" 1000
~~~
$ ./rotstr "12345" 0
12345
$ ./rotstr "ABA" 17
BÊLEMENT
$ ./rotstr "Bonjour tout le monde!" -16
ô monde! Enfer

Python 3, 45 octets

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

Le cœur du programme est

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

Tout le reste n'est qu'un travail maladroit avec les E / S.

K, 8 7 octets

{|x!|y}

Il existe déjà une "rotation" ( !) primitive qui effectue une généralisation de cette opération pour les listes. Les chaînes K sont des listes de caractères, donc cela s'applique. La spécification favorise un peu CJam et Pyth, car la rotation de K se trouve dans le sens inverse de ce qui est souhaité. Envelopper !dans une fonction et annuler l'argument implicite xfera ce que nous voulons:

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

Une approche légèrement plus courte, suggérée par kirbyfan64sos, consiste à supprimer les parenthèses et la négation au profit de l'inversion de la chaîne ( |) avant et après la rotation.

S'il n'y avait pas ce décalage d'impédance, la solution serait simplement

!

Appelé à l'identique:

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

Pip, 10 octets

Cela pourrait très probablement être encore amélioré. Pourtant, pour une langue sans opérateur de décalage, 10 octets n'est pas mauvais.

a@_M-b+,#a

Explication:

            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)

Cela fonctionne parce que la chaîne et l' indexation liste Pip est cyclique: "Hello"@9 == "Hello"@4 == "o".

rs , 180 caractères

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

Démo en direct .

La plupart de ceci inverse la chaîne si le nombre d'entrée est négatif. J'ai profité du fait que seuls certains caractères ASCII sont des entrées valides et j'ai utilisé l'onglet à mon avantage.

Notez que j'ai dû tricher un peu: comme rs est un modificateur de texte sur une seule ligne, j'ai dû utiliser <number> <text>comme format d'entrée.

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

Prend l'entrée via la ligne de commande.

assez drôle, à l'origine, j'avais accidentellement inversé la façon dont la chaîne devait être décalée. Mais corriger cette erreur était plus court pour multiplier simplement n par -1 puis pour écrire correctement la logique.

étendu:

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 octets (sans concurrence)

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

Cas de test

Japt , 2 octets

éV

Essayez-le en ligne

Casio Basic, 27 octets

StrRotate s,s,-n:Print s

En fait, il y a une fonction intégrée pour cela sur le Casio ClassPad! Mais cela fonctionne à l'envers, donc -n.

24 octets pour le code, 3 octets à spécifier s,ncomme arguments.

05AB1E , 6 octets

DgI+FÁ

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

Étant donné que 05AB1E ne dispose de fonctions de rotation qu'une seule fois vers la droite / gauche , et non une rotation Nvers la droite / gauche , je boucle plusieurs length + inputfois et je tourne autant de fois vers la droite.

Par exemple:

• "Testing ..." et -3 tourneront les 10 + -3 = 7temps vers la droite, ce qui entraînera ting...Tes.
• "Bonjour tout le monde" et 5 tourneront les 11 + 5 = 16temps vers la droite, résultant en worldHello.

Julia 0,6 , 31 octets

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

Essayez-le en ligne!

Stax , 2 octets

|)

Exécuter et déboguer

Perl 5 + -palF, 26 octets

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

Essayez-le en ligne!