Contexte

Je suis actuellement dans une classe AP Comp Sci A: Java, et je veux commencer certains de mes amis sur le golf de code. J'ai un défi à relever pendant le cours, et j'aimerais voir dans combien d'octets la communauté peut relever ce défi.

Détails du défi:

Étant donné deux chaînes d'entrée, la chaîne principale et la chaîne pivot, procédez comme suit:

Si la chaîne pivot est exactement une fois en tant que sous-chaîne de la chaîne principale, la partie de la chaîne principale qui précède la chaîne pivot doit être permutée avec la partie qui suit, tout en préservant l'ordre dans lesdites sous-chaînes permutées. .

Par exemple:

Si la chaîne pivot est vide ou la chaîne pivot est pas trouvée dans la chaîne principale, le programme n'a pas besoin d'avoir un comportement défini.

S'il existe plusieurs instances de la chaîne pivot, la division doit se produire à la première et uniquement à la première instance du pivot.

Exemples: Étant donné la chaîne principale OneTwoThreeTwoOneet la chaîne pivot Two, la sortie doit être ThreeTwoOneTwoOne.

Étant donné la chaîne principale 1Two2Two3Two4et le pivot Two, la sortie devrait être 2Two3Two4Two1.

Étant donné la chaîne principale OneTwoThreeet la chaîne pivot "Two", la sortie devrait être ThreeTwoOne. Étant donné la chaîne principale the rabbit is faster than the turtleet la chaîne pivot

 is faster than 

(notez le seul espace qui suit et qui précède), la sortie devrait être the turtle is faster than the rabbit.

Étant donné la chaîne principale 1-2-3-4-5-6et le pivot -, la sortie devrait être 2-3-4-5-6-1.

Épilogue:

C'est ma toute première question sur le golf de code, donc si vous avez des suggestions ou des critiques constructives, n'hésitez pas à le dire.

De plus, mon code pour ce projet (écrit en Java parce que le cours se concentre sur cela) peut être trouvé ci-dessous. Si vous avez des conseils, j'adorerais les voir. C'est actuellement 363 octets, mais je parie que vous pouvez trouver des solutions bien meilleures et plus petites.

import java.util.Scanner;interface Main{static<T>void D(T f){System.out.println(f);}static void main(String[]A){Scanner s=new Scanner(System.in);D("Enter the first String:");String a=s.nextLine();D("Enter the pivot String:");String p=s.nextLine();if(p.isEmpty()|!a.contains(p)){D("Error: Pivot String not found.");return;}String w[]=a.split(p,2);D(w[1]+p+w[0]);}}

Remarque: Le texte pour les entrées et pour le cas où la chaîne pivot est introuvable est obligatoire pour l'affectation d'origine, mais pas pour ce défi.

Mathematica, 42 octets

Reverse@StringSplit[##,2]~StringRiffle~#2&

Essayez-le en ligne!

Gelée , 6 octets

œṣṙ1j⁴

Essayez-le en ligne!

Explication

œṣṙ1j⁴  Main Link
œṣ      Split around sublists equal to the pivot
  ṙ1    Rotate left by one
    j⁴  Rejoin on the pivot

Python 2 , 37 39 octets

lambda a,b:b.join(a.split(b,1)[::-1])

Où aest la chaîne principale et bla chaîne pivot.

Essayez-le en ligne!

Wolfram Language (Mathematica) , 34 octets

p#2<>p<>#&@@StringSplit[#,p,2]&

Essayez-le en ligne!

Une fonction au curry sans nom qui doit être appelée avec le pivot en premier et la chaîne principale en second. Par exemple, si vous avez attribué la fonction à un nom f:

f["-"]["1-2-3-4-5-6"]

Ohm v2 , 4 octets

ïλ⁴j

Essayez-le en ligne!

Perl 5 , 20 + 2 ( -pl) = 22 octets

<>=~/$_/;$_="$'$_$`"

Essayez-le en ligne!

Prend la chaîne pivot sur la première ligne, puis la chaîne complète sur la seconde.

Python 2 , 53 44 octets

merci à ThePlasmaRailgun pour quelques octets

p,m=input()
k=m.split(p,1)
print k[1]+p+k[0]

Essayez-le en ligne!

Python 2 , 37 octets

lambda a,b:b.join(a.split(b,1)[::-1])

Essayez-le en ligne!

C # (Visual C # Compiler) , 56 octets

(m,p)=>(m+p+m).Substring(m.IndexOf(p)+p.Length,m.Length)

Essayez-le en ligne!

Alice , 18 octets

/?.?.Qz
\IoI%!oo@/

Essayez-le en ligne!

Explication

/...
\...@/

Ceci est juste un cadre pour le code en mode Ordinal linéaire (traitement de chaîne). En dépliant le flux de contrôle en zigzag, nous obtenons:

I.I.!zo?o?%Qo

I.  Read the first string, duplicate it.
I   Read the second string (the pivot).
.!  Store a copy of the pivot on the tape.
z   Drop. Removes everything up to and including the pivot from the first string,
    so we get only the stuff after the pivot.
o   Output that.
?o  Retrieve the pivot from the tape and output it.
?%  Retrieve the pivot again and split the input around (all occurrences of)
    the pivot.
Q   Reverse the stack.
o   Output the top of the stack (i.e. the chunk in front of the first pivot).

SOGL V0.12 , 9 5 octets

ΘK+,∑

Essayez-le ici!

Explication:

Θ      split the 2nd input on the 1st one
 K     get the 1st element
  +    and add it to the end
   ,∑  join on the 1st input

Rétine , 24 23 octets

réservoirs à Martin Ender pour -1 octet

(.*)¶(.*?)\1(.*)
$3$1$2

Essayez-le en ligne!

Python 2 , 48 octets

lambda s,p:p.join(s.split(p)[1:]+s.split(p)[:1])

Essayez-le en ligne!

Pyth , 8 octets

jQ.<cEQ1

Essayez-le ici!

Explication

jQ.<cEQ1 - Full program.

    cEQ  - Split the second input by the first input.
  .<   1 - Cyclically rotate by 1 place to the left.
jQ       - Join on the first input.

Fusain , 13 octets

≔⪪θηθ⪫Ｅθ§θ⊕κη

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

  θ             First input
   η            Second input
 ⪪              Split
≔   θ           Assign result
      Ｅθ        Map over result
           κ    Current index
          ⊕     Incremented
        §θ      Circularly index into result
     ⪫      η   Join
                Implicitly print

R , 63 58 57 octets

function(M,P)sub(sub("_",P,"(.+?)(_)(.+)"),"\\3\\2\\1",M)

Essayez-le en ligne!

Mest la chaîne principale, Pest le pivot.

La réponse d'ovs sur la rétine a indiqué que je pouvais réparer ma tentative antérieure d'approche regex

(.+)(Pivot string)(.+)

en ajoutant ?au premier groupe de capture.

Java 8, 47 octets

x->y->x.replaceAll("(.*?)("+y+")(.*)","$3$2$1")

Essayez-le en ligne

JavaScript (ES6), 41 40 octets

(s,p,[a,...r]=s.split(p))=>r.join(p)+p+a

Cas de test

let f =

(s,p,[a,...r]=s.split(p))=>r.join(p)+p+a

console.log(f('the rabbit is faster than the turtle', ' is faster than '))
console.log(f('1-2-3-4-5-6', '-'))

J , 14 octets

#@[}.{.@ss|.,~

Comment ça fonctionne:

L'argument de gauche est le pivot, celui de droite - la chaîne à inverser

            ,~   appends the pivot to the string
     {.@ss       finds the positions of the pivot in the string and takes the first one
          |.     rotates the appended string to the left, so that the pivot is at the start
#@[              finds the length of the pivot string (n)
   }.            drops n characters from the begining of the rotated string

Essayez-le en ligne!

C,  106  100 octets

i,l;f(s,p)char*s,*p;{l=strlen(p);for(i=0;strncmp(s+i,p,l);++i);printf("%s%s",s+i+l,p);write(1,s,i);}

Essayez-le en ligne!

SNOBOL4 (CSNOBOL4) , 53 octets

	P =INPUT
	INPUT ARB . R P REM . L
	OUTPUT =L P R
END

Essayez-le en ligne!

Prend l'entrée en tant que Pivot, puis Principal, séparé par une nouvelle ligne.

Ceci est essentiellement l'équivalent SNOBOL de ma réponse R .

Perl 6 , 31 octets

->$_,$b {S/(.*?)$b(.*)/$1$b$0/}

Essaye-le

PHP, 62 octets

<?=![,$s,$p]=$argv,preg_filter("(^(.*)$p(.*)$)U","$2$p$1",$s);

nécessite PHP 7.1; peut échouer si le pivot contient des caractères spéciaux regex ( \+*?[^]$(){}=!<>|:-).
aucun changement si Pivot est vide, sortie vide si Pivot n'est pas en entrée.
Courir avec-n .

version sûre, 77 octets:

<?=preg_filter("(^(.*)".preg_quote($p=$argv[1])."(.*)$)U","$2$p$1",$argv[2]);

aucun changement si Pivot est vide, sortie vide si Pivot n'est pas en entrée.
Courez avec -n.

version non regex, 71 octets:

$a=explode($p=$argv[2],$argv[1]);$a[]=array_shift($a);echo join($p,$a);

renvoie des avertissements si le pivot est vide; aucun changement si Pivot n'est pas en entrée.

Courez avec -nr.

Essayez-les en ligne .

Rouge , 63 octets

f: func[p s][rejoin[copy find/tail s p p copy/part s find s p]]

Essayez-le en ligne!

Swift , 131 octets

import Foundation
func f(s:String,d:String){var c=s.components(separatedBy:d);print((c+[c[0]]).suffix(from:1).joined(separator:d))}

Explication (non golfée)

import Foundation                     // Import String.components
func f(s:String,d:String){
    var c=s.components(separatedBy:d) // Split the input string by the separator
    print((c+[c[0]])                  // Add the last element of c ([A,B,C] -> [A,B,C,A])
        .suffix(from:1)               // Remove the first element  ([A,B,C,A] -> [B,C,A])
        .joined(separator:d))         // Join with the separator
}

C (gcc) , 76 octets

f(s,t)char*s,*t;{char*p=strstr(s,t);printf("%s%s%.*s",p+strlen(t),t,p-s,s);}

Essayez-le en ligne!

C ++ 11, 64 octets

[s,p,&a]{int f=s.find(p);a=s.substr(f+p.size())+p+s.substr(0,f);}

Un lambda, qui capture les chaînes s, p et a, avec a comme référence (in-out).

Code de test

#include <iostream>
#include <string>

std::string Test(std::string s, std::string p) {
    std::string a;
[s,p,&a]{int f=s.find(p);a=s.substr(f+p.size())+p+s.substr(0,f);}();
    return a; 
}

int main() {
    std::string 
        s = "OneTwoThreeTwoOne",
        p = "Two",
        r = "ThreeTwoOneTwoOne";
    auto a = Test(s,p);
    std::cout << ((a==r)?"OK":"Failed") << ": " << a << std::endl; 

    return 0;
}

Nettoyer , 83 octets

import StdEnv;f s c=(\p=p takeWhile++[hd s,c:p dropWhile])\g=reverse(tl(g((<>)c)s))

Un Stringdans Clean est normalement {#Char}- un tableau unboxed ( #) Char( {}). Cette fonction prend la [Char]place de String, qui est une deuxième version valide de String.

La signature de fonction complète est f :: [.t] .t -> [.t] | [.t <= Char].

Essayez-le en ligne!

Japt , 8 7 octets

£Zg°Y}V

Essayez-le ici