_{Lưu ý: tiêu đề đã sai chính tả.}

Cho một chuỗi s, hoán đổi các nguyên âm đầu tiên chạy của mỗi 2 từ. Đối với thử thách này, y được coi là một nguyên âm.

Ví dụ: đưa ra một đầu vào của "ngày tuyệt vời thưa ngài":

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"

Khi có các nguyên âm chạy với độ dài khác nhau, bạn vẫn trao đổi toàn bộ các lần chạy. Khi một từ có nhiều nguyên âm chạy, bạn vẫn chỉ trao đổi từ đầu tiên. Khi từ đầu tiên hoặc từ thứ hai của một cặp từ không có nguyên âm, thì bạn không trao đổi nguyên âm cho các từ đó.

Bạn có thể giả sử rằng đầu vào chỉ bao gồm một trường hợp chữ cái và không gian bằng chữ hoặc dấu phân cách không đổi khác.

Phương pháp tiêu chuẩn của I / O, áp dụng sơ hở tiêu chuẩn. Người dẫn đầu / dấu vết là ổn.

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

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"

V , 42 , 41 byte

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

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

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

Giải trình:

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

Điều này sẽ đặt tất cả các nhóm của hai từ trên dòng riêng của chúng, ví dụ:

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

Bây giờ chúng tôi chạy một số ma thuật regex ưa thích:

Í                                           " 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

Japt , 39 37 byte

Họ nói nó sẽ xấu, nhưng tôi không nghe ... và đó là:

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

Kiểm tra nó trực tuyến!

Giải trình

 ¸  ò ® 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

JavaScript (ES6), 62 106 98 101 byte

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

Võng mạc , 65 byte

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

Hãy thử trực tuyến! Bao gồm các trường hợp thử nghiệm. Tôi muốn sử dụng một tham chiếu nhóm có điều kiện nhưng tôi không thể làm cho nó hoạt động trong 66 byte chứ đừng nói đến 65 hoặc ít hơn.

Võng mạc , 50 byte

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

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

Byte2 byte nhờ Martin.

• Bước đầu tiên là tách từng cặp từ thành dòng riêng ( ¶là dòng mới). Điều này cho phép chúng tôi sử dụng .*trong một cặp từ.
• Tiếp theo, với mỗi dòng, chúng tôi tìm thấy khối nguyên âm đầu tiên trong mỗi từ và sắp xếp chúng theo vị trí theo thứ tự giảm dần.

Python 2 , 148 byte

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

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

Code Golfing đang gây nghiện!

Phần tách ra các cặp từ, sau đó lấy 2 nhóm nguyên âm và chuỗi ở giữa, đảo ngược thứ tự và sử dụng từ đó để thay thế .

Haskell , 177 173 171 169 byte

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)

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

Đây là một sự rút ngắn trực tiếp của giải pháp ngây thơ sau đây, vì vậy cần có một cái gì đó tốt hơn nhiều ở đây:

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)

Java (OpenJDK 8) ,363 304 + 25 byte

-34 byte nhờ @KevinCruijssen

Chơi gôn

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

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

Ung dung:

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

Perl, 58 byte

Mã 57 byte + 1 cho -p.

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

-2 byte nhờ @Dada !

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

Ruby, 87 + 1 = 88 byte

Sử dụng -pcờ.

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

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

Python 3 , 198 196 192 byte

• Đã lưu 6 byte: nhờ Zachary T : if(m and n)nếu m và n & loại bỏ r không mong muốn cho chuỗi regex, chỉ mục i bắt đầu từ 1 thay vì 0

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

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