Antecedentes

Actualmente estoy en una clase AP Comp Sci A: Java, y quiero comenzar a algunos de mis amigos en golf de código. Tengo un desafío del curso, y me gustaría ver en cuántos bytes la comunidad puede hacer este desafío.

Detalles del desafío:

Dadas dos cadenas de entrada, la cadena principal y la cadena de pivote, haga lo siguiente:

Si la cadena de pivote es exactamente una vez como una subcadena de la cadena principal, la parte de la cadena principal que viene antes de la cadena de pivote se intercambiará con la parte que viene después, mientras se preserva el orden dentro de dichas subcadenas que se intercambian .

Por ejemplo:

Si la cadena dinámica está vacía o la cadena dinámica no se encuentra dentro de la cadena principal, el programa no tiene que tener un comportamiento definido.

Si hay más de una instancia de la cadena de pivote, la división debe ocurrir en la primera y solo la primera instancia del pivote.

Ejemplos: Dada la cadena principal OneTwoThreeTwoOney la cadena dinámica Two, la salida debería ser ThreeTwoOneTwoOne.

Dada la cadena principal 1Two2Two3Two4y el pivote Two, la salida debería ser 2Two3Two4Two1.

Dada la cadena principal OneTwoThreey la cadena de pivote "Dos", la salida debería ser ThreeTwoOne. Dada la cadena principal the rabbit is faster than the turtley la cadena de pivote

 is faster than 

(tenga en cuenta el espacio único que sigue y anterior), la salida debe ser the turtle is faster than the rabbit.

Dada la cadena principal 1-2-3-4-5-6y el pivote -, la salida debería ser 2-3-4-5-6-1.

Epílogo:

Esta es mi primera pregunta sobre el código de golf, así que si tiene sugerencias o críticas constructivas, no dude en decirlo.

Además, mi código para este proyecto (escrito en Java porque el curso se centra en eso) se puede encontrar a continuación. Si tienes algún consejo, me encantaría verlo. Actualmente tiene 363 bytes, pero apuesto a que ustedes pueden encontrar soluciones mucho mejores y más pequeñas.

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

Nota: El texto para las entradas y para el caso de que no se encuentre la cadena de pivote es obligatorio para la asignación original, pero no para este desafío.

Mathematica, 42 bytes

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

Pruébalo en línea!

Jalea , 6 bytes

œṣṙ1j⁴

Pruébalo en línea!

Explicación

œṣṙ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])

¿Dónde aestá la cadena principal y bes la cadena de pivote?

Pruébalo en línea!

Wolfram Language (Mathematica) , 34 bytes

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

Pruébalo en línea!

Una función curry sin nombre que debe llamarse con el pivote primero y la cadena principal segundo. Por ejemplo, si asignó la función a un nombre f:

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

Ohm v2 , 4 bytes

ïλ⁴j

Pruébalo en línea!

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

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

Pruébalo en línea!

Toma la cadena de pivote en la primera línea, luego la cadena completa en la segunda.

Python 2 , 53 44 bytes

gracias a ThePlasmaRailgun por algunos bytes

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

Pruébalo en línea!

Python 2 , 37 bytes

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

Pruébalo en línea!

C # (compilador de Visual C #) , 56 bytes

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

Pruébalo en línea!

Alice , 18 bytes

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

Pruébalo en línea!

Explicación

/...
\...@/

Esto es solo un marco para el código lineal del modo ordinal (procesamiento de cadenas). Al desplegar el flujo de control en zigzag, obtenemos:

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+,∑

Pruébalo aquí!

Explicación:

Θ      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

tanques a Martin Ender por -1 byte

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

Pruébalo en línea!

Python 2 , 48 bytes

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

Pruébalo en línea!

Pyth , 8 bytes

jQ.<cEQ1

Pruébalo aquí!

Explicación

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.

Carbón , 13 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

  θ             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)

Pruébalo en línea!

Mes la cadena principal, Pes el pivote.

La respuesta de Retina de ovs indicó que podía reparar mi intento anterior de un enfoque de expresiones regulares

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

agregando ?al primer grupo de captura.

Java 8, 47 bytes

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

Pruébalo en línea

JavaScript (ES6), 41 40 bytes

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

Casos de prueba

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

Cómo funciona:

El argumento izquierdo es el pivote, el derecho: la cadena que se va a invertir.

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

Pruébalo en línea!

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

Pruébalo en línea!

SNOBOL4 (CSNOBOL4) , 53 bytes

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

Pruébalo en línea!

Toma datos como Pivot, luego Main, separados por una nueva línea.

Este es básicamente el equivalente SNOBOL de mi R respuesta .

Perl 6 , 31 bytes

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

Pruébalo

PHP, 62 bytes

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

requiere PHP 7.1; puede fallar si el pivote contiene caracteres especiales regex ( \+*?[^]$(){}=!<>|:-).
sin cambios si Pivot está vacío, salida vacía si Pivot no está en la entrada.
Corre con-n .

versión segura, 77 bytes:

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

sin cambios si Pivot está vacío, salida vacía si Pivot no está en la entrada.
Corre con-n .

versión no regex, 71 bytes:

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

produce advertencias si el Pivot está vacío; no cambia si Pivot no está en la entrada.

Corre con -nr.

Pruébalos en línea .

Rojo , 63 bytes

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

Pruébalo en línea!

Rápido , 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))}

Explicación (sin golf)

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

Pruébalo en línea!

C ++ 11, 64 bytes

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

Una lambda, que captura las cadenas s, p y a, con a como referencia (in-out).

Código de prueba

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

Limpio , 83 bytes

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

A Stringen Clean normalmente es {#Char}una matriz unboxed ( #) Char( {}). Esta función toma en [Char]lugar de String, que es una segunda versión válida deString .

La firma de la función completa es f :: [.t] .t -> [.t] | [.t <= Char].

Pruébalo en línea!

Japt , 8 7 bytes

£Zg°Y}V

Pruébalo aquí