Arka fon

Şu anda bir AP Comp Sci A: Java sınıfındayım ve bazı arkadaşlarımı kod golf konusunda başlatmak istiyorum. Kurstan bir meydan okumam var ve topluluğun bu meydan okumayı kaç bayt yapabileceğini görmek istiyorum.

Zorluk detayları:

İki giriş dizesi (ana dize ve pivot dizesi) verildiğinde aşağıdakileri yapın:

Pivot dizesi tam olarak bir kez ana dizenin bir alt dizesi ise, ana dizenin pivot dizesinden önce gelen kısmı, söz konusu alt diziler içindeki sırayı korurken, pivot dizesinden önce gelen parça ile değiştirilir .

Örneğin:

Pivot dize boş veya Pivot dize ise değil ana dize içinde bulunan program tanımlı davranışa sahip olmak zorunda değildir.

Pivot dizesinin birden fazla örneği varsa, bölünme, pivotun ilk ve yalnızca ilk örneğinde gerçekleşmelidir.

Örnekler: Ana dize OneTwoThreeTwoOneve pivot dize Twoverildiğinde, çıktı olmalıdır ThreeTwoOneTwoOne.

Ana dize 1Two2Two3Two4ve pivot göz önüne alındığında, Twoçıktı olmalıdır 2Two3Two4Two1.

Ana dize OneTwoThreeve pivot dize "Two" verildiğinde, çıktı olmalıdır ThreeTwoOne. Ana dize the rabbit is faster than the turtleve pivot dizesi verildiğinde

 is faster than 

(tek boşluk sonunu ve öncesini not edin), çıkış olmalıdır the turtle is faster than the rabbit.

Ana dize 1-2-3-4-5-6ve pivot verildiğinde, -çıktı olmalıdır 2-3-4-5-6-1.

Sonsöz:

Bu kod golf hakkında ilk sorum, bu yüzden önerileriniz veya yapıcı eleştirileriniz varsa, bunu söylemekten çekinmeyin.

Ayrıca, bu proje için kodum (derse odaklandığı için Java ile yazılmış) aşağıda bulunabilir. Eğer herhangi bir ipucu varsa, onları görmek isterim. Şu anda 363 bayt, ama eminim sizler çok daha iyi ve daha küçük çözümler üretebilirsiniz.

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

Not: Girişler ve pivot dizesinin bulunmadığı durumlar için metin, orijinal atama için zorunludur, ancak bu sınama için zorunlu değildir.

Mathematica, 42 bayt

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

Çevrimiçi deneyin!

Jöle , 6 bayt

œṣṙ1j⁴

Çevrimiçi deneyin!

açıklama

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

Python 2 , 37 39 bayt

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

aAna dize ve bpivot dizesi nerede .

Çevrimiçi deneyin!

Wolfram Dili (Mathematica) , 34 bayt

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

Çevrimiçi deneyin!

Önce pivot ve ikinci olarak ana dize ile çağrılması gereken adlandırılmamış, curried bir işlev. Örneğin, işlevi bir ada atadıysanız f:

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

Ohm v2 , 4 bayt

ïλ⁴j

Çevrimiçi deneyin!

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

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

Çevrimiçi deneyin!

İlk satırdaki pivot dizesini, sonra ikinci satırdaki tam dizeyi alır.

Python 2 , 53 44 bayt

bazı baytlar için ThePlasmaRailgun'a teşekkürler

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

Çevrimiçi deneyin!

Python 2 , 37 bayt

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

Çevrimiçi deneyin!

C # (Görsel C # Derleyici) , 56 bayt

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

Çevrimiçi deneyin!

Alice , 18 bayt

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

Çevrimiçi deneyin!

açıklama

/...
\...@/

Bu yalnızca doğrusal Ordinal mod (dize işleme) kodu için bir çerçevedir. Zikzak kontrol akışını açarken:

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

Try it Here!

Explanation:

Θ      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 to Martin Ender for -1 byte

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

Try it online!

Python 2, 48 bytes

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

Try it online!

Pyth, 8 bytes

jQ.<cEQ1

Try it here!

Explanation

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.

Charcoal, 13 bytes

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

Try it online! Link is to verbose version of code. Explanation:

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

Try it online!

M is the main string, P is the pivot.

ovs' Retina answer indicated that I could repair my earlier attempt at a regex approach

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

by adding ? to the first capture group.

Java 8, 47 bytes

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

Try it online

JavaScript (ES6), 41 40 bytes

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

Test cases

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

How it works:

The left argument is the pivot, the right one - the string to be reversed

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

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

Try it online!

SNOBOL4 (CSNOBOL4), 53 bytes

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

Try it online!

Takes input as Pivot, then Main, separated by a newline.

This is basically the SNOBOL equivalent of my R answer.

Perl 6, 31 bytes

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

Test it

PHP, 62 bytes

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

requires PHP 7.1; may fail if the pivot contains regex special chars (\+*?[^]$(){}=!<>|:-).
no changes if Pivot is empty, empty output if Pivot is not in input.
Run with -n.

safe version, 77 bytes:

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

no changes if Pivot is empty, empty output if Pivot is not in input.
Run with -n.

non-regex version, 71 bytes:

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

yields warnings if the Pivot is empty; no change if Pivot is not in input.

Run with -nr.

Try them online.

Red, 63 bytes

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

Try it online!

Swift, 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))}

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

Try it online!

C++11, 64 bytes

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

A lambda, which captures the strings s, p and a, with a as a reference (in-out).

Test code

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

Clean, 83 bytes

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

A String in Clean is normally {#Char} - an unboxed (#) Char array ({}). This function takes [Char] instead of String, which is a second, valid version of String.

The full function signature is f :: [.t] .t -> [.t] | [.t <= Char].

Try it online!

Japt, 8 7 bytes

£Zg°Y}V

Try it here