Lý lịch

Tôi hiện đang tham gia lớp AP Comp Sci A: Java và tôi muốn bắt đầu một số người bạn của mình chơi golf. Tôi có một thử thách từ khóa học, và tôi muốn xem cộng đồng có thể thực hiện thử thách này bao nhiêu byte.

Chi tiết thử thách:

Cho hai chuỗi đầu vào, chuỗi chính và chuỗi trục, thực hiện như sau:

Nếu chuỗi trục chính xác một lần là chuỗi con của chuỗi chính, phần của chuỗi chính đi trước chuỗi trục sẽ được hoán đổi với phần đi sau, trong khi vẫn giữ trật tự trong chuỗi phụ được nói .

Ví dụ:

Nếu chuỗi trục trống hoặc chuỗi trục không được tìm thấy trong chuỗi chính, chương trình không phải có hành vi được xác định.

Nếu có nhiều hơn một phiên bản của chuỗi trục, sự phân tách sẽ xảy ra ở lần đầu tiên và chỉ là phiên bản đầu tiên của trục.

Ví dụ: Cho chuỗi chính OneTwoThreeTwoOnevà chuỗi trục Two, đầu ra phải là ThreeTwoOneTwoOne.

Cho chuỗi chính 1Two2Two3Two4và trục Two, đầu ra phải là 2Two3Two4Two1.

Cho chuỗi chính OneTwoThreevà chuỗi trục "Hai", đầu ra phải là ThreeTwoOne. Cho chuỗi chính the rabbit is faster than the turtlevà chuỗi trục

 is faster than 

(lưu ý dấu vết không gian đơn và trước đó), đầu ra phải là the turtle is faster than the rabbit.

Cho chuỗi chính 1-2-3-4-5-6và trục -, đầu ra phải là 2-3-4-5-6-1.

Lời bạt:

Đây là câu hỏi đầu tiên của tôi về môn đánh gôn, vì vậy nếu bạn có đề xuất hoặc phê bình mang tính xây dựng, thì hãy thoải mái nói như vậy.

Ngoài ra, mã của tôi cho dự án này (được viết bằng Java vì khóa học tập trung vào đó) có thể được tìm thấy bên dưới. Nếu bạn có bất cứ lời khuyên nào, tôi rất muốn thấy chúng. Nó hiện có 363 byte, nhưng tôi cá rằng các bạn có thể đưa ra các giải pháp tốt hơn và nhỏ hơn nhiều.

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

Lưu ý: Văn bản cho các đầu vào và trong trường hợp không tìm thấy chuỗi trục là bắt buộc đối với bài tập gốc, nhưng không phải cho thử thách này.

Toán học, 42 byte

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

Hãy thử trực tuyến!

Thạch , 6 byte

œṣṙ1j⁴

Hãy thử trực tuyến!

Giải trình

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

Python 2 , 37 39 byte

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

Trong trường hợp alà chuỗi chính và blà chuỗi trục.

Hãy thử trực tuyến!

Ngôn ngữ Wolfram (Mathicala) , 34 byte

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

Hãy thử trực tuyến!

Một hàm không được đặt tên, được sử dụng nên được gọi với trục đầu tiên và chuỗi chính thứ hai. Ví dụ: nếu bạn đã gán chức năng cho một tên f:

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

Ohm v2 , 4 byte

ïλ⁴j

Hãy thử trực tuyến!

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

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

Hãy thử trực tuyến!

Lấy chuỗi trục trên dòng đầu tiên, sau đó là chuỗi đầy đủ trên dòng thứ hai.

Python 2 , 53 44 byte

cảm ơn ThePlasmaRailgun cho một số byte

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

Hãy thử trực tuyến!

Python 2 , 37 byte

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

Hãy thử trực tuyến!

C # (Trình biên dịch C # trực quan) , 56 byte

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

Hãy thử trực tuyến!

Alice , 18 byte

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

Hãy thử trực tuyến!

Giải trình

/...
\...@/

Đây chỉ là một khung cho mã chế độ tuyến tính (xử lý chuỗi) tuyến tính. Mở ra luồng điều khiển ngoằn ngoèo, chúng tôi nhận được:

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 byte

ΘK+,∑

Hãy thử nó ở đây!

Giải trình:

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

Võng mạc , 24 23 byte

xe tăng đến Martin Ender cho -1 byte

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

Hãy thử trực tuyến!

Python 2 , 48 byte

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

Hãy thử trực tuyến!

Bình thường , 8 byte

jQ.<cEQ1

Hãy thử nó ở đây!

Giải trình

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.

Than , 13 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

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

R , 63 58 57 byte

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

Hãy thử trực tuyến!

Mlà chuỗi chính, Plà trục.

Câu trả lời Retina của ovs chỉ ra rằng tôi có thể sửa chữa nỗ lực trước đó của mình theo cách tiếp cận regex

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

bằng cách thêm ?vào nhóm chụp đầu tiên.

Java 8, 47 byte

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

Dùng thử trực tuyến

JavaScript (ES6), 41 40 byte

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

Các trường hợp thử nghiệm

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 byte

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

Làm thế nào nó hoạt động:

Đối số bên trái là trục, bên phải - chuỗi được đảo ngược

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

Hãy thử trực tuyến!

C,  106  100 byte

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

Hãy thử trực tuyến!

SNOBOL4 (CSNOBOL4) , 53 byte

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

Hãy thử trực tuyến!

Lấy đầu vào là Pivot, rồi Chính, được phân tách bằng một dòng mới.

Về cơ bản, đây là SNOBOL tương đương với câu trả lời R của tôi .

Perl 6 , 31 byte

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

Kiểm tra nó

PHP, 62 byte

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

yêu cầu PHP 7.1; có thể thất bại nếu trục có chứa ký tự đặc biệt regex ( \+*?[^]$(){}=!<>|:-).
không thay đổi nếu Pivot trống, đầu ra trống nếu Pivot không có trong đầu vào.
Chạy với -n.

phiên bản an toàn, 77 byte:

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

không thay đổi nếu Pivot trống, đầu ra trống nếu Pivot không có trong đầu vào.
Chạy với -n.

phiên bản không phải regex, 71 byte:

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

mang lại cảnh báo nếu Pivot trống; không thay đổi nếu Pivot không có trong đầu vào.

Chạy với -nr.

Hãy thử chúng trực tuyến .

Màu đỏ , 63 byte

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

Hãy thử trực tuyến!

Swift , 131 byte

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

Giải thích (vô danh)

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 byte

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

Hãy thử trực tuyến!

C ++ 11, 64 byte

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

Một lambda, bắt các chuỗi s, p và a, với tư cách là một tham chiếu (vào ra).

Mã kiểm tra

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

Sạch , 83 byte

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

Một Stringtrong sạch là bình thường {#Char}- một không có hộp bọc ( #) Charmảng ( {}). Hàm này [Char]thay thế String, là phiên bản hợp lệ thứ hai của String.

Chữ ký đầy đủ chức năng là f :: [.t] .t -> [.t] | [.t <= Char].

Hãy thử trực tuyến!

Japt , 8 7 byte

£Zg°Y}V

Hãy thử nó ở đây