Hintergrund

Ich bin zurzeit in einer AP Comp Sci A: Java-Klasse und möchte einige meiner Freunde mit dem Code-Golfen beginnen. Ich habe eine Herausforderung aus dem Kurs und möchte sehen, in wie vielen Bytes die Community diese Herausforderung durchführen kann.

Herausforderungsdetails:

Wenn zwei Eingabezeichenfolgen, die Hauptzeichenfolge und die Pivotzeichenfolge, angegeben werden, gehen Sie wie folgt vor:

Wenn die Pivot-Zeichenfolge genau einmal Teil der Hauptzeichenfolge ist, muss der Teil der Hauptzeichenfolge, der vor der Pivot-Zeichenfolge liegt, mit dem nachfolgenden Teil ausgetauscht werden , wobei die Reihenfolge innerhalb der auszutauschenden Unterzeichenfolgen beibehalten wird .

Beispielsweise:

Wenn die Pivot-Zeichenfolge leer ist oder die Pivot-Zeichenfolge nicht in der Hauptzeichenfolge gefunden wird, muss das Programm kein definiertes Verhalten aufweisen.

Wenn mehr als eine Instanz der Pivot-Zeichenfolge vorhanden ist, sollte die Aufteilung bei der ersten und nur bei der ersten Instanz des Pivots erfolgen.

Beispiele: Ausgehend von der Hauptzeichenfolge OneTwoThreeTwoOneund der Pivotzeichenfolge Twosollte die Ausgabe sein ThreeTwoOneTwoOne.

Wenn der Hauptstring 1Two2Two3Two4und der Drehpunkt gegeben sind Two, sollte die Ausgabe sein 2Two3Two4Two1.

Bei der gegebenen Hauptzeichenfolge OneTwoThreeund der Pivotzeichenfolge "Zwei" sollte die Ausgabe sein ThreeTwoOne. Gegeben die Hauptschnur the rabbit is faster than the turtleund die Pivotschnur

 is faster than 

(beachte das einzelne Leerzeichen nach und vor), sollte die Ausgabe sein the turtle is faster than the rabbit.

Wenn der Hauptstring 1-2-3-4-5-6und der Drehpunkt gegeben sind -, sollte die Ausgabe sein 2-3-4-5-6-1.

Nachwort:

Dies ist meine allererste Frage zum Thema Codegolf. Wenn Sie also Vorschläge oder konstruktive Kritik haben, können Sie dies gerne sagen.

Außerdem ist mein Code für dieses Projekt (in Java geschrieben, weil der Kurs darauf abzielt) unten zu finden. Wenn Sie Tipps haben, würde ich sie gerne sehen. Derzeit sind es 363 Bytes, aber ich wette, ihr könnt euch viel bessere und kleinere Lösungen einfallen lassen.

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

Hinweis: Der Text für die Eingaben und für den Fall, dass die Pivot-Zeichenfolge nicht gefunden wird, ist für die ursprüngliche Zuweisung obligatorisch, jedoch nicht für diese Herausforderung.

Mathematica, 42 Bytes

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

Probieren Sie es online!

Gelee , 6 Bytes

œṣṙ1j⁴

Probieren Sie es online!

Erläuterung

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

Python 2 , 37 39 Bytes

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

Wo aist die Hauptsaite und bist die Pivot-Saite.

Probieren Sie es online!

Wolfram Language (Mathematica) , 34 Byte

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

Probieren Sie es online!

Eine unbenannte Curry-Funktion, die mit dem Pivot zuerst und dem Hauptstring zweitens aufgerufen werden sollte. Wenn Sie beispielsweise die Funktion einem Namen zugewiesen haben f:

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

Ohm v2 , 4 Bytes

ïλ⁴j

Probieren Sie es online!

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

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

Probieren Sie es online!

Nimmt die Pivot-Zeichenfolge in die erste Zeile, dann die vollständige Zeichenfolge in die zweite.

Python 2 , 53 44 Bytes

danke an ThePlasmaRailgun für ein paar Bytes

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

Probieren Sie es online!

Python 2 , 37 Bytes

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

Probieren Sie es online!

C # (Visual C # -Compiler) , 56 Byte

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

Probieren Sie es online!

Alice , 18 Bytes

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

Probieren Sie es online!

Erläuterung

/...
\...@/

Dies ist nur ein Framework für Code im linearen Ordinalmodus (Zeichenfolgenverarbeitung). Wenn wir den Zick-Zack-Kontrollfluss entfalten, erhalten wir:

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 Bytes

ΘK+,∑

Probieren Sie es hier aus!

Erläuterung:

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

Retina , 24 23 Bytes

Tanks an Martin Ender für -1 Byte

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

Probieren Sie es online!

Python 2 , 48 Bytes

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

Probieren Sie es online!

Pyth , 8 Bytes

jQ.<cEQ1

Probieren Sie es hier aus!

Erläuterung

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.

Kohle , 13 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

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

R , 63 58 57 Bytes

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

Probieren Sie es online!

Mist die Hauptsaite, Pist der Dreh- und Angelpunkt.

Die Retina-Antwort von ovs zeigte an, dass ich meinen früheren Versuch eines Regex-Ansatzes reparieren konnte

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

durch Hinzufügen ?zur ersten Erfassungsgruppe.

Java 8, 47 Bytes

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

Probieren Sie es online aus

JavaScript (ES6), 41 bis 40 Byte

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

Testfälle

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 Bytes

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

Wie es funktioniert:

Das linke Argument ist der Drehpunkt, das rechte der umzukehrende String

            ,~   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

Probieren Sie es online!

C  106  100 Bytes

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

Probieren Sie es online!

SNOBOL4 (CSNOBOL4) , 53 Byte

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

Probieren Sie es online!

Nimmt die Eingabe als Pivot, dann als Main, getrennt durch eine neue Zeile.

Dies ist im Grunde das SNOBOL-Äquivalent meiner R-Antwort .

Perl 6 , 31 Bytes

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

Probier es aus

PHP, 62 Bytes

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

benötigt PHP 7.1; kann fehlschlagen, wenn der Pivot Regex-Sonderzeichen ( \+*?[^]$(){}=!<>|:-) enthält.
Keine Änderungen, wenn Pivot leer ist. Leere Ausgabe, wenn Pivot nicht in der Eingabe ist.
Laufen Sie mit -n.

sichere Version, 77 Bytes:

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

Keine Änderungen, wenn Pivot leer ist. Leere Ausgabe, wenn Pivot nicht in der Eingabe ist.
Laufen Sie mit -n.

Nicht-Regex-Version, 71 Bytes:

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

gibt Warnungen aus, wenn der Pivot leer ist; Keine Änderung, wenn Pivot nicht in der Eingabe ist.

Laufen Sie mit -nr.

Probieren Sie sie online aus .

Rot , 63 Bytes

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

Probieren Sie es online!

Schnell , 131 Bytes

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

Erklärung (ungolfed)

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 Bytes

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

Probieren Sie es online!

C ++ 11, 64 Bytes

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

Ein Lambda, das die Zeichenfolgen s, p und a erfasst, mit a als Referenz (in-out).

Code testen

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

Sauber , 83 Bytes

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

Ein Stringin Clean ist normalerweise {#Char}- ein unboxed ( #) CharArray ( {}). Diese Funktion benötigt [Char]stattdessen Stringeine zweite, gültige Version von String.

Die Vollfunktionssignatur ist f :: [.t] .t -> [.t] | [.t <= Char].

Probieren Sie es online!

Japt , 8 7 Bytes

£Zg°Y}V

Probieren Sie es hier aus