एक धुरी के चारों ओर एक स्ट्रिंग के दो खंडों को उल्टा करें

Question

पृष्ठभूमि

मैं वर्तमान में AP Comp Sci A: Java वर्ग में हूं, और मैं अपने कुछ दोस्तों को कोड गोल्फिंग पर शुरू करना चाहता हूं। मेरे पास पाठ्यक्रम से एक चुनौती है, और मैं यह देखना चाहूंगा कि समुदाय इस चुनौती को कितने बाइट्स में कर सकता है।

चुनौती का विवरण:

दो इनपुट स्ट्रिंग्स, मुख्य स्ट्रिंग और पिवट स्ट्रिंग को देखते हुए, निम्न कार्य करें:

यदि पिवट स्ट्रिंग मुख्य स्ट्रिंग के विकल्प के रूप में एक बार होती है, तो मुख्य स्ट्रिंग का हिस्सा जो पिवट स्ट्रिंग से पहले आता है उसे उस भाग के साथ स्वैप किया जाएगा, जबकि ऑर्डर को संरक्षित करते हुए कहा गया कि सबट्रेप को स्वैप किया जा रहा है ।

उदाहरण के लिए:

यदि पिवट स्ट्रिंग खाली है या पिवट स्ट्रिंग मुख्य स्ट्रिंग के भीतर नहीं पाई जाती है, तो प्रोग्राम को परिभाषित व्यवहार नहीं करना पड़ता है।

यदि पिवट स्ट्रिंग के एक से अधिक उदाहरण हैं, तो विभाजन पिवट के पहले और केवल पहले उदाहरण में होना चाहिए ।

उदाहरण: मुख्य स्ट्रिंग OneTwoThreeTwoOneऔर धुरी स्ट्रिंग को देखते हुए Two, आउटपुट होना चाहिए ThreeTwoOneTwoOne।

मुख्य स्ट्रिंग 1Two2Two3Two4और धुरी को देखते हुए Two, आउटपुट होना चाहिए 2Two3Two4Two1।

मुख्य स्ट्रिंग OneTwoThreeऔर धुरी स्ट्रिंग "दो" को देखते हुए , आउटपुट होना चाहिए ThreeTwoOne। मुख्य स्ट्रिंग the rabbit is faster than the turtleऔर धुरी स्ट्रिंग को देखते हुए

 is faster than 

(एकल स्थान अनुगामी और पूर्ववर्ती पर ध्यान दें), आउटपुट होना चाहिए the turtle is faster than the rabbit।

मुख्य स्ट्रिंग 1-2-3-4-5-6और धुरी को देखते हुए -, आउटपुट होना चाहिए 2-3-4-5-6-1।

उपसंहार:

कोड गोल्फ पर यह मेरा पहला प्रश्न है, इसलिए यदि आपके पास कोई सुझाव या रचनात्मक आलोचना है, तो ऐसा कहने के लिए स्वतंत्र महसूस करें।

इसके अतिरिक्त, इस परियोजना के लिए मेरा कोड (जावा में लिखा गया है क्योंकि पाठ्यक्रम उस पर केंद्रित है) नीचे पाया जा सकता है। यदि आपके पास कोई सुझाव है, तो मैं उन्हें देखना पसंद करूंगा। इसके वर्तमान में 363 बाइट्स हैं, लेकिन मुझे यकीन है कि आप लोग बेहतर और छोटे समाधानों के साथ आ सकते हैं।

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

नोट: इनपुट के लिए पाठ और उस स्थिति के लिए जिसे पिवट स्ट्रिंग नहीं मिली है, मूल असाइनमेंट के लिए अनिवार्य है, लेकिन इस चुनौती के लिए नहीं।

Comments

pivot='-'और के लिए अपेक्षित आउटपुट क्या है main='1-2-3-4-5-6'? इसके लिए अधिकांश सबमिशन आउटपुट 2-3-4-5-6-1, लेकिन जैसा कि मैं समझता हूं कि यह चुनौती होनी चाहिए 2-1-3-4-5-6।

— ओव्स

यह केवल पहली धुरी पर स्ट्रिंग को विभाजित करना चाहिए । तो इरादा उत्पादन होना चाहिए 2-3-4-5-6-1।

— thePlasmaRailgun

वैसे, आप अगली बार सैंडबॉक्स का उपयोग कर सकते हैं ।

— आउटगोल्फर

मुझे लगता है कि जोर "कहा जा रहा है, जबकि उपप्रकारों को अदला-बदली करने के क्रम में" बस इसे और अधिक भ्रमित किया गया। मैं इसे पहले से ही इस तरह से समझता हूं, लेकिन शब्दांकन ने इसे भ्रमित कर दिया अगर आपका मतलब है।

— kamoroso94

Answer 1

गणितज्ञ, 42 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 2

जेली , 6 बाइट्स

œṣṙ1j⁴

इसे ऑनलाइन आज़माएं!

व्याख्या

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

Comments

वाह, कोई स्पष्टीकरण का कोई मौका? वह अभूतपूर्व है!

— thePlasmaRailgun

@ ThePlasmaRailgun यह वह अभूतपूर्व नहीं है, वास्तव में: पी - जेली में उपयोगी बिल्ट-इन है: œṣ" वाई के बराबर सब्लिस्ट्स के चारों ओर विभाजित एक्स ", सरणी को बाईं ओर एक स्थान पर घुमाता है और दूसरे इनपुट के साथ जुड़ता है। ṙ1j⁴

— श्री Xcoder

@ ThePlasmaRailgun अब स्पष्टीकरण जोड़ रहा है। लेकिन जेली के लिए यह अत्यंत प्रभावशाली xD भी नहीं है

— HyperNeutrino

अच्छा लगा। मुझे यह पसंद है।

— thePlasmaRailgun

Answer 3

पायथन 2 , 37 39 बाइट्स

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

जहां aमुख्य स्ट्रिंग है और bधुरी स्ट्रिंग है।

इसे ऑनलाइन आज़माएं!

Comments

यह निर्दिष्ट split(b)करने के split(b,1)लिए परिवर्तित करें कि आप केवल पहले परिवर्तन पर विभाजन करना चाहते हैं।

— १

@ovs, तीसरे टेस्ट केस में काम करने के लिए संपादित

— wnnmaw 18

@mypetlion, मुझे नहीं पता कि splitअधिक तर्क स्वीकार किए जाते हैं, धन्यवाद!

— 18

Answer 4

वोल्फ्राम भाषा (गणितज्ञ) , 34 बाइट्स

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

इसे ऑनलाइन आज़माएं!

एक अनाम, करी हुई फ़ंक्शन जिसे धुरी के साथ बुलाया जाना चाहिए पहला और मुख्य स्ट्रिंग दूसरा। उदाहरण के लिए, यदि आपने फ़ंक्शन को एक नाम दिया है f:

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

Answer 5

ओम v2 , 4 बाइट्स

ïλ⁴j

इसे ऑनलाइन आज़माएं!

Comments

@ ThePlasmaRailgun जेली के रूप में ही, सिर्फ छोटे बिल्ट-इन्स

— Mr. Xcoder

Answer 6

पर्ल 5 , 20 + 2 (-pl ) = 22 बाइट्स

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

इसे ऑनलाइन आज़माएं!

पहली पंक्ति पर धुरी स्ट्रिंग लेता है, फिर दूसरी पर पूर्ण स्ट्रिंग।

Comments

तर्कों के साथ खेलने पर मुझे यह 20 बाइट्स समाधान मिला , अन्यथा /एस $_को हटाया जा सकता है

— नाहुले फौइउल

यह भी $_=~<>;$_="$'$&$`` 20 बाइट्स हैं और सही क्रम में तर्क पढ़ता है

— नहुएल फौलीउल

Answer 7

पायथन 2 , 53 44 बाइट्स

कुछ बाइट्स के लिए ThePlasmaRailgun का धन्यवाद

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

इसे ऑनलाइन आज़माएं!

Comments

धुरी "दो" और स्ट्रिंग "1Two2Two3Two4" के साथ आपके परीक्षण के मामले में आउटपुट "2Two3Two4Two1" होना चाहिए। यह केवल पहले "दो" पर विभाजित होना चाहिए, आपको सरणी ["1", "2Two3Two4Two" छोड़कर]। तब आप बस कर सकते हैं print k[1]+p+k[0]। यह अभिप्रेत व्यवहार होना चाहिए।

— thePlasmaRailgun

फिक्स्ड। मैं लोगों को यह दिखाने के लिए एक उदाहरण परीक्षण मामला जोड़ने जा रहा हूं कि यह कैसा होना चाहिए।

— thePlasmaRailgun

@ ThePlasmaRailgun अगली बार जब आप किसी उत्तर को बेहतर बनाना चाहते हैं तो एक टिप्पणी छोड़ दें और सेशन को इसमें संपादित करें।

— 18

अपने स्पष्टीकरण के लिए @ThePlasmaRailgun धन्यवाद

— OVS

k,j=m.split(p,1);print j,p,k38 बाइट्स के लिए दूसरी और तीसरी लाइनें बन जाती हैं।

— म्युटेलियन

Answer 8

पायथन 2 , 37 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 9

सी # (विजुअल सी # कंपाइलर) , 56 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 10

ऐलिस , 18 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

/...
\...@/

यह रैखिक ऑर्डिनल मोड (स्ट्रिंग-प्रोसेसिंग) कोड के लिए सिर्फ एक रूपरेखा है। ज़िगज़ैग नियंत्रण प्रवाह को बंद करने पर, हमें यह मिलता है:

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

Answer 11

SOGL V0.12 , 9 5 बाइट्स

ΘK+,∑

यह कोशिश करो!

स्पष्टीकरण:

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

Answer 12

रेटिना , २४ 23 बाइट्स

-1 बाइट के लिए मार्टिन एंडर को टैंक

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

इसे ऑनलाइन आज़माएं!

Answer 13

पायथन 2 , 48 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 14

पायथ , 8 बाइट्स

jQ.<cEQ1

यहाँ यह कोशिश करो!

व्याख्या

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.

Answer 15

चारकोल , 13 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

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

Answer 16

आर , 63 58 57 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Mमुख्य तार Pहै, धुरी है।

ओव्स रेटिना जवाब ने संकेत दिया कि मैं अपने पहले प्रयास को एक रेक्सएक्स दृष्टिकोण पर मरम्मत कर सकता हूं

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

?पहले कैप्चर ग्रुप में जोड़कर ।

Answer 17

जावा 8, 47 बाइट्स

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

इसे ऑनलाइन आज़माएं

Comments

बदल दिया गया है कि जगह से बदल दें क्योंकि 2 बाइट्स छोटी होती हैं और जैसे ही

— रेग्क्स

Answer 18

जावास्क्रिप्ट (ईएस 6), 41 40 बाइट्स

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

परीक्षण के मामलों

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', '-'))

Answer 19

जे , 14 बाइट्स

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

यह काम किस प्रकार करता है:

बायाँ तर्क धुरी है, दायें वाला - उल्टा होने का तार

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

इसे ऑनलाइन आज़माएं!

Answer 20

सी,  106  100 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 21

SNOBOL4 (CSNOBOL4) , 53 बाइट्स

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

इसे ऑनलाइन आज़माएं!

धुरी के रूप में इनपुट लेता है, फिर मेन, एक नई रेखा द्वारा अलग किया जाता है।

यह मूल रूप से मेरे R उत्तर के SNOBOL के बराबर है ।

Answer 22

पर्ल 6 , 31 बाइट्स

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

झसे आज़माओ

Answer 23

PHP, 62 बाइट्स

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

PHP 7.1 की आवश्यकता है; धुरी regex विशेष वर्ण ( \+*?[^]$(){}=!<>|:-) शामिल हैं, तो विफल हो सकता है ।
यदि पिवट इनपुट में नहीं है तो पिवट खाली है, खाली आउटपुट है तो कोई बदलाव नहीं।
के साथ चला -n।

सुरक्षित संस्करण, 77 बाइट्स:

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

यदि पिवट इनपुट में नहीं है तो पिवट खाली है, खाली आउटपुट है तो कोई बदलाव नहीं।
के साथ चला -n।

नॉन-रेगेक्स संस्करण, 71 बाइट्स:

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

पिवट खाली होने पर चेतावनी देता है; पिवट इनपुट में नहीं है तो कोई परिवर्तन नहीं।

के साथ चला -nr।

उन्हें ऑनलाइन प्रयास करें ।

Answer 24

लाल , 63 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 25

स्विफ्ट , 131 बाइट्स

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

स्पष्टीकरण (अपुष्ट)

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
}

Answer 26

सी (जीसीसी) , 76 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 27

सी ++ 11, 64 बाइट्स

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

एक लंबोदर, जो एक संदर्भ (इन-आउट) के साथ स्ट्रिंग्स एस, पी और ए को कैप्चर करता है।

टेस्ट कोड

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

Answer 28

क्लीन , 83 बाइट्स

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

ए Stringइन क्लीन आम तौर पर है {#Char}- एक अनबॉक्स ( #) Charसरणी ( {})। यह फ़ंक्शन [Char]इसके बजाय लेता है String, जिसका दूसरा, मान्य संस्करण हैString ।

पूर्ण फ़ंक्शन हस्ताक्षर है f :: [.t] .t -> [.t] | [.t <= Char]।

इसे ऑनलाइन आज़माएं!

Answer 29

जाप , 8 7 बाइट्स

£Zg°Y}V

इसे यहाँ आज़माएँ