स्वैप थ स्वर!

Question

_{नोट: शीर्षक जानबूझकर गलत तरीके से लिया गया था।}

एक स्ट्रिंग s को देखते हुए, प्रत्येक 2 शब्दों के पहले स्वर रन को स्वैप करें। इस चुनौती के लिए, y को एक स्वर माना जाता है।

उदाहरण के लिए, "ग्रेट डे सर" का एक इनपुट दिया गया:

1. Input: "great day sir"
2. Identify pairs of words: "[great day] [sir]" (No word for sir to pair with)
3. Identify the first vowel runs in each word: "[gr[ea]t d[ay]] [s[i]r]"
4. Swap the vowel runs in each pair: "[gr[ay]t d[ea]] [s[i]r]"
5. Return/print: "grayt dea sir"

जब अलग-अलग लंबाई के स्वर रन होते हैं, तब भी आप पूरे रन को स्वैप करते हैं। जब किसी शब्द में एक से अधिक स्वर चलते हैं, तब भी आप केवल पहले वाले को ही स्वैप करते हैं। जब किसी शब्द के पहले या दूसरे शब्द में स्वर नहीं होता है, तो आप उन शब्दों के लिए स्वरों की अदला-बदली नहीं करते हैं।

आप मान सकते हैं कि इनपुट में केवल वर्णमाला के अक्षरों का एक मामला और शाब्दिक स्थान या एक अन्य निरंतर सीमांकक शामिल है।

I / O के मानक तरीके, मानक खामियां लागू होते हैं। अग्रणी / अनुगामी क्या ठीक है।

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

Input -> Output

"great day sir" -> "grayt dea sir"
"ppcg is the best" -> "ppcg is the best" (When there is no vowel to swap, don't swap vowels."
"this is a test case" -> "this is e tast case"
"loooooooooooooong word" -> "long woooooooooooooord"
"great night" -> "grit neaght"
"anything goes" -> "oenything gas"
"qwrtpsdfghjklzxcvbnm aaaaaaaa hi there" -> "qwrtpsdfghjklzxcvbnm aaaaaaaa he thire"
"this is a long test case in case you could not tell" -> "this is o lang tast cese an cise ou cyould net toll"

Comments

जो लोग हटाए गए पोस्ट देख सकते हैं, उनके लिए सैंडबॉक्स पोस्ट यहां था ।

— कॉमरेड स्पार्कलपनी 20

यदि पहले शब्द में कोई स्वर नहीं है, तो क्या दूसरे और तीसरे शब्दों के स्वर को स्वैप करना ठीक है? या स्वर केवल दो शब्दों के रन के बीच स्वैप कर सकते हैं? उदाहरण के लिए, ppcg is awesomeबनना चाहिए ppcg is awesomeया ppcg as iwesome?

— DJMcMayhem

@DJMcMayhem स्वर केवल दो शब्दों के रन के बीच स्वैप कर सकते हैं। मैं संपादित करूंगा।

— कॉमरेड स्पार्कलेपनी

मेरा मानना ​​है कि उत्पादन this is a long test case in case you could not tellहोना चाहिए this is o lang tast cese an cise ou cyould net toll, क्योंकि स्वर चलता है youऔर ouउसकी अदला-बदली होगी।

— बशफुल बेलुगा

@ बाशफुलगुफा येप, मेरी गलती है। मैं ठीक कर दूँगा।

— कॉमरेड स्पार्कलपनी

Answer 1

वी , 42 , 41 बाइट्स

ò2Eá
òͨ[aeiouy]«©¨ƒ ƒ©¨[aeiouy]«©/³²±
Íî

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

Hexdump:

00000000: f232 45e1 0af2 cda8 5b61 6569 6f75 795d  .2E.....[aeiouy]
00000010: aba9 a883 2083 a9a8 5b61 6569 6f75 795d  .... ...[aeiouy]
00000020: aba9 2fb3 b2b1 0acd ee                   ../......

स्पष्टीकरण:

ò       ò                                   " Recursively:
 2E                                         "   Move to the end of two words forward
   á<cr>                                    "   And append a newline

यह दो शब्दों के सभी समूहों को अपनी-अपनी पंक्ति में रखेगा, उदाहरण के लिए:

this is
a long
test case
in case
you could
not tell

अब हम कुछ फैंसी रेगेक्स-मैजिक चलाते हैं:

Í                                           " Globally substitute
 ¨[aeiouy]«©                                "   A vowel (capture group 1)
            ¨<131>                          "   Followed by as few characters as possible, then a space
                   <131>©                   "   Followed by as few characters as possible (capture group 2)
                         ¨[aeiouy]«©        "   Followed by a vowel again
                                    /       " With:
                                     ³²±    "   Capture groups '3', '2', '1'
Í                                           " Remove all:
 î                                          "   Newlines

Comments

आपके regex को आपके दो स्वर समूहों के बीच एक शब्द के अंत की आवश्यकता नहीं है। इसे ऑनलाइन आज़माएं!

— nmjcman101

@ nmjcman101 क्या आप मेरे पुराने संशोधन को देख रहे हैं? क्योंकि है कि वास्तव में क्या मैं अभी

— DJMcMayhem

मेरा TIO लिंक कुछ भी ठीक नहीं कर रहा था, मैंने अभी इनपुट बदला है। यह अक्षरों को अजीब तरीके से स्वैप करता है।

— nmjcman101

@ nmjcman101 आह, मैं देख रहा हूं। अब तय!

— DJMcMayhem

Answer 2

जाप , ३ ९ 37 बाइट्स

उन्होंने कहा कि यह बदसूरत होगा, लेकिन मैंने नहीं सुना ... और यह था:

¸ò ®efQ="%y+" ?Z£XrQZg°T fQP PÃ:ZÃc ¸

इसे ऑनलाइन टेस्ट करें!

व्याख्या

 ¸  ò ® efQ="%y+" ?Z£    XrQ    Zg° T fQ    P PÃ :ZÃ c ¸
UqS ò mZ{Zef"%y+" ?ZmXYZ{Xr"%y+"Zg++T f"%y+"P P} :Z} c qS
             Implicit: U = input string, such as     "abc def ghi jkl mno"
UqS          Split on spaces, splitting into words.  ["abc","def","ghi","jkl","mno"]
ò            Group into runs of two items.           [["abc","def"],["ghi","jkl"],["mno"]]
mZ{          For each pair Z:
 Zef"%y+"?     If not every item contains a run of vowels (%y = [AEIOUYaeiouy]),
 :Z            return Z.                             [              ["ghi","jkl"]        ]
 ZmXYZ{        Otherwise, for each item X in Z:
  Xr"%y+"        Replace each run of vowels with
  Zg++T           the item at the next index in Z,   [["def","abc"]               ["mno"]]
  f"%y+"P         but only the first run of vowels.  [["e",  "a"  ]               ["o"  ]]
  P              Replace only for the first match.   [["ebc","daf"]               ["mno"]]
 }
}                                                    [["ebc","daf"],["ghi","jkl"],"mno"]]
c            Flatten back into a single array.       ["ebc","def","ghi","jkl","mno"]
qS           Re-join on spaces.                      "ebc daf ghi jkl mno"
             Implicit: output result of last expression

Answer 3

जावास्क्रिप्ट (ईएस 6), 62 106 98 101 बाइट्स

s=>s.match(/(\w+)( (\w+))?/g).map(m=>m.replace(/([aeiouy]+)(\w* \w*?)([aeiouy]+)/g,'$3$2$1')).join` `

f=
s=>s.match(/(\w+)( (\w+))?/g).map(m=>m.replace(/([aeiouy]+)(\w* \w*?)([aeiouy]+)/g,'$3$2$1')).join` `
;

[
  "great day sir",
  "ppcg is the best",
  "this is a test case",
  "loooooooooooooong word",
  "great night",
  "anything goes",
  "qwrtpsdfghjklzxcvbnm aaaaaaaa hi there",
].map(f).map(s=>console.log(s))

Answer 4

रेटिना , 65 बाइट्स

((\w*?)([aeiouy]+)(\w* \w*?)([aeiouy]+)|(\w+ ))(\w*)
$2$5$4$3$6$7

इसे ऑनलाइन आज़माएं!परीक्षण मामलों में शामिल हैं। मैं एक सशर्त समूह संदर्भ का उपयोग करना चाहता था, लेकिन मैं इसे 66 बाइट्स में अकेले 65 या उससे कम काम नहीं कर सका।

Answer 5

रेटिना , 50 बाइट्स

\S+ \S+ 
$&¶
%O$^`(?<=\b[^aeiouy]*)[aeiouy]+
$`
¶

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

मार्टिन के लिए −2 बाइट्स धन्यवाद।

• पहला चरण प्रत्येक शब्द जोड़े को अपनी रेखा में विभाजित कर रहा है (¶ न्यूलाइन है)। यह हमें उपयोग करने की अनुमति देता है.* शब्दों की एक जोड़ी के भीतर ।
• अगला, प्रत्येक पंक्ति के लिए हम प्रत्येक शब्द में पहला स्वर ब्लॉक पाते हैं, और उन्हें अवरोही क्रम में स्थिति के अनुसार क्रमबद्ध करते हैं।

Comments

मैंने दोहरे को हटाने की कोशिश की [aeiouy]+लेकिन कुछ आर्थिक नहीं हो सका।

— कोबी

यह थोड़े चरण के साथ रन स्वैप करने के लिए मामूली रूप से छोटा है: tio.run/…

— मार्टिन

@MartinEnder - एक अच्छा! मैं काम करने के लिए छँटाई नहीं कर सका। मैंने एक और संस्करण की कोशिश की जिसने [aeiouy]दोहराव को हटा दिया , लेकिन मैं इसे नीचे नहीं कर सकता। मुझे लगता है कि यह आपके सुझाव के साथ अच्छी तरह से काम कर सकता है: tio.run/…

— Kobi

Answer 6

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

from re import*
v="([aeiouy]+)"
print sub(r"(\w+)(?: (\w+))?",lambda m:sub(v+"(.* .*?)"+v,lambda g:''.join(g.groups()[::-1]),m.group()),raw_input())

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

कोड गोल्फिंग की लत लग रही है!

शब्दों के जोड़े को खंडित करता है, फिर स्वरों के 2 समूहों को पकड़ता है और बीच में स्ट्रिंग, क्रम को उलट देता है और विकल्प के रूप में उपयोग करता है ।

Answer 7

हास्केल , 177 173 171 169 बाइट्स

unwords.s.words
s(x:y:z)=maybe[x,y]id(do(a,b)<-k x;(c,d)<-k y;j[b c,d a])++s z
s x=x
v=(`elem`"aeiouy")
j=Just
k s=do(a,(x:y,r))<-j$span v<$>break v s;j(x:y,\n->a++n++r)

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

यह निम्नलिखित भोले समाधान का एक छोटा छोटा हिस्सा है, इसलिए यहां कुछ बेहतर होना चाहिए:

swapvowels :: String -> String
swapvowels = unwords . swapPairs . words

swapPairs :: [String] -> [String]
swapPairs (word1:word2:rest) =
   case (,) <$> extractVowels word1 <*> extractVowels word2 of
     Just ((vowels1, rebuild1), (vowels2, rebuild2))
       -> [rebuild1 vowels2, rebuild2 vowels1] ++ swapPairs rest
     Nothing -> [word1,word2] ++ swapPairs rest
swapPairs rest = rest

extractVowels :: String -> Maybe (String, String -> String)
extractVowels s = do
    let isVowel l = l `elem` "aeiouy"
    (a,b) <- Just $ break isVowel s 
    (w@(_:_),r) <- Just $ span isVowel b 
    return (w, \n -> a ++ n ++ r)

Answer 8

जावा (ओपनजेडके 8) ,363 304 + 25 बाइट्स

-34 बाइट्स का शुक्रिया @KevinCruijssen

golfed:

l->{String s[]=l.split(" "),a,b;Pattern p=Pattern.compile("[aeiouy]+");for(int i=0;i<s.length-1;i+=2){Matcher m=p.matcher(s[i]),n=p.matcher(s[i+1]);a=m.find()?m.group():null;b=n.find()?n.group():null;if(a!=null&b!=null){s[i]=s[i].replaceFirst(a,b);s[i+1]=s[i+1].replaceFirst(b,a);}}return l.join(" ",s);}

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

Ungolfed:

String swapVowels(String line) {
    String[] parts = line.split(" ");
    Pattern pattern = Pattern.compile("([aeiouy]+)");
    for (int i = 0; i < parts.length - 1; i += 2) {
        Matcher matcherL = pattern.matcher(parts[i]), matcherR = pattern.matcher(parts[i + 1]);
        String vowelRunL = matcherL.find() ? matcherL.group() : null, vowelRunR = matcherR.find() ? matcherR.group() : null;
        if (vowelRunL != null & vowelRunR != null) {
            parts[i] = parts[i].replaceFirst(vowelRunL, vowelRunR);
            parts[i + 1] = parts[i + 1].replaceFirst(vowelRunR, vowelRunL);
        }
    }
    return String.join(" ", parts);
}

Comments

आप इनपुट ( (l)->से l->) के आसपास कोष्ठक को हटा सकते हैं । आप import java.util.regex.*;बाइट-गिनती में जोड़ सकते हैं , और अन्य सभी को हटा सकते हैं java.util.regex.। आप कोष्ठक ( "([aeiouy]+)"-> "[aeiouy]+") में कोष्ठक हटा सकते हैं । और अगर आप बदल सकते हैं String[]s=l.split(" ");करने के लिए String s[]=l.split(" "),a,b;है, तो आप निकाल सकते हैं Stringअंदर के लिए लूप; और अगर आप बदल सकते हैं String.join(" ",s);करने के लिए l.join(" ",s);।यहाँ यह सब संयुक्त है। [ 329 बाइट्स ]

— केविन क्रूज़सेन

@KevinCruijssen वास्तव में! संपादित, धन्यवाद! :-)

— बैशफुल बेलुगा

Answer 9

पर्ल, 58 बाइट्स

57 बाइट्स कोड + 1 के लिए -p।

$v="([aeiouy]+)";s!\w+ \w+!$&=~s/$v(.* .*?)$v/$3$2$1/r!ge

-2 बाइट्स @ दादा को धन्यवाद !

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

Comments

बस एक जोड़े को छोड़ने ?और ([aeiouy]+)एक चर में संग्रहीत करके बचाने के लिए बाइट्स के एक जोड़े : इसे ऑनलाइन आज़माएं!

— दादा

Answer 10

रूबी, 87 + 1 = 88 बाइट्स

-pझंडे का उपयोग करता है ।

gsub(/(\w+) (\w+)/){_,a,b=*$~;a[r=/[aeiouy]+/]&&b[r]?a.sub(r,b[r])+' '+b.sub(r,a[r]):_}

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

Answer 11

पायथन 3 , 198 196 192 बाइट्स

• सहेजे गए 6 बाइट्स: Zachary टी के लिए धन्यवाद : if(m and n)यदि मी और n और रेगेक्स स्ट्रिंग के लिए अवांछित आर हटा दिया जाता है, तो इंडेक्स I 0 के बजाय 1 से शुरू होता है

from re import*
s=search
a=input().split()
v="[aeiouy]+"
j=1
while j<len(a):
 i=j-1;m=s(v,a[j]);n=s(v,a[i])
 if m and n:a[i]=sub(v,m[0],a[i],1);a[j]=sub(v,n[0],a[j],1)
 j+=2
print(' '.join(a))

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

Comments

मुझे लगता है कि आप अपने प्रोग्राम बंद तीन बाइट्स दाढ़ी कर सकते हैं: बदल कर अपनी स्ट्रिंग से पहले आर हटाने, किसी अन्य के द्वारा एक i+1<len(a)के लिए i<=len(a), और बदलकर तीसरे if(m and n)करने के लिए if m and n।

— जकार्इ

धन्यवाद। लेकिन i+1<len(a)करने के लिए बदला नहीं जा सकता i<=len(a)वरना यह मूल्यांकन करने के लिए कोशिश करेंगे a[j]यानी a[i+1]के लिए i=len(a)और कारण index out of rangeत्रुटि:

— officialaimm

क्षमा करें, मैं पढ़ रहा था कि के रूप में i<len(a)+1, वूप्स!

— जचारि

क्या यह काम करेगा? repl.it/IlX1

— Zacharý

आपके पास अपनी कुछ लाइनों के अंत में बाहरी स्थान हैं, मैंने 192 बाइट्स गिना।

— जचारि